]>
Commit | Line | Data |
---|---|---|
3ea81e9c | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | // $Id$ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////// | |
19 | // Class AliTimestamp | |
20 | // Handling of timestamps for (astro)particle physics reserach. | |
21 | // | |
22 | // This class is derived from TTimeStamp and provides additional | |
23 | // facilities (e.g. Julian date) which are commonly used in the | |
24 | // field of (astro)particle physics. | |
25 | // | |
26 | // The Julian Date (JD) indicates the number of days since noon (UT) on | |
27 | // 01 jan -4712 (i.e. noon 01 jan 4713 BC), being day 0 of the Julian calendar. | |
28 | // | |
29 | // The Modified Julian Date (MJD) indicates the number of days since midnight | |
30 | // (UT) on 17-nov-1858, which corresponds to 2400000.5 days after day 0 of the | |
31 | // Julian calendar. | |
32 | // | |
33 | // The Truncated Julian Date (TJD) corresponds to 2440000.5 days after day 0 | |
34 | // of the Julian calendar and consequently TJD=MJD-40000. | |
35 | // This TJD date indication was used by the Vela and Batse missions in | |
36 | // view of Gamma Ray Burst investigations. | |
37 | // | |
a4f7a3a1 | 38 | // The Julian Epoch (JE) indicates the fractional elapsed Julian year count |
39 | // since the start of the Gregorian year count. | |
40 | // A Julian year is defined to be 365.25 days and starts at 01-jan 12:00:00 UT. | |
41 | // As such, the integer part of JE corresponds to the usual Gregorian year count, | |
42 | // apart from 01-jan before 12:00:00 UT. | |
43 | // So, 01-jan-1965 12:00:00 UT corresponds to JE=1965.0 | |
44 | // | |
45 | // The Besselian Epoch (BE) indicates the fractional elapsed Besselian year count | |
46 | // since the start of the Gregorian year count. | |
47 | // A Besselian (or tropical) year is defined to be 365.242198781 days. | |
48 | // | |
49 | // The Besselian and Julian epochs are used in astronomical catalogs | |
50 | // to denote values of time varying observables like e.g. right ascension. | |
3ea81e9c | 51 | // |
52 | // Because of the fact that the Julian date indicators are all w.r.t. UT | |
53 | // they provide an absolute timescale irrespective of timezone or daylight | |
54 | // saving time (DST). | |
55 | // | |
a4f7a3a1 | 56 | // In view of astronomical observations and positioning it is convenient |
57 | // to have also a UT equivalent related to stellar meridian transitions. | |
58 | // This is achieved by the Greenwich Sidereal Time (GST). | |
59 | // The GST is defined as the right ascension of the objects passing | |
60 | // the Greenwich meridian at 00:00:00 UT. | |
61 | // Due to the rotation of the Earth around the Sun, a sidereal day | |
62 | // lasts 86164.09 seconds (23h 56m 04.09s) compared to the mean solar | |
63 | // day of 86400 seconds (24h). | |
64 | // Furthermore, precession of the earth's spin axis results in the fact | |
65 | // that the zero point of right ascension (vernal equinox) gradually | |
66 | // moves along the celestial equator. | |
67 | // In addition, tidal friction and ocean and atmospheric effects will | |
68 | // induce seasonal variations in the earth's spin rate and polar motion | |
69 | // of the earth's spin axis. | |
70 | // To obtain a sidereal time measure, the above efects are taken | |
71 | // into account via corrections in the UT to GST conversion. | |
72 | // | |
a7dc0627 | 73 | // This AliTimestamp facility allows for picosecond precision, in view |
74 | // of time of flight analyses for particle physics experiments. | |
75 | // For normal date/time indication the standard nanosecond precision | |
76 | // will in general be sufficient. | |
77 | // Note that when the fractional JD, MJD and TJD counts are used instead | |
3ea81e9c | 78 | // of the integer (days,sec,ns) specification, the nanosecond precision |
79 | // may be lost due to computer accuracy w.r.t. floating point operations. | |
80 | // | |
81 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
82 | // which corresponds to JD=2440587.5 or the start of MJD=40587 or TJD=587. | |
83 | // Using the corresponding MJD of this EPOCH allows construction of | |
84 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input (M/T)JD and time. | |
85 | // Obviously this TTimeStamp implementation would prevent usage of values | |
86 | // smaller than JD=2440587.5 or MJD=40587 or TJD=587. | |
0cfe76b5 | 87 | // Furthermore, due to a limitation on the "seconds since the EPOCH start" count |
88 | // in TTimeStamp, the latest accessible date/time is 19-jan-2038 02:14:08 UTC. | |
3ea81e9c | 89 | // However, this AliTimestamp facility provides support for the full range |
90 | // of (M/T)JD values, but the setting of the corresponding TTimeStamp parameters | |
91 | // is restricted to the values allowed by the TTimeStamp implementation. | |
0cfe76b5 | 92 | // For these earlier/later (M/T)JD values, the standard TTimeStamp parameters will |
3ea81e9c | 93 | // be set corresponding to the start of the TTimeStamp EPOCH. |
0cfe76b5 | 94 | // This implies that for these earlier/later (M/T)JD values the TTimeStamp parameters |
3ea81e9c | 95 | // do not match the Julian parameters of AliTimestamp. |
96 | // As such the standard TTimeStamp parameters do not appear on the print output | |
0cfe76b5 | 97 | // when invoking the Date() memberfunction for these earlier/later (M/T)JD values. |
3ea81e9c | 98 | // |
99 | // Examples : | |
100 | // ========== | |
101 | // | |
102 | // Note : All TTimeStamp functionality is available as well. | |
103 | // | |
104 | // AliTimestamp t; | |
105 | // | |
106 | // t.Date(); | |
107 | // | |
108 | // // Retrieve Julian Date | |
109 | // Int_t jd,jsec,jns; | |
110 | // t.GetJD(jd,jsec,jns); | |
111 | // | |
112 | // // Retrieve fractional Truncated Julian Date | |
113 | // Double_t tjd=t.GetTJD(); | |
114 | // | |
115 | // // Retrieve fractional Julian Epoch | |
116 | // Double_t je=t.GetJE(); | |
117 | // | |
118 | // // Set to a specific Modified Julian Date | |
119 | // Int_t mjd=50537; | |
120 | // Int_t mjsec=1528; | |
121 | // Int_t mjns=185643; | |
122 | // t.SetMJD(mjd,mjsec,mjns); | |
123 | // | |
124 | // t.Date(); | |
125 | // | |
95cfc777 | 126 | // // Time intervals for e.g. trigger or TOF analysis |
127 | // AliEvent evt; | |
ee26083f | 128 | // AliTrack* tx=evt.GetTrack(5); |
129 | // AliTimestamp* timex=tx->GetTimestamp(); | |
130 | // Double_t dt=evt.GetDifference(timex,"ps"); | |
131 | // AliTimestamp trig((AliTimestamp)evt); | |
132 | // trig.Add(0,0,2,173); | |
133 | // AliSignal* sx=evt.GetHit(23); | |
134 | // AliTimestamp* timex=sx->GetTimestamp(); | |
135 | // Double_t dt=trig.GetDifference(timex,"ps"); | |
95cfc777 | 136 | // Int_t d,s,ns,ps; |
ee26083f | 137 | // trig.GetDifference(timex,d,s,ns,ps); |
95cfc777 | 138 | // |
3ea81e9c | 139 | // // Some practical conversion facilities |
140 | // // Note : They don't influence the actual date/time settings | |
141 | // // and as such can also be invoked as AliTimestamp::Convert(...) etc... | |
142 | // Int_t y=1921; | |
143 | // Int_t m=7; | |
144 | // Int_t d=21; | |
145 | // Int_t hh=15; | |
146 | // Int_t mm=23; | |
147 | // Int_t ss=47; | |
148 | // Int_t ns=811743; | |
149 | // Double_t jdate=t.GetJD(y,m,d,hh,mm,ss,ns); | |
150 | // | |
151 | // Int_t days,secs,nsecs; | |
152 | // Double_t date=421.1949327; | |
153 | // t.Convert(date,days,secs,nsecs); | |
154 | // | |
155 | // days=875; | |
156 | // secs=23; | |
157 | // nsecs=9118483; | |
158 | // date=t.Convert(days,secs,nsecs); | |
159 | // | |
160 | // Double_t mjdate=40563.823744; | |
161 | // Double_t epoch=t.GetJE(mjdate,"mjd"); | |
162 | // | |
163 | //--- Author: Nick van Eijndhoven 28-jan-2005 Utrecht University. | |
164 | //- Modified: NvE $Date$ Utrecht University. | |
165 | /////////////////////////////////////////////////////////////////////////// | |
166 | ||
167 | #include "AliTimestamp.h" | |
168 | #include "Riostream.h" | |
169 | ||
170 | ClassImp(AliTimestamp) // Class implementation to enable ROOT I/O | |
171 | ||
172 | AliTimestamp::AliTimestamp() : TTimeStamp() | |
173 | { | |
174 | // Default constructor | |
175 | // Creation of an AliTimestamp object and initialisation of parameters. | |
176 | // All attributes are initialised to the current date/time as specified | |
177 | // in the docs of TTimeStamp. | |
178 | ||
179 | FillJulian(); | |
a7dc0627 | 180 | fJps=0; |
3ea81e9c | 181 | } |
182 | /////////////////////////////////////////////////////////////////////////// | |
183 | AliTimestamp::AliTimestamp(TTimeStamp& t) : TTimeStamp(t) | |
184 | { | |
185 | // Creation of an AliTimestamp object and initialisation of parameters. | |
186 | // All attributes are initialised to the values of the input TTimeStamp. | |
187 | ||
188 | FillJulian(); | |
a7dc0627 | 189 | fJps=0; |
3ea81e9c | 190 | } |
191 | /////////////////////////////////////////////////////////////////////////// | |
192 | AliTimestamp::~AliTimestamp() | |
193 | { | |
194 | // Destructor to delete dynamically allocated memory. | |
195 | } | |
196 | /////////////////////////////////////////////////////////////////////////// | |
197 | AliTimestamp::AliTimestamp(const AliTimestamp& t) : TTimeStamp(t) | |
198 | { | |
199 | // Copy constructor | |
200 | ||
201 | fMJD=t.fMJD; | |
202 | fJsec=t.fJsec; | |
203 | fJns=t.fJns; | |
a7dc0627 | 204 | fJps=t.fJps; |
3ea81e9c | 205 | fCalcs=t.fCalcs; |
206 | fCalcns=t.fCalcns; | |
207 | } | |
208 | /////////////////////////////////////////////////////////////////////////// | |
e47fe004 | 209 | void AliTimestamp::Date(Int_t mode,Double_t offset) |
3ea81e9c | 210 | { |
211 | // Print date/time info. | |
212 | // | |
145c9890 | 213 | // mode = 1 ==> Only the UT yy-mm-dd hh:mm:ss:ns:ps and GST info is printed |
3ea81e9c | 214 | // 2 ==> Only the Julian parameter info is printed |
145c9890 | 215 | // 3 ==> Both the UT, GST and Julian parameter info is printed |
3ea81e9c | 216 | // |
e47fe004 | 217 | // offset : Local time offset from UT (and also GST) in fractional hours. |
218 | // | |
219 | // When an offset value is specified, the corresponding local times | |
220 | // LT and LST are printed as well. | |
221 | // | |
222 | // The default values are mode=3 and offset=0. | |
3ea81e9c | 223 | // |
224 | // Note : In case the (M/T)JD falls outside the TTimeStamp range, | |
145c9890 | 225 | // the yy-mm-dd info will be omitted. |
a4f7a3a1 | 226 | |
227 | Int_t mjd,mjsec,mjns,mjps; | |
228 | GetMJD(mjd,mjsec,mjns); | |
229 | mjps=GetPs(); | |
3ea81e9c | 230 | |
e47fe004 | 231 | TString month[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"}; |
232 | TString day[7]={"Mon","Tue","Wed","Thu","Fri","Sat","Sun"}; | |
233 | UInt_t y,m,d,wd; | |
a4f7a3a1 | 234 | Int_t hh,mm,ss,ns,ps; |
0cfe76b5 | 235 | |
a4f7a3a1 | 236 | if (mode==1 || mode==3) |
0cfe76b5 | 237 | { |
a4f7a3a1 | 238 | if (mjd>=40587 && (mjd<65442 || (mjd==65442 && mjsec<8047))) |
239 | { | |
145c9890 | 240 | GetDate(kTRUE,0,&y,&m,&d); |
e47fe004 | 241 | wd=GetDayOfWeek(kTRUE,0); |
145c9890 | 242 | cout << " " << day[wd-1].Data() << ", " << setfill('0') << setw(2) << d << " " |
243 | << setfill(' ') << month[m-1].Data() << " " << y << " "; | |
a4f7a3a1 | 244 | } |
245 | else | |
246 | { | |
145c9890 | 247 | cout << " Time "; |
a4f7a3a1 | 248 | } |
145c9890 | 249 | GetUT(hh,mm,ss,ns,ps); |
250 | cout << setfill('0') << setw(2) << hh << ":" | |
251 | << setw(2) << mm << ":" << setw(2) << ss << "." | |
252 | << setw(9) << ns << setw(3) << ps << " (UT) "; | |
a4f7a3a1 | 253 | GetGST(hh,mm,ss,ns,ps); |
145c9890 | 254 | cout << setfill('0') << setw(2) << hh << ":" |
255 | << setw(2) << mm << ":" << setw(2) << ss << "." | |
256 | << setw(9) << ns << setw(3) << ps << " (GST)"<< endl; | |
e47fe004 | 257 | if (offset) |
258 | { | |
259 | // Determine the new date by including the offset | |
260 | AliTimestamp t2(*this); | |
261 | t2.Add(offset); | |
262 | Int_t mjd2,mjsec2,mjns2; | |
263 | t2.GetMJD(mjd2,mjsec2,mjns2); | |
264 | if (mjd2>=40587 && (mjd2<65442 || (mjd2==65442 && mjsec2<8047))) | |
265 | { | |
266 | t2.GetDate(kTRUE,0,&y,&m,&d); | |
267 | wd=t2.GetDayOfWeek(kTRUE,0); | |
268 | cout << " " << day[wd-1].Data() << ", " << setfill('0') << setw(2) << d << " " | |
269 | << setfill(' ') << month[m-1].Data() << " " << y << " "; | |
270 | } | |
271 | else | |
272 | { | |
273 | cout << " Time "; | |
274 | } | |
275 | // Determine the local time by including the offset w.r.t. the original timestamp | |
276 | Double_t h; | |
277 | h=GetUT(); | |
278 | h+=offset; | |
279 | while (h<0) | |
280 | { | |
281 | h+=24.; | |
282 | } | |
283 | while (h>24) | |
284 | { | |
285 | h-=24.; | |
286 | } | |
287 | Convert(h,hh,mm,ss,ns,ps); | |
288 | cout << setfill('0') << setw(2) << hh << ":" | |
289 | << setw(2) << mm << ":" << setw(2) << ss << "." | |
290 | << setw(9) << ns << setw(3) << ps << " (LT) "; | |
291 | h=GetGST(); | |
292 | h+=offset; | |
293 | while (h<0) | |
294 | { | |
295 | h+=24.; | |
296 | } | |
297 | while (h>24) | |
298 | { | |
299 | h-=24.; | |
300 | } | |
301 | Convert(h,hh,mm,ss,ns,ps); | |
302 | cout << setfill('0') << setw(2) << hh << ":" | |
303 | << setw(2) << mm << ":" << setw(2) << ss << "." | |
304 | << setw(9) << ns << setw(3) << ps << " (LST)"<< endl; | |
305 | } | |
0cfe76b5 | 306 | } |
3ea81e9c | 307 | if (mode==2 || mode==3) |
308 | { | |
309 | Int_t jd,jsec,jns; | |
310 | GetJD(jd,jsec,jns); | |
311 | Int_t tjd,tjsec,tjns; | |
312 | GetTJD(tjd,tjsec,tjns); | |
a4f7a3a1 | 313 | cout << " Julian Epoch : " << setprecision(25) << GetJE() |
314 | << " Besselian Epoch : " << setprecision(25) << GetBE() << endl; | |
95cfc777 | 315 | cout << " JD : " << jd << " sec : " << jsec << " ns : " << jns << " ps : " << fJps |
3ea81e9c | 316 | << " Fractional : " << setprecision(25) << GetJD() << endl; |
95cfc777 | 317 | cout << " MJD : " << mjd << " sec : " << mjsec << " ns : " << mjns << " ps : " << fJps |
3ea81e9c | 318 | << " Fractional : " << setprecision(25) << GetMJD() << endl; |
95cfc777 | 319 | cout << " TJD : " << tjd << " sec : " << tjsec << " ns : " << tjns << " ps : " << fJps |
3ea81e9c | 320 | << " Fractional : " << setprecision(25) << GetTJD() << endl; |
321 | } | |
322 | } | |
323 | /////////////////////////////////////////////////////////////////////////// | |
324 | Double_t AliTimestamp::GetJD(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Int_t ss,Int_t ns) const | |
325 | { | |
326 | // Provide the (fractional) Julian Date (JD) corresponding to the UT date | |
327 | // and time in the Gregorian calendar as specified by the input arguments. | |
328 | // | |
329 | // The input arguments represent the following : | |
330 | // y : year in UT (e.g. 1952, 2003 etc...) | |
331 | // m : month in UT (1=jan 2=feb etc...) | |
332 | // d : day in UT (1-31) | |
333 | // hh : elapsed hours in UT (0-23) | |
334 | // mm : elapsed minutes in UT (0-59) | |
335 | // ss : elapsed seconds in UT (0-59) | |
336 | // ns : remaining fractional elapsed second of UT in nanosecond | |
337 | // | |
338 | // This algorithm is valid for all AD dates in the Gregorian calendar | |
339 | // following the recipe of R.W. Sinnott Sky & Telescope 82, (aug. 1991) 183. | |
340 | // See also http://scienceworld.wolfram.com/astronomy/JulianDate.html | |
341 | // | |
342 | // In case of invalid input, a value of -1 is returned. | |
343 | // | |
344 | // Note : | |
345 | // ------ | |
346 | // This memberfunction only provides the JD corresponding to the | |
347 | // UT input arguments. It does NOT set the corresponding Julian parameters | |
348 | // for the current AliTimestamp instance. | |
349 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
350 | // To set the Julian parameters for the current AliTimestamp instance, | |
351 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
352 | // or TTimeStamp. | |
353 | ||
354 | if (y<0 || m<1 || m>12 || d<1 || d>31) return -1; | |
355 | if (hh<0 || hh>23 || mm<0 || mm>59 || ss<0 || ss>59 || ns<0 || ns>1e9) return -1; | |
356 | ||
357 | // The UT daytime in fractional hours | |
358 | Double_t ut=double(hh)+double(mm)/60.+(double(ss)+double(ns)*1.e-9)/3600.; | |
359 | ||
360 | Double_t JD=0; | |
361 | ||
362 | JD=367*y-int(7*(y+int((m+9)/12))/4) | |
363 | -int(3*(int((y+(m-9)/7)/100)+1)/4) | |
364 | +int(275*m/9)+d+1721028.5+ut/24.; | |
365 | ||
366 | return JD; | |
367 | } | |
368 | /////////////////////////////////////////////////////////////////////////// | |
369 | Double_t AliTimestamp::GetMJD(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Int_t ss,Int_t ns) const | |
370 | { | |
371 | // Provide the (fractional) Modified Julian Date corresponding to the UT | |
372 | // date and time in the Gregorian calendar as specified by the input arguments. | |
373 | // | |
374 | // The input arguments represent the following : | |
375 | // y : year in UT (e.g. 1952, 2003 etc...) | |
376 | // m : month in UT (1=jan 2=feb etc...) | |
377 | // d : day in UT (1-31) | |
378 | // hh : elapsed hours in UT (0-23) | |
379 | // mm : elapsed minutes in UT (0-59) | |
380 | // ss : elapsed seconds in UT (0-59) | |
381 | // ns : remaining fractional elapsed second of UT in nanosecond | |
382 | // | |
383 | // This algorithm is valid for all AD dates in the Gregorian calendar | |
384 | // following the recipe of R.W. Sinnott Sky & Telescope 82, (aug. 1991) 183. | |
385 | // See also http://scienceworld.wolfram.com/astronomy/JulianDate.html | |
386 | // | |
387 | // In case of invalid input, a value of -1 is returned. | |
388 | // | |
389 | // Note : | |
390 | // ------ | |
391 | // This memberfunction only provides the MJD corresponding to the | |
392 | // UT input arguments. It does NOT set the corresponding Julian parameters | |
393 | // for the current AliTimestamp instance. | |
394 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
395 | // To set the Julian parameters for the current AliTimestamp instance, | |
396 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
397 | // or TTimeStamp. | |
398 | ||
399 | Double_t JD=GetJD(y,m,d,hh,mm,ss,ns); | |
400 | ||
401 | if (JD<0) return JD; | |
402 | ||
403 | Double_t MJD=JD-2400000.5; | |
404 | ||
405 | return MJD; | |
406 | } | |
407 | /////////////////////////////////////////////////////////////////////////// | |
408 | Double_t AliTimestamp::GetTJD(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Int_t ss,Int_t ns) const | |
409 | { | |
410 | // Provide the (fractional) Truncated Julian Date corresponding to the UT | |
411 | // date and time in the Gregorian calendar as specified by the input arguments. | |
412 | // | |
413 | // The input arguments represent the following : | |
414 | // y : year in UT (e.g. 1952, 2003 etc...) | |
415 | // m : month in UT (1=jan 2=feb etc...) | |
416 | // d : day in UT (1-31) | |
417 | // hh : elapsed hours in UT (0-23) | |
418 | // mm : elapsed minutes in UT (0-59) | |
419 | // ss : elapsed seconds in UT (0-59) | |
420 | // ns : remaining fractional elapsed second of UT in nanosecond | |
421 | // | |
422 | // This algorithm is valid for all AD dates in the Gregorian calendar | |
423 | // following the recipe of R.W. Sinnott Sky & Telescope 82, (aug. 1991) 183. | |
424 | // See also http://scienceworld.wolfram.com/astronomy/JulianDate.html | |
425 | // | |
426 | // In case of invalid input, a value of -1 is returned. | |
427 | // | |
428 | // Note : | |
429 | // ------ | |
430 | // This memberfunction only provides the TJD corresponding to the | |
431 | // UT input arguments. It does NOT set the corresponding Julian parameters | |
432 | // for the current AliTimestamp instance. | |
433 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
434 | // To set the Julian parameters for the current AliTimestamp instance, | |
435 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
436 | // or TTimeStamp. | |
437 | ||
438 | Double_t JD=GetJD(y,m,d,hh,mm,ss,ns); | |
439 | ||
440 | if (JD<0) return JD; | |
441 | ||
442 | Double_t TJD=JD-2440000.5; | |
443 | ||
444 | return TJD; | |
445 | } | |
446 | /////////////////////////////////////////////////////////////////////////// | |
447 | Double_t AliTimestamp::GetJE(Double_t date,TString mode) const | |
448 | { | |
449 | // Provide the Julian Epoch (JE) corresponding to the specified date. | |
450 | // The argument "mode" indicates the type of the argument "date". | |
451 | // | |
452 | // Available modes are : | |
453 | // mode = "jd" ==> date represents the Julian Date | |
454 | // = "mjd" ==> date represents the Modified Julian Date | |
455 | // = "tjd" ==> date represents the Truncated Julian Date | |
456 | // | |
457 | // The default is mode="jd". | |
458 | // | |
459 | // In case of invalid input, a value of -99999 is returned. | |
460 | // | |
461 | // Note : | |
462 | // ------ | |
463 | // This memberfunction only provides the JE corresponding to the | |
464 | // input arguments. It does NOT set the corresponding Julian parameters | |
465 | // for the current AliTimestamp instance. | |
466 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
467 | // To set the Julian parameters for the current AliTimestamp instance, | |
468 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
469 | // or TTimeStamp. | |
470 | ||
471 | if ((mode != "jd") && (mode != "mjd") && (mode != "tjd")) return -99999; | |
472 | ||
473 | Double_t jd=date; | |
474 | if (mode=="mjd") jd=date+2400000.5; | |
475 | if (mode=="tjd") jd=date+2440000.5; | |
476 | ||
477 | Double_t je=2000.+(jd-2451545.)/365.25; | |
478 | ||
479 | return je; | |
480 | } | |
481 | /////////////////////////////////////////////////////////////////////////// | |
a4f7a3a1 | 482 | Double_t AliTimestamp::GetBE(Double_t date,TString mode) const |
483 | { | |
484 | // Provide the Besselian Epoch (JE) corresponding to the specified date. | |
485 | // The argument "mode" indicates the type of the argument "date". | |
486 | // | |
487 | // Available modes are : | |
488 | // mode = "jd" ==> date represents the Julian Date | |
489 | // = "mjd" ==> date represents the Modified Julian Date | |
490 | // = "tjd" ==> date represents the Truncated Julian Date | |
491 | // | |
492 | // The default is mode="jd". | |
493 | // | |
494 | // In case of invalid input, a value of -99999 is returned. | |
495 | // | |
496 | // Note : | |
497 | // ------ | |
498 | // This memberfunction only provides the BE corresponding to the | |
499 | // input arguments. It does NOT set the corresponding Julian parameters | |
500 | // for the current AliTimestamp instance. | |
501 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
502 | // To set the Julian parameters for the current AliTimestamp instance, | |
503 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
504 | // or TTimeStamp. | |
505 | ||
506 | if ((mode != "jd") && (mode != "mjd") && (mode != "tjd")) return -99999; | |
507 | ||
508 | Double_t jd=date; | |
509 | if (mode=="mjd") jd=date+2400000.5; | |
510 | if (mode=="tjd") jd=date+2440000.5; | |
511 | ||
512 | Double_t be=1900.+(jd-2415020.31352)/365.242198781; | |
513 | ||
514 | return be; | |
515 | } | |
516 | /////////////////////////////////////////////////////////////////////////// | |
3ea81e9c | 517 | void AliTimestamp::Convert(Double_t date,Int_t& days,Int_t& secs,Int_t& ns) const |
518 | { | |
519 | // Convert date as fractional day count into integer days, secs and ns. | |
520 | // | |
521 | // Note : Due to computer accuracy the ns value may become inaccurate. | |
522 | // | |
523 | // The arguments represent the following : | |
524 | // date : The input date as fractional day count | |
525 | // days : Number of elapsed days | |
526 | // secs : Remaining number of elapsed seconds | |
527 | // ns : Remaining fractional elapsed second in nanoseconds | |
528 | // | |
529 | // Note : | |
530 | // ------ | |
531 | // This memberfunction only converts the input date into the corresponding | |
532 | // integer parameters. It does NOT set the corresponding Julian parameters | |
533 | // for the current AliTimestamp instance. | |
534 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
535 | // To set the Julian parameters for the current AliTimestamp instance, | |
536 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
537 | // or TTimeStamp. | |
538 | ||
539 | days=int(date); | |
540 | date=date-double(days); | |
541 | Int_t daysecs=24*3600; | |
542 | date=date*double(daysecs); | |
543 | secs=int(date); | |
544 | date=date-double(secs); | |
545 | ns=int(date*1.e9); | |
546 | } | |
547 | /////////////////////////////////////////////////////////////////////////// | |
548 | Double_t AliTimestamp::Convert(Int_t days,Int_t secs,Int_t ns) const | |
549 | { | |
550 | // Convert date in integer days, secs and ns into fractional day count. | |
551 | // | |
552 | // Note : Due to computer accuracy the ns precision may be lost. | |
553 | // | |
554 | // The input arguments represent the following : | |
555 | // days : Number of elapsed days | |
556 | // secs : Remaining number of elapsed seconds | |
557 | // ns : Remaining fractional elapsed second in nanoseconds | |
558 | // | |
559 | // Note : | |
560 | // ------ | |
561 | // This memberfunction only converts the input integer parameters into the | |
562 | // corresponding fractional day count. It does NOT set the corresponding | |
563 | // Julian parameters for the current AliTimestamp instance. | |
564 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
565 | // To set the Julian parameters for the current AliTimestamp instance, | |
566 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
567 | // or TTimeStamp. | |
568 | ||
569 | Double_t frac=double(secs)+double(ns)*1.e-9; | |
570 | Int_t daysecs=24*3600; | |
571 | frac=frac/double(daysecs); | |
572 | Double_t date=double(days)+frac; | |
573 | return date; | |
574 | } | |
575 | /////////////////////////////////////////////////////////////////////////// | |
a4f7a3a1 | 576 | void AliTimestamp::Convert(Double_t h,Int_t& hh,Int_t& mm,Int_t& ss,Int_t& ns,Int_t& ps) const |
577 | { | |
578 | // Convert fractional hour count h into hh:mm:ss:ns:ps. | |
579 | // | |
580 | // Note : Due to computer accuracy the ps value may become inaccurate. | |
581 | // | |
582 | // Note : | |
583 | // ------ | |
584 | // This memberfunction only converts the input "h" into the corresponding | |
585 | // integer parameters. It does NOT set the corresponding Julian parameters | |
586 | // for the current AliTimestamp instance. | |
587 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
588 | // To set the Julian parameters for the current AliTimestamp instance, | |
589 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
590 | // or TTimeStamp. | |
591 | ||
592 | hh=int(h); | |
593 | h=h-double(hh); | |
e47fe004 | 594 | h=h*60.; |
595 | mm=int(h); | |
596 | h=h-double(mm); | |
597 | h=h*60.; | |
a4f7a3a1 | 598 | ss=int(h); |
599 | h=h-double(ss); | |
600 | h=h*1.e9; | |
601 | ns=int(h); | |
602 | h=h-double(ns); | |
603 | h=h*1000.; | |
604 | ps=int(h); | |
605 | } | |
606 | /////////////////////////////////////////////////////////////////////////// | |
607 | Double_t AliTimestamp::Convert(Int_t hh,Int_t mm,Int_t ss,Int_t ns,Int_t ps) const | |
608 | { | |
609 | // Convert hh:mm:ss:ns:ps into fractional hour count. | |
610 | // | |
611 | // Note : Due to computer accuracy the ps precision may be lost. | |
612 | // | |
613 | // Note : | |
614 | // ------ | |
615 | // This memberfunction only converts the input integer parameters into the | |
616 | // corresponding fractional hour count. It does NOT set the corresponding | |
617 | // Julian parameters for the current AliTimestamp instance. | |
618 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
619 | // To set the Julian parameters for the current AliTimestamp instance, | |
620 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
621 | // or TTimeStamp. | |
622 | ||
623 | Double_t h=hh; | |
624 | h+=double(mm)/60.+(double(ss)+double(ns)*1.e-9+double(ps)*1.e-12)/3600.; | |
625 | ||
626 | return h; | |
627 | } | |
628 | /////////////////////////////////////////////////////////////////////////// | |
3ea81e9c | 629 | void AliTimestamp::FillJulian() |
630 | { | |
631 | // Calculation and setting of the Julian date/time parameters corresponding | |
632 | // to the current TTimeStamp date/time parameters. | |
633 | ||
634 | UInt_t y,m,d,hh,mm,ss; | |
635 | ||
636 | GetDate(kTRUE,0,&y,&m,&d); | |
637 | GetTime(kTRUE,0,&hh,&mm,&ss); | |
638 | Int_t ns=GetNanoSec(); | |
639 | ||
640 | Double_t mjd=GetMJD(y,m,d,hh,mm,ss,ns); | |
641 | ||
642 | fMJD=int(mjd); | |
643 | fJsec=GetSec()%(24*3600); // Daytime in elapsed seconds | |
644 | fJns=ns; // Remaining fractional elapsed second in nanoseconds | |
645 | ||
646 | // Store the TTimeStamp seconds and nanoseconds values | |
647 | // for which this Julian calculation was performed. | |
648 | fCalcs=GetSec(); | |
649 | fCalcns=GetNanoSec(); | |
650 | } | |
651 | /////////////////////////////////////////////////////////////////////////// | |
0cfe76b5 | 652 | void AliTimestamp::GetMJD(Int_t& mjd,Int_t& sec,Int_t& ns) |
3ea81e9c | 653 | { |
654 | // Provide the Modified Julian Date (MJD) and time corresponding to the | |
655 | // currently stored AliTimestamp date/time parameters. | |
656 | // | |
657 | // The returned arguments represent the following : | |
658 | // mjd : The modified Julian date. | |
659 | // sec : The number of seconds elapsed within the MJD. | |
660 | // ns : The remaining fractional number of seconds (in ns) elapsed within the MJD. | |
661 | ||
662 | if (fCalcs != GetSec() || fCalcns != GetNanoSec()) FillJulian(); | |
663 | ||
664 | mjd=fMJD; | |
665 | sec=fJsec; | |
666 | ns=fJns; | |
667 | } | |
668 | /////////////////////////////////////////////////////////////////////////// | |
669 | Double_t AliTimestamp::GetMJD() | |
670 | { | |
671 | // Provide the (fractional) Modified Julian Date (MJD) corresponding to the | |
672 | // currently stored AliTimestamp date/time parameters. | |
673 | // | |
674 | // Due to computer accuracy the ns precision may be lost. | |
675 | // It is advised to use the (mjd,sec,ns) getter instead. | |
676 | ||
677 | Int_t mjd=0; | |
678 | Int_t sec=0; | |
679 | Int_t ns=0; | |
680 | GetMJD(mjd,sec,ns); | |
681 | ||
682 | Double_t date=Convert(mjd,sec,ns); | |
683 | ||
684 | return date; | |
685 | } | |
686 | /////////////////////////////////////////////////////////////////////////// | |
687 | void AliTimestamp::GetTJD(Int_t& tjd,Int_t& sec, Int_t& ns) | |
688 | { | |
689 | // Provide the Truncated Julian Date (TJD) and time corresponding to the | |
690 | // currently stored AliTimestamp date/time parameters. | |
691 | // | |
692 | // The returned arguments represent the following : | |
693 | // tjd : The modified Julian date. | |
694 | // sec : The number of seconds elapsed within the MJD. | |
695 | // ns : The remaining fractional number of seconds (in ns) elapsed within the MJD. | |
696 | ||
697 | Int_t mjd=0; | |
698 | GetMJD(mjd,sec,ns); | |
699 | ||
700 | tjd=mjd-40000; | |
701 | } | |
702 | /////////////////////////////////////////////////////////////////////////// | |
703 | Double_t AliTimestamp::GetTJD() | |
704 | { | |
705 | // Provide the (fractional) Truncated Julian Date (TJD) corresponding to the | |
706 | // currently stored AliTimestamp date/time parameters. | |
707 | // | |
708 | // Due to computer accuracy the ns precision may be lost. | |
709 | // It is advised to use the (mjd,sec,ns) getter instead. | |
710 | ||
711 | Int_t tjd=0; | |
712 | Int_t sec=0; | |
713 | Int_t ns=0; | |
714 | GetTJD(tjd,sec,ns); | |
715 | ||
716 | Double_t date=Convert(tjd,sec,ns); | |
717 | ||
718 | return date; | |
719 | } | |
720 | /////////////////////////////////////////////////////////////////////////// | |
721 | void AliTimestamp::GetJD(Int_t& jd,Int_t& sec, Int_t& ns) | |
722 | { | |
723 | // Provide the Julian Date (JD) and time corresponding to the currently | |
724 | // stored AliTimestamp date/time parameters. | |
725 | // | |
726 | // The returned arguments represent the following : | |
727 | // jd : The Julian date. | |
728 | // sec : The number of seconds elapsed within the JD. | |
729 | // ns : The remaining fractional number of seconds (in ns) elapsed within the JD. | |
730 | ||
731 | Int_t mjd=0; | |
732 | GetMJD(mjd,sec,ns); | |
733 | ||
734 | jd=mjd+2400000; | |
735 | sec+=12*3600; | |
736 | if (sec >= 24*3600) | |
737 | { | |
738 | sec-=24*3600; | |
739 | jd+=1; | |
740 | } | |
741 | } | |
742 | /////////////////////////////////////////////////////////////////////////// | |
743 | Double_t AliTimestamp::GetJD() | |
744 | { | |
745 | // Provide the (fractional) Julian Date (JD) corresponding to the currently | |
746 | // stored AliTimestamp date/time parameters. | |
747 | // | |
748 | // Due to computer accuracy the ns precision may be lost. | |
749 | // It is advised to use the (jd,sec,ns) getter instead. | |
750 | ||
751 | Int_t jd=0; | |
752 | Int_t sec=0; | |
753 | Int_t ns=0; | |
754 | GetJD(jd,sec,ns); | |
755 | ||
756 | Double_t date=Convert(jd,sec,ns); | |
757 | ||
758 | return date; | |
759 | } | |
760 | /////////////////////////////////////////////////////////////////////////// | |
761 | Double_t AliTimestamp::GetJE() | |
762 | { | |
763 | // Provide the Julian Epoch (JE) corresponding to the currently stored | |
764 | // AliTimestamp date/time parameters. | |
765 | ||
766 | Double_t jd=GetJD(); | |
767 | Double_t je=GetJE(jd); | |
768 | return je; | |
769 | } | |
770 | /////////////////////////////////////////////////////////////////////////// | |
a4f7a3a1 | 771 | Double_t AliTimestamp::GetBE() |
772 | { | |
773 | // Provide the Besselian Epoch (BE) corresponding to the currently stored | |
774 | // AliTimestamp date/time parameters. | |
775 | ||
776 | Double_t jd=GetJD(); | |
777 | Double_t be=GetBE(jd); | |
778 | return be; | |
779 | } | |
780 | /////////////////////////////////////////////////////////////////////////// | |
a7dc0627 | 781 | void AliTimestamp::SetMJD(Int_t mjd,Int_t sec,Int_t ns,Int_t ps) |
3ea81e9c | 782 | { |
783 | // Set the Modified Julian Date (MJD) and time and update the TTimeStamp | |
784 | // parameters accordingly (if possible). | |
785 | // | |
786 | // Note : | |
787 | // ------ | |
788 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
789 | // which corresponds to the start of MJD=40587. | |
790 | // Using the corresponding MJD of this EPOCH allows construction of | |
791 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
792 | // Obviously this TTimeStamp implementation would prevent usage of MJD values | |
793 | // smaller than 40587. | |
0cfe76b5 | 794 | // Furthermore, due to a limitation on the "seconds since the EPOCH start" count |
795 | // in TTimeStamp, the latest accessible date/time is 19-jan-2038 02:14:08 UTC. | |
3ea81e9c | 796 | // However, this AliTimestamp facility provides support for the full range |
797 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
798 | // is restricted to the values allowed by the TTimeStamp implementation. | |
0cfe76b5 | 799 | // For these earlier/later MJD values, the standard TTimeStamp parameters will |
3ea81e9c | 800 | // be set corresponding to the start of the TTimeStamp EPOCH. |
0cfe76b5 | 801 | // This implies that for these earlier/later MJD values the TTimeStamp parameters |
3ea81e9c | 802 | // do not match the Julian parameters of AliTimestamp. |
803 | // | |
804 | // The input arguments represent the following : | |
805 | // mjd : The modified Julian date. | |
806 | // sec : The number of seconds elapsed within the MJD. | |
807 | // ns : The remaining fractional number of seconds (in ns) elapsed within the MJD. | |
a7dc0627 | 808 | // ps : The remaining fractional number of nanoseconds (in ps) elapsed within the MJD. |
809 | // | |
810 | // Note : ps=0 is the default value. | |
3ea81e9c | 811 | |
a7dc0627 | 812 | if (sec<0 || sec>=24*3600 || ns<0 || ns>=1e9 || ps<0 || ps>=1000) |
3ea81e9c | 813 | { |
814 | cout << " *AliTimestamp::SetMJD* Invalid input." | |
815 | << " sec : " << sec << " ns : " << ns << endl; | |
816 | return; | |
817 | } | |
818 | ||
819 | fMJD=mjd; | |
820 | fJsec=sec; | |
821 | fJns=ns; | |
a7dc0627 | 822 | fJps=ps; |
3ea81e9c | 823 | |
0cfe76b5 | 824 | Int_t epoch=40587; // MJD of the start of the epoch |
825 | Int_t limit=65442; // MJD of the latest possible TTimeStamp date/time | |
3ea81e9c | 826 | |
0cfe76b5 | 827 | Int_t date,time; |
828 | if (mjd<epoch || (mjd>=limit && sec>=8047)) | |
3ea81e9c | 829 | { |
830 | Set(0,kFALSE,0,kFALSE); | |
0cfe76b5 | 831 | date=GetDate(); |
832 | time=GetTime(); | |
833 | Set(date,time,0,kTRUE,0); | |
3ea81e9c | 834 | } |
835 | else | |
836 | { | |
837 | // The elapsed time since start of EPOCH | |
838 | Int_t days=mjd-epoch; | |
839 | UInt_t secs=days*24*3600; | |
840 | secs+=sec; | |
841 | Set(secs,kFALSE,0,kFALSE); | |
0cfe76b5 | 842 | date=GetDate(); |
843 | time=GetTime(); | |
3ea81e9c | 844 | Set(date,time,ns,kTRUE,0); |
845 | } | |
846 | ||
847 | // Denote that the Julian and TTimeStamp parameters are synchronised, | |
848 | // even in the case the MJD falls outside the TTimeStamp validity range. | |
849 | // The latter still allows retrieval of Julian parameters for these | |
850 | // earlier times. | |
851 | fCalcs=GetSec(); | |
852 | fCalcns=GetNanoSec(); | |
853 | } | |
854 | /////////////////////////////////////////////////////////////////////////// | |
855 | void AliTimestamp::SetMJD(Double_t mjd) | |
856 | { | |
857 | // Set the Modified Julian Date (MJD) and time and update the TTimeStamp | |
858 | // parameters accordingly (if possible). | |
859 | // | |
860 | // Note : | |
861 | // ------ | |
862 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
863 | // which corresponds to the start of MJD=40587. | |
864 | // Using the corresponding MJD of this EPOCH allows construction of | |
865 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
866 | // Obviously this TTimeStamp implementation would prevent usage of MJD values | |
867 | // smaller than 40587. | |
0cfe76b5 | 868 | // Furthermore, due to a limitation on the "seconds since the EPOCH start" count |
869 | // in TTimeStamp, the latest accessible date/time is 19-jan-2038 02:14:08 UTC. | |
3ea81e9c | 870 | // However, this AliTimestamp facility provides support for the full range |
871 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
872 | // is restricted to the values allowed by the TTimeStamp implementation. | |
0cfe76b5 | 873 | // For these earlier/later MJD values, the standard TTimeStamp parameters will |
3ea81e9c | 874 | // be set corresponding to the start of the TTimeStamp EPOCH. |
0cfe76b5 | 875 | // This implies that for these earlier/later MJD values the TTimeStamp parameters |
3ea81e9c | 876 | // do not match the Julian parameters of AliTimestamp. |
877 | // | |
878 | // Due to computer accuracy the ns precision may be lost. | |
879 | // It is advised to use the (mjd,sec,ns) setting instead. | |
880 | // | |
881 | // The input argument represents the following : | |
882 | // mjd : The modified Julian date as fractional day count. | |
883 | ||
884 | Int_t days=0; | |
885 | Int_t secs=0; | |
886 | Int_t ns=0; | |
887 | Convert(mjd,days,secs,ns); | |
888 | SetMJD(days,secs,ns); | |
889 | } | |
890 | /////////////////////////////////////////////////////////////////////////// | |
a7dc0627 | 891 | void AliTimestamp::SetJD(Int_t jd,Int_t sec,Int_t ns,Int_t ps) |
3ea81e9c | 892 | { |
893 | // Set the Julian Date (JD) and time and update the TTimeStamp | |
894 | // parameters accordingly (if possible). | |
895 | // | |
896 | // Note : | |
897 | // ------ | |
898 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
899 | // which corresponds to JD=2440587.5 or the start of MJD=40587. | |
900 | // Using the corresponding MJD of this EPOCH allows construction of | |
901 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
902 | // Obviously this TTimeStamp implementation would prevent usage of values | |
903 | // smaller than JD=2440587.5. | |
0cfe76b5 | 904 | // Furthermore, due to a limitation on the "seconds since the EPOCH start" count |
905 | // in TTimeStamp, the latest accessible date/time is 19-jan-2038 02:14:08 UTC. | |
3ea81e9c | 906 | // However, this AliTimestamp facility provides support for the full range |
907 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
908 | // is restricted to the values allowed by the TTimeStamp implementation. | |
0cfe76b5 | 909 | // For these earlier/later JD values, the standard TTimeStamp parameters will |
3ea81e9c | 910 | // be set corresponding to the start of the TTimeStamp EPOCH. |
0cfe76b5 | 911 | // This implies that for these earlier/later (M)JD values the TTimeStamp parameters |
3ea81e9c | 912 | // do not match the Julian parameters of AliTimestamp. |
913 | // | |
914 | // The input arguments represent the following : | |
915 | // jd : The Julian date. | |
916 | // sec : The number of seconds elapsed within the JD. | |
917 | // ns : The remaining fractional number of seconds (in ns) elapsed within the JD. | |
a7dc0627 | 918 | // ps : The remaining fractional number of nanoseconds (in ps) elapsed within the JD. |
919 | // | |
920 | // Note : ps=0 is the default value. | |
3ea81e9c | 921 | |
922 | Int_t mjd=jd-2400000; | |
923 | sec-=12*3600; | |
924 | if (sec<0) | |
925 | { | |
926 | sec+=24*3600; | |
927 | mjd-=1; | |
928 | } | |
929 | ||
a7dc0627 | 930 | SetMJD(mjd,sec,ns,ps); |
3ea81e9c | 931 | } |
932 | /////////////////////////////////////////////////////////////////////////// | |
933 | void AliTimestamp::SetJD(Double_t jd) | |
934 | { | |
935 | // Set the Julian Date (JD) and time and update the TTimeStamp | |
936 | // parameters accordingly (if possible). | |
937 | // | |
938 | // Note : | |
939 | // ------ | |
940 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
941 | // which corresponds to JD=2440587.5 or the start of MJD=40587. | |
942 | // Using the corresponding MJD of this EPOCH allows construction of | |
943 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
944 | // Obviously this TTimeStamp implementation would prevent usage of values | |
945 | // smaller than JD=2440587.5. | |
0cfe76b5 | 946 | // Furthermore, due to a limitation on the "seconds since the EPOCH start" count |
947 | // in TTimeStamp, the latest accessible date/time is 19-jan-2038 02:14:08 UTC. | |
3ea81e9c | 948 | // However, this AliTimestamp facility provides support for the full range |
949 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
950 | // is restricted to the values allowed by the TTimeStamp implementation. | |
0cfe76b5 | 951 | // For these earlier/later JD values, the standard TTimeStamp parameters will |
3ea81e9c | 952 | // be set corresponding to the start of the TTimeStamp EPOCH. |
0cfe76b5 | 953 | // This implies that for these earlier/later (M)JD values the TTimeStamp parameters |
3ea81e9c | 954 | // do not match the Julian parameters of AliTimestamp. |
955 | // | |
956 | // Due to computer accuracy the ns precision may be lost. | |
957 | // It is advised to use the (jd,sec,ns) setting instead. | |
958 | // | |
959 | // The input argument represents the following : | |
960 | // jd : The Julian date as fractional day count. | |
961 | ||
962 | Int_t days=0; | |
963 | Int_t secs=0; | |
964 | Int_t ns=0; | |
965 | Convert(jd,days,secs,ns); | |
966 | ||
967 | SetJD(days,secs,ns); | |
968 | } | |
969 | /////////////////////////////////////////////////////////////////////////// | |
a7dc0627 | 970 | void AliTimestamp::SetTJD(Int_t tjd,Int_t sec,Int_t ns,Int_t ps) |
3ea81e9c | 971 | { |
972 | // Set the Truncated Julian Date (TJD) and time and update the TTimeStamp | |
973 | // parameters accordingly (if possible). | |
974 | // | |
975 | // Note : | |
976 | // ------ | |
977 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
978 | // which corresponds to JD=2440587.5 or the start of TJD=587. | |
979 | // Using the corresponding MJD of this EPOCH allows construction of | |
980 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
981 | // Obviously this TTimeStamp implementation would prevent usage of values | |
982 | // smaller than TJD=587. | |
0cfe76b5 | 983 | // Furthermore, due to a limitation on the "seconds since the EPOCH start" count |
984 | // in TTimeStamp, the latest accessible date/time is 19-jan-2038 02:14:08 UTC. | |
3ea81e9c | 985 | // However, this AliTimestamp facility provides support for the full range |
986 | // of (T)JD values, but the setting of the corresponding TTimeStamp parameters | |
987 | // is restricted to the values allowed by the TTimeStamp implementation. | |
0cfe76b5 | 988 | // For these earlier/later JD values, the standard TTimeStamp parameters will |
3ea81e9c | 989 | // be set corresponding to the start of the TTimeStamp EPOCH. |
0cfe76b5 | 990 | // This implies that for these earlier/later (T)JD values the TTimeStamp parameters |
3ea81e9c | 991 | // do not match the Julian parameters of AliTimestamp. |
992 | // | |
993 | // The input arguments represent the following : | |
994 | // tjd : The Truncated Julian date. | |
995 | // sec : The number of seconds elapsed within the JD. | |
996 | // ns : The remaining fractional number of seconds (in ns) elapsed within the JD. | |
a7dc0627 | 997 | // ps : The remaining fractional number of nanoseconds (in ps) elapsed within the JD. |
998 | // | |
999 | // Note : ps=0 is the default value. | |
3ea81e9c | 1000 | |
1001 | Int_t mjd=tjd+40000; | |
1002 | ||
5481c137 | 1003 | SetMJD(mjd,sec,ns,ps); |
3ea81e9c | 1004 | } |
1005 | /////////////////////////////////////////////////////////////////////////// | |
1006 | void AliTimestamp::SetTJD(Double_t tjd) | |
1007 | { | |
1008 | // Set the Truncated Julian Date (TJD) and time and update the TTimeStamp | |
1009 | // parameters accordingly (if possible). | |
1010 | // | |
1011 | // Note : | |
1012 | // ------ | |
1013 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
1014 | // which corresponds to JD=2440587.5 or the start of TJD=587. | |
1015 | // Using the corresponding MJD of this EPOCH allows construction of | |
1016 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
1017 | // Obviously this TTimeStamp implementation would prevent usage of values | |
1018 | // smaller than TJD=587. | |
0cfe76b5 | 1019 | // Furthermore, due to a limitation on the "seconds since the EPOCH start" count |
1020 | // in TTimeStamp, the latest accessible date/time is 19-jan-2038 02:14:08 UTC. | |
3ea81e9c | 1021 | // However, this AliTimestamp facility provides support for the full range |
1022 | // of (T)JD values, but the setting of the corresponding TTimeStamp parameters | |
1023 | // is restricted to the values allowed by the TTimeStamp implementation. | |
0cfe76b5 | 1024 | // For these earlier/later JD values, the standard TTimeStamp parameters will |
3ea81e9c | 1025 | // be set corresponding to the start of the TTimeStamp EPOCH. |
0cfe76b5 | 1026 | // This implies that for these earlier/later (T)JD values the TTimeStamp parameters |
3ea81e9c | 1027 | // do not match the Julian parameters of AliTimestamp. |
1028 | // | |
1029 | // Due to computer accuracy the ns precision may be lost. | |
1030 | // It is advised to use the (jd,sec,ns) setting instead. | |
1031 | // | |
1032 | // The input argument represents the following : | |
1033 | // tjd : The Truncated Julian date as fractional day count. | |
1034 | ||
1035 | Int_t days=0; | |
1036 | Int_t secs=0; | |
1037 | Int_t ns=0; | |
1038 | Convert(tjd,days,secs,ns); | |
1039 | ||
1040 | SetTJD(days,secs,ns); | |
1041 | } | |
1042 | /////////////////////////////////////////////////////////////////////////// | |
95cfc777 | 1043 | void AliTimestamp::SetNs(Int_t ns) |
1044 | { | |
1045 | // Set the remaining fractional number of seconds in nanosecond precision. | |
1046 | // Notes : | |
1047 | // ------- | |
1048 | // 1) The allowed range for the argument "ns" is [0,99999999]. | |
1049 | // Outside that range no action is performed. | |
1050 | // 2) The ns fraction can also be entered directly via SetMJD() etc... | |
1051 | // 3) For additional accuracy see SetPs(). | |
1052 | ||
1053 | if (ns>=0 && ns<=99999999) fJns=ns; | |
1054 | } | |
1055 | /////////////////////////////////////////////////////////////////////////// | |
1056 | Int_t AliTimestamp::GetNs() const | |
1057 | { | |
1058 | // Provide the remaining fractional number of seconds in nanosecond precision. | |
1059 | // This function allows trigger/timing analysis for (astro)particle physics | |
1060 | // experiments. | |
1061 | // Note : For additional accuracy see also GetPs(). | |
1062 | ||
1063 | return fJns; | |
1064 | } | |
1065 | /////////////////////////////////////////////////////////////////////////// | |
1066 | void AliTimestamp::SetPs(Int_t ps) | |
1067 | { | |
1068 | // Set the remaining fractional number of nanoseconds in picoseconds. | |
1069 | // Notes : | |
1070 | // ------- | |
1071 | // 1) The allowed range for the argument "ps" is [0,999]. | |
1072 | // Outside that range no action is performed. | |
1073 | // 2) The ps fraction can also be entered directly via SetMJD() etc... | |
1074 | ||
1075 | if (ps>=0 && ps<=999) fJps=ps; | |
1076 | } | |
1077 | /////////////////////////////////////////////////////////////////////////// | |
1078 | Int_t AliTimestamp::GetPs() const | |
a7dc0627 | 1079 | { |
1080 | // Provide remaining fractional number of nanoseconds in picoseconds. | |
95cfc777 | 1081 | // This function allows time of flight analysis for particle physics |
a7dc0627 | 1082 | // experiments. |
1083 | ||
1084 | return fJps; | |
1085 | } | |
1086 | /////////////////////////////////////////////////////////////////////////// | |
95cfc777 | 1087 | void AliTimestamp::Add(Int_t d,Int_t s,Int_t ns,Int_t ps) |
1088 | { | |
1089 | // Add (or subtract) a certain time difference to the current timestamp. | |
ee26083f | 1090 | // Subtraction can be achieved by entering negative values as input arguments. |
95cfc777 | 1091 | // |
25eefd00 | 1092 | // The time difference is entered via the following input arguments : |
1093 | // | |
95cfc777 | 1094 | // d : elapsed number of days |
25eefd00 | 1095 | // s : (remaining) elapsed number of seconds |
1096 | // ns : (remaining) elapsed number of nanoseconds | |
1097 | // ps : (remaining) elapsed number of picoseconds | |
1098 | // | |
1099 | // The specified d, s, ns and ps values will be used in an additive | |
1100 | // way to determine the time difference. | |
1101 | // So, specification of d=1, s=100, ns=0, ps=0 will result in the | |
1102 | // same time difference addition as d=0, s=24*3600+100, ns=0, ps=0. | |
1103 | // However, by making use of the latter the user should take care | |
1104 | // of possible integer overflow problems in the input arguments, | |
1105 | // which obviously will provide incorrect results. | |
95cfc777 | 1106 | // |
1107 | // Note : ps=0 is the default value. | |
1108 | ||
ee26083f | 1109 | Int_t days=0; |
1110 | Int_t secs=0; | |
1111 | Int_t nsec=0; | |
1112 | // Use Get functions to ensure updated Julian parameters. | |
1113 | GetMJD(days,secs,nsec); | |
1114 | Int_t psec=GetPs(); | |
95cfc777 | 1115 | |
25eefd00 | 1116 | psec+=ps%1000; |
1117 | nsec+=ps/1000; | |
1118 | while (psec<0) | |
95cfc777 | 1119 | { |
1120 | nsec-=1; | |
1121 | psec+=1000; | |
1122 | } | |
25eefd00 | 1123 | while (psec>999) |
95cfc777 | 1124 | { |
1125 | nsec+=1; | |
1126 | psec-=1000; | |
1127 | } | |
1128 | ||
25eefd00 | 1129 | nsec+=ns%1000000000; |
1130 | secs+=ns/1000000000; | |
1131 | while (nsec<0) | |
95cfc777 | 1132 | { |
1133 | secs-=1; | |
1134 | nsec+=1000000000; | |
1135 | } | |
25eefd00 | 1136 | while (nsec>999999999) |
95cfc777 | 1137 | { |
1138 | secs+=1; | |
1139 | nsec-=1000000000; | |
1140 | } | |
1141 | ||
25eefd00 | 1142 | secs+=s%(24*3600); |
1143 | days+=s/(24*3600); | |
1144 | while (secs<0) | |
95cfc777 | 1145 | { |
1146 | days-=1; | |
1147 | secs+=24*3600; | |
1148 | } | |
25eefd00 | 1149 | while (secs>=24*3600) |
95cfc777 | 1150 | { |
1151 | days+=1; | |
1152 | secs-=24*3600; | |
1153 | } | |
1154 | ||
1155 | days+=d; | |
1156 | ||
6a7b0c73 | 1157 | SetMJD(days,secs,nsec,psec); |
95cfc777 | 1158 | } |
1159 | /////////////////////////////////////////////////////////////////////////// | |
e47fe004 | 1160 | void AliTimestamp::Add(Double_t hours) |
1161 | { | |
1162 | // Add (or subtract) a certain time difference to the current timestamp. | |
1163 | // The time difference is specified as a (fractional) number of hours. | |
1164 | // Subtraction can be achieved by entering a negative value as input argument. | |
1165 | ||
1166 | Int_t d,s,ns,ps; | |
1167 | Double_t h=fabs(hours); | |
1168 | d=int(h/24.); | |
1169 | h-=double(d)*24.; | |
1170 | h*=3600.; | |
1171 | s=int(h); | |
1172 | h-=double(s); | |
1173 | h*=1.e9; | |
1174 | ns=int(h); | |
1175 | h-=double(ns); | |
1176 | ps=int(h*1000.); | |
1177 | if (hours>0) Add(d,s,ns,ps); | |
1178 | if (hours<0) Add(-d,-s,-ns,-ps); | |
1179 | } | |
1180 | /////////////////////////////////////////////////////////////////////////// | |
ee26083f | 1181 | Int_t AliTimestamp::GetDifference(AliTimestamp* t,Int_t& d,Int_t& s,Int_t& ns,Int_t& ps) |
a7dc0627 | 1182 | { |
1183 | // Provide the time difference w.r.t the AliTimestamp specified on the input. | |
1184 | // This memberfunction supports both very small (i.e. time of flight analysis | |
1185 | // for particle physics experiments) and very long (i.e. investigation of | |
1186 | // astrophysical phenomena) timescales. | |
1187 | // | |
1188 | // The time difference is returned via the following output arguments : | |
1189 | // d : elapsed number of days | |
1190 | // s : remaining elapsed number of seconds | |
1191 | // ns : remaining elapsed number of nanoseconds | |
1192 | // ps : remaining elapsed number of picoseconds | |
1193 | // | |
95cfc777 | 1194 | // Note : |
1195 | // ------ | |
1196 | // The calculated time difference is the absolute value of the time interval. | |
1197 | // This implies that the values of d, s, ns and ps are always positive or zero. | |
1198 | // | |
a7dc0627 | 1199 | // The integer return argument indicates whether the AliTimestamp specified |
1200 | // on the input argument occurred earlier (-1), simultaneously (0) or later (1). | |
1201 | ||
ee26083f | 1202 | if (!t) return 0; |
1203 | ||
1204 | // Ensure updated Julian parameters for this AliTimestamp instance | |
1205 | if (fCalcs != GetSec() || fCalcns != GetNanoSec()) FillJulian(); | |
1206 | ||
1207 | // Use Get functions to ensure updated Julian parameters. | |
1208 | t->GetMJD(d,s,ns); | |
1209 | ps=t->GetPs(); | |
1210 | ||
1211 | d-=fMJD; | |
1212 | s-=fJsec; | |
1213 | ns-=fJns; | |
1214 | ps-=fJps; | |
a7dc0627 | 1215 | |
1216 | if (!d && !s && !ns && !ps) return 0; | |
1217 | ||
1218 | Int_t sign=0; | |
1219 | ||
95cfc777 | 1220 | if (d>0) sign=1; |
1221 | if (d<0) sign=-1; | |
1222 | ||
1223 | if (!sign && s>0) sign=1; | |
1224 | if (!sign && s<0) sign=-1; | |
a7dc0627 | 1225 | |
1226 | if (!sign && ns>0) sign=1; | |
1227 | if (!sign && ns<0) sign=-1; | |
1228 | ||
1229 | if (!sign && ps>0) sign=1; | |
1230 | if (!sign && ps<0) sign=-1; | |
1231 | ||
1232 | // In case the input stamp was earlier, take the reverse difference | |
1233 | // to simplify the algebra. | |
1234 | if (sign<0) | |
1235 | { | |
95cfc777 | 1236 | d=-d; |
a7dc0627 | 1237 | s=-s; |
1238 | ns=-ns; | |
1239 | ps=-ps; | |
1240 | } | |
1241 | ||
1242 | // Here we always have a positive time difference | |
95cfc777 | 1243 | // and can now unambiguously correct for other negative values. |
a7dc0627 | 1244 | if (ps<0) |
1245 | { | |
1246 | ns-=1; | |
1247 | ps+=1000; | |
1248 | } | |
1249 | ||
1250 | if (ns<0) | |
1251 | { | |
1252 | s-=1; | |
95cfc777 | 1253 | ns+=1000000000; |
a7dc0627 | 1254 | } |
1255 | ||
95cfc777 | 1256 | if (s<0) |
1257 | { | |
1258 | d-=1; | |
1259 | s+=24*3600; | |
1260 | } | |
a7dc0627 | 1261 | |
1262 | return sign; | |
1263 | } | |
1264 | /////////////////////////////////////////////////////////////////////////// | |
ee26083f | 1265 | Int_t AliTimestamp::GetDifference(AliTimestamp& t,Int_t& d,Int_t& s,Int_t& ns,Int_t& ps) |
1266 | { | |
1267 | // Provide the time difference w.r.t the AliTimestamp specified on the input. | |
1268 | // This memberfunction supports both very small (i.e. time of flight analysis | |
1269 | // for particle physics experiments) and very long (i.e. investigation of | |
1270 | // astrophysical phenomena) timescales. | |
1271 | // | |
1272 | // The time difference is returned via the following output arguments : | |
1273 | // d : elapsed number of days | |
1274 | // s : remaining elapsed number of seconds | |
1275 | // ns : remaining elapsed number of nanoseconds | |
1276 | // ps : remaining elapsed number of picoseconds | |
1277 | // | |
1278 | // Note : | |
1279 | // ------ | |
1280 | // The calculated time difference is the absolute value of the time interval. | |
1281 | // This implies that the values of d, s, ns and ps are always positive or zero. | |
1282 | // | |
1283 | // The integer return argument indicates whether the AliTimestamp specified | |
1284 | // on the input argument occurred earlier (-1), simultaneously (0) or later (1). | |
1285 | ||
1286 | return GetDifference(&t,d,s,ns,ps); | |
1287 | } | |
1288 | /////////////////////////////////////////////////////////////////////////// | |
1289 | Double_t AliTimestamp::GetDifference(AliTimestamp* t,TString u,Int_t mode) | |
95cfc777 | 1290 | { |
1291 | // Provide the time difference w.r.t the AliTimestamp specified on the input | |
1292 | // argument in the units as specified by the TString argument. | |
1293 | // A positive return value means that the AliTimestamp specified on the input | |
1294 | // argument occurred later, whereas a negative return value indicates an | |
1295 | // earlier occurence. | |
1296 | // | |
1297 | // The units may be specified as : | |
1298 | // u = "d" ==> Time difference returned as (fractional) day count | |
1299 | // "s" ==> Time difference returned as (fractional) second count | |
1300 | // "ns" ==> Time difference returned as (fractional) nanosecond count | |
1301 | // "ps" ==> Time difference returned as picosecond count | |
1302 | // | |
1303 | // It may be clear that for a time difference of several days, the picosecond | |
1304 | // and even the nanosecond accuracy may be lost. | |
1305 | // To cope with this, the "mode" argument has been introduced to allow | |
1306 | // timestamp comparison on only the specified units. | |
1307 | // | |
1308 | // The following operation modes are supported : | |
1309 | // mode = 1 : Full time difference is returned in specified units | |
1310 | // 2 : Time difference is returned in specified units by | |
1311 | // neglecting the elapsed time for the larger units than the | |
1312 | // ones specified. | |
1313 | // 3 : Time difference is returned in specified units by only | |
1314 | // comparing the timestamps on the level of the specified units. | |
1315 | // | |
1316 | // Example : | |
1317 | // --------- | |
1318 | // AliTimestamp t1; // Corresponding to days=3, secs=501, ns=31, ps=7 | |
1319 | // AliTimestamp t2; // Corresponding to days=5, secs=535, ns=12, ps=15 | |
1320 | // | |
1321 | // The statement : Double_t val=t1.GetDifference(t2,....) | |
1322 | // would return the following values : | |
1323 | // val=(2*24*3600)+34-(19*1e-9)+(8*1e-12) for u="s" and mode=1 | |
1324 | // val=34-(19*1e-9)+(8*1e-12) for u="s" and mode=2 | |
1325 | // val=34 for u="s" and mode=3 | |
1326 | // val=-19 for u="ns" and mode=3 | |
1327 | // | |
1328 | // The default is mode=1. | |
1329 | ||
ee26083f | 1330 | if (!t || mode<1 || mode>3) return 0; |
95cfc777 | 1331 | |
1332 | Double_t dt=0; | |
1333 | ||
ee26083f | 1334 | // Ensure updated Julian parameters for this AliTimestamp instance |
1335 | if (fCalcs != GetSec() || fCalcns != GetNanoSec()) FillJulian(); | |
1336 | ||
1337 | Int_t dd=0; | |
1338 | Int_t ds=0; | |
1339 | Int_t dns=0; | |
1340 | Int_t dps=0; | |
1341 | ||
1342 | // Use Get functions to ensure updated Julian parameters. | |
1343 | t->GetMJD(dd,ds,dns); | |
1344 | dps=t->GetPs(); | |
1345 | ||
1346 | dd-=fMJD; | |
1347 | ds-=fJsec; | |
1348 | dns-=fJns; | |
1349 | dps-=fJps; | |
95cfc777 | 1350 | |
1351 | // Time difference for the specified units only | |
1352 | if (mode==3) | |
1353 | { | |
1354 | if (u=="d") dt=dd; | |
1355 | if (u=="s") dt=ds; | |
1356 | if (u=="ns") dt=dns; | |
1357 | if (u=="ps") dt=dps; | |
1358 | return dt; | |
1359 | } | |
1360 | ||
1361 | // Suppress elapsed time for the larger units than specified | |
1362 | if (mode==2) | |
1363 | { | |
1364 | if (u=="s") dd=0; | |
1365 | if (u=="ns") | |
1366 | { | |
1367 | dd=0; | |
1368 | ds=0; | |
1369 | } | |
1370 | if (u=="ps") | |
1371 | { | |
1372 | dd=0; | |
1373 | ds=0; | |
1374 | dns=0; | |
1375 | } | |
1376 | } | |
1377 | ||
1378 | // Compute the time difference as requested | |
1379 | if (u=="s" || u=="d") | |
1380 | { | |
1381 | // The time difference in (fractional) seconds | |
1382 | dt=double(dd*24*3600+ds)+(double(dns)*1e-9)+(double(dps)*1e-12); | |
1383 | if (u=="d") dt=dt/double(24*3600); | |
1384 | } | |
1385 | if (u=="ns") dt=(double(dd*24*3600+ds)*1e9)+double(dns)+(double(dps)*1e-3); | |
1386 | if (u=="ps") dt=(double(dd*24*3600+ds)*1e12)+(double(dns)*1e3)+double(dps); | |
1387 | ||
1388 | return dt; | |
1389 | } | |
1390 | /////////////////////////////////////////////////////////////////////////// | |
ee26083f | 1391 | Double_t AliTimestamp::GetDifference(AliTimestamp& t,TString u,Int_t mode) |
1392 | { | |
1393 | // Provide the time difference w.r.t the AliTimestamp specified on the input | |
1394 | // argument in the units as specified by the TString argument. | |
1395 | // A positive return value means that the AliTimestamp specified on the input | |
1396 | // argument occurred later, whereas a negative return value indicates an | |
1397 | // earlier occurence. | |
1398 | // | |
1399 | // The units may be specified as : | |
1400 | // u = "d" ==> Time difference returned as (fractional) day count | |
1401 | // "s" ==> Time difference returned as (fractional) second count | |
1402 | // "ns" ==> Time difference returned as (fractional) nanosecond count | |
1403 | // "ps" ==> Time difference returned as picosecond count | |
1404 | // | |
1405 | // It may be clear that for a time difference of several days, the picosecond | |
1406 | // and even the nanosecond accuracy may be lost. | |
1407 | // To cope with this, the "mode" argument has been introduced to allow | |
1408 | // timestamp comparison on only the specified units. | |
1409 | // | |
1410 | // The following operation modes are supported : | |
1411 | // mode = 1 : Full time difference is returned in specified units | |
1412 | // 2 : Time difference is returned in specified units by | |
1413 | // neglecting the elapsed time for the larger units than the | |
1414 | // ones specified. | |
1415 | // 3 : Time difference is returned in specified units by only | |
1416 | // comparing the timestamps on the level of the specified units. | |
1417 | // | |
1418 | // Example : | |
1419 | // --------- | |
1420 | // AliTimestamp t1; // Corresponding to days=3, secs=501, ns=31, ps=7 | |
1421 | // AliTimestamp t2; // Corresponding to days=5, secs=535, ns=12, ps=15 | |
1422 | // | |
1423 | // The statement : Double_t val=t1.GetDifference(t2,....) | |
1424 | // would return the following values : | |
1425 | // val=(2*24*3600)+34-(19*1e-9)+(8*1e-12) for u="s" and mode=1 | |
1426 | // val=34-(19*1e-9)+(8*1e-12) for u="s" and mode=2 | |
1427 | // val=34 for u="s" and mode=3 | |
1428 | // val=-19 for u="ns" and mode=3 | |
1429 | // | |
1430 | // The default is mode=1. | |
1431 | ||
1432 | return GetDifference(&t,u,mode); | |
1433 | } | |
1434 | /////////////////////////////////////////////////////////////////////////// | |
0cfe76b5 | 1435 | void AliTimestamp::SetUT(Int_t y,Int_t m,Int_t d,Int_t hh,Int_t mm,Int_t ss,Int_t ns,Int_t ps) |
1436 | { | |
1437 | // Set the AliTimestamp parameters corresponding to the UT date and time | |
1438 | // in the Gregorian calendar as specified by the input arguments. | |
1439 | // This facility is exact upto picosecond precision and as such is | |
1440 | // for scientific observations preferable above the corresponding | |
1441 | // Set function(s) of TTimestamp. | |
1442 | // The latter has a random spread in the sub-second part, which | |
1443 | // might be of use in generating distinguishable timestamps while | |
1444 | // still keeping second precision. | |
1445 | // | |
1446 | // The input arguments represent the following : | |
1447 | // y : year in UT (e.g. 1952, 2003 etc...) | |
1448 | // m : month in UT (1=jan 2=feb etc...) | |
1449 | // d : day in UT (1-31) | |
1450 | // hh : elapsed hours in UT (0-23) | |
1451 | // mm : elapsed minutes in UT (0-59) | |
1452 | // ss : elapsed seconds in UT (0-59) | |
1453 | // ns : remaining fractional elapsed second of UT in nanosecond | |
1454 | // ps : remaining fractional elapsed nanosecond of UT in picosecond | |
1455 | // | |
1456 | // Note : ns=0 and ps=0 are the default values. | |
1457 | // | |
1458 | // This facility first determines the elapsed days, seconds etc... | |
1459 | // since the beginning of the specified UT year on bais of the | |
1460 | // input arguments. Subsequently it invokes the SetUT memberfunction | |
1461 | // for the elapsed timespan. | |
1462 | // As such this facility is valid for all AD dates in the Gregorian | |
1463 | // calendar with picosecond precision. | |
1464 | ||
1465 | Int_t day=GetDayOfYear(d,m,y); | |
1466 | Int_t secs=hh*3600+mm*60+ss; | |
1467 | SetUT(y,day-1,secs,ns,ps); | |
1468 | } | |
1469 | /////////////////////////////////////////////////////////////////////////// | |
1470 | void AliTimestamp::SetUT(Int_t y,Int_t d,Int_t s,Int_t ns,Int_t ps) | |
1471 | { | |
1472 | // Set the AliTimestamp parameters corresponding to the specified elapsed | |
1473 | // timespan since the beginning of the new UT year. | |
1474 | // This facility is exact upto picosecond precision and as such is | |
1475 | // for scientific observations preferable above the corresponding | |
1476 | // Set function(s) of TTimestamp. | |
1477 | // The latter has a random spread in the sub-second part, which | |
1478 | // might be of use in generating distinguishable timestamps while | |
1479 | // still keeping second precision. | |
1480 | // | |
1481 | // The UT year and elapsed time span is entered via the following input arguments : | |
1482 | // | |
1483 | // y : year in UT (e.g. 1952, 2003 etc...) | |
1484 | // d : elapsed number of days | |
1485 | // s : (remaining) elapsed number of seconds | |
1486 | // ns : (remaining) elapsed number of nanoseconds | |
1487 | // ps : (remaining) elapsed number of picoseconds | |
1488 | // | |
1489 | // The specified d, s, ns and ps values will be used in an additive | |
1490 | // way to determine the elapsed timespan. | |
1491 | // So, specification of d=1, s=100, ns=0, ps=0 will result in the | |
1492 | // same elapsed time span as d=0, s=24*3600+100, ns=0, ps=0. | |
1493 | // However, by making use of the latter the user should take care | |
1494 | // of possible integer overflow problems in the input arguments, | |
1495 | // which obviously will provide incorrect results. | |
1496 | // | |
1497 | // Note : ns=0 and ps=0 are the default values. | |
1498 | // | |
1499 | // This facility first sets the (M)JD corresponding to the start (01-jan 00:00:00) | |
1500 | // of the specified UT year following the recipe of R.W. Sinnott | |
1501 | // Sky & Telescope 82, (aug. 1991) 183. | |
1502 | // Subsequently the day and (sub)second parts are added to the AliTimestamp. | |
1503 | // As such this facility is valid for all AD dates in the Gregorian calendar. | |
1504 | ||
1505 | Double_t jd=GetJD(y,1,1,0,0,0,0); | |
1506 | SetJD(jd); | |
1507 | ||
1508 | Int_t mjd,sec,nsec; | |
1509 | GetMJD(mjd,sec,nsec); | |
1510 | SetMJD(mjd,0,0,0); | |
1511 | Add(d,s,ns,ps); | |
1512 | } | |
1513 | /////////////////////////////////////////////////////////////////////////// | |
a4f7a3a1 | 1514 | void AliTimestamp::GetUT(Int_t& hh,Int_t& mm,Int_t& ss,Int_t& ns,Int_t& ps) |
1515 | { | |
1516 | // Provide the corrresponding UT as hh:mm:ss:ns:ps. | |
1517 | // This facility is based on the MJD, so the TTimeStamp limitations | |
1518 | // do not apply here. | |
1519 | ||
1520 | Int_t mjd,sec,nsec,psec; | |
1521 | ||
1522 | GetMJD(mjd,sec,nsec); | |
1523 | psec=GetPs(); | |
1524 | ||
1525 | hh=sec/3600; | |
1526 | sec=sec%3600; | |
1527 | mm=sec/60; | |
1528 | ss=sec%60; | |
1529 | ns=nsec; | |
1530 | ps=psec; | |
1531 | } | |
1532 | /////////////////////////////////////////////////////////////////////////// | |
1533 | Double_t AliTimestamp::GetUT() | |
1534 | { | |
1535 | // Provide the corrresponding UT in fractional hours. | |
1536 | // This facility is based on the MJD, so the TTimeStamp limitations | |
1537 | // do not apply here. | |
1538 | ||
1539 | Int_t hh,mm,ss,ns,ps; | |
1540 | ||
1541 | GetUT(hh,mm,ss,ns,ps); | |
1542 | ||
1543 | Double_t ut=Convert(hh,mm,ss,ns,ps); | |
1544 | ||
1545 | return ut; | |
1546 | } | |
1547 | /////////////////////////////////////////////////////////////////////////// | |
1548 | void AliTimestamp::GetGST(Int_t& hh,Int_t& mm,Int_t& ss,Int_t& ns,Int_t& ps) | |
1549 | { | |
1550 | // Provide the corrresponding Greenwich Sideral Time (GST). | |
1551 | // The algorithm used is the one described at p. 83 of the book | |
1552 | // Astronomy Methods by Hale Bradt. | |
1553 | // This facility is based on the MJD, so the TTimeStamp limitations | |
1554 | // do not apply here. | |
1555 | ||
1556 | Int_t mjd,sec,nsec,psec; | |
1557 | ||
1558 | // The current UT based timestamp data | |
1559 | GetMJD(mjd,sec,nsec); | |
1560 | psec=fJps; | |
1561 | ||
1562 | // The basis for the daily corrections in units of Julian centuries w.r.t. J2000. | |
1563 | // Note : Epoch J2000 starts at 01-jan-2000 12:00:00 UT. | |
1564 | Double_t tau=(GetJD()-2451545.)/36525.; | |
1565 | ||
1566 | // Syncronise sidereal time with current timestamp | |
1567 | AliTimestamp sid; | |
1568 | sid.SetMJD(mjd,sec,nsec,psec); | |
1569 | ||
1570 | // Add offset for GST start value defined as 06:41:50.54841 at 01-jan 00:00:00 UT | |
1571 | sec=6*3600+41*60+50; | |
1572 | nsec=548410000; | |
1573 | psec=0; | |
1574 | sid.Add(0,sec,nsec,psec); | |
1575 | ||
1576 | // Daily correction for precession and polar motion | |
1577 | Double_t addsec=8640184.812866*tau+0.093104*pow(tau,2)-6.2e-6*pow(tau,3); | |
1578 | sec=int(addsec); | |
1579 | addsec-=double(sec); | |
1580 | nsec=int(addsec*1.e9); | |
1581 | addsec-=double(nsec)*1.e-9; | |
1582 | psec=int(addsec*1.e12); | |
1583 | sid.Add(0,sec,nsec,psec); | |
1584 | ||
1585 | sid.GetMJD(mjd,sec,nsec); | |
1586 | psec=sid.GetPs(); | |
1587 | ||
1588 | hh=sec/3600; | |
1589 | sec=sec%3600; | |
1590 | mm=sec/60; | |
1591 | ss=sec%60; | |
1592 | ns=nsec; | |
1593 | ps=psec; | |
1594 | } | |
1595 | /////////////////////////////////////////////////////////////////////////// | |
1596 | Double_t AliTimestamp::GetGST() | |
1597 | { | |
1598 | // Provide the corrresponding Greenwich Sideral Time (GMST) | |
1599 | // in fractional hours. | |
1600 | // This facility is based on the MJD, so the TTimeStamp limitations | |
1601 | // do not apply here. | |
1602 | ||
1603 | Int_t hh,mm,ss,ns,ps; | |
1604 | ||
1605 | GetGST(hh,mm,ss,ns,ps); | |
1606 | ||
1607 | Double_t gst=Convert(hh,mm,ss,ns,ps); | |
1608 | ||
1609 | return gst; | |
1610 | } | |
1611 | /////////////////////////////////////////////////////////////////////////// | |
1612 | Double_t AliTimestamp::GetJD(Double_t e,TString mode) const | |
1613 | { | |
1614 | // Provide the fractional Julian Date from epoch e. | |
1615 | // The sort of epoch may be specified via the "mode" parameter. | |
1616 | // | |
1617 | // mode = "J" ==> Julian epoch | |
1618 | // "B" ==> Besselian epoch | |
1619 | // | |
1620 | // The default value is mode="J". | |
1621 | ||
1622 | Double_t jd=0; | |
1623 | ||
1624 | if (mode=="J" || mode=="j") jd=(e-2000.0)*365.25+2451545.0; | |
1625 | ||
1626 | if (mode=="B" || mode=="b") jd=(e-1900.0)*365.242198781+2415020.31352; | |
1627 | ||
1628 | return jd; | |
1629 | } | |
1630 | /////////////////////////////////////////////////////////////////////////// | |
1631 | Double_t AliTimestamp::GetMJD(Double_t e,TString mode) const | |
1632 | { | |
1633 | // Provide the fractional Modified Julian Date from epoch e. | |
1634 | // The sort of epoch may be specified via the "mode" parameter. | |
1635 | // | |
1636 | // mode = "J" ==> Julian epoch | |
1637 | // "B" ==> Besselian epoch | |
1638 | // | |
1639 | // The default value is mode="J". | |
1640 | ||
1641 | Double_t mjd=GetJD(e,mode)-2400000.5; | |
1642 | ||
1643 | return mjd; | |
1644 | } | |
1645 | /////////////////////////////////////////////////////////////////////////// | |
1646 | Double_t AliTimestamp::GetTJD(Double_t e,TString mode) const | |
1647 | { | |
1648 | // Provide the fractional Truncated Julian Date from epoch e. | |
1649 | // The sort of epoch may be specified via the "mode" parameter. | |
1650 | // | |
1651 | // mode = "J" ==> Julian epoch | |
1652 | // "B" ==> Besselian epoch | |
1653 | // | |
1654 | // The default value is mode="J". | |
1655 | ||
1656 | Double_t tjd=GetJD(e,mode)-2440000.5; | |
1657 | ||
1658 | return tjd; | |
1659 | } | |
1660 | /////////////////////////////////////////////////////////////////////////// |