]>
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 | // | |
38 | // The Julian Epoch (JE) indicates the fractional elapsed year count since | |
39 | // midnight (UT) on 01-jan at the start of the Gregorian year count. | |
40 | // A year is defined to be 365.25 days, so the integer part of JE corresponds | |
41 | // to the usual Gregorian year count. | |
42 | // So, 01-jan-1965 00:00:00 UT corresponds to JE=1965.0 | |
43 | // | |
44 | // Because of the fact that the Julian date indicators are all w.r.t. UT | |
45 | // they provide an absolute timescale irrespective of timezone or daylight | |
46 | // saving time (DST). | |
47 | // | |
48 | // This AliTimestamp facility allows for nanosecond precision. | |
49 | // However, when the fractional JD, MJD and TJD counts are used instead | |
50 | // of the integer (days,sec,ns) specification, the nanosecond precision | |
51 | // may be lost due to computer accuracy w.r.t. floating point operations. | |
52 | // | |
53 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
54 | // which corresponds to JD=2440587.5 or the start of MJD=40587 or TJD=587. | |
55 | // Using the corresponding MJD of this EPOCH allows construction of | |
56 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input (M/T)JD and time. | |
57 | // Obviously this TTimeStamp implementation would prevent usage of values | |
58 | // smaller than JD=2440587.5 or MJD=40587 or TJD=587. | |
59 | // However, this AliTimestamp facility provides support for the full range | |
60 | // of (M/T)JD values, but the setting of the corresponding TTimeStamp parameters | |
61 | // is restricted to the values allowed by the TTimeStamp implementation. | |
62 | // For these earlier (M/T)JD values, the standard TTimeStamp parameters will | |
63 | // be set corresponding to the start of the TTimeStamp EPOCH. | |
64 | // This implies that for these earlier (M/T)JD values the TTimeStamp parameters | |
65 | // do not match the Julian parameters of AliTimestamp. | |
66 | // As such the standard TTimeStamp parameters do not appear on the print output | |
67 | // when invoking the Date() memberfunction for these earlier (M/T)JD values. | |
68 | // | |
69 | // Examples : | |
70 | // ========== | |
71 | // | |
72 | // Note : All TTimeStamp functionality is available as well. | |
73 | // | |
74 | // AliTimestamp t; | |
75 | // | |
76 | // t.Date(); | |
77 | // | |
78 | // // Retrieve Julian Date | |
79 | // Int_t jd,jsec,jns; | |
80 | // t.GetJD(jd,jsec,jns); | |
81 | // | |
82 | // // Retrieve fractional Truncated Julian Date | |
83 | // Double_t tjd=t.GetTJD(); | |
84 | // | |
85 | // // Retrieve fractional Julian Epoch | |
86 | // Double_t je=t.GetJE(); | |
87 | // | |
88 | // // Set to a specific Modified Julian Date | |
89 | // Int_t mjd=50537; | |
90 | // Int_t mjsec=1528; | |
91 | // Int_t mjns=185643; | |
92 | // t.SetMJD(mjd,mjsec,mjns); | |
93 | // | |
94 | // t.Date(); | |
95 | // | |
96 | // // Some practical conversion facilities | |
97 | // // Note : They don't influence the actual date/time settings | |
98 | // // and as such can also be invoked as AliTimestamp::Convert(...) etc... | |
99 | // Int_t y=1921; | |
100 | // Int_t m=7; | |
101 | // Int_t d=21; | |
102 | // Int_t hh=15; | |
103 | // Int_t mm=23; | |
104 | // Int_t ss=47; | |
105 | // Int_t ns=811743; | |
106 | // Double_t jdate=t.GetJD(y,m,d,hh,mm,ss,ns); | |
107 | // | |
108 | // Int_t days,secs,nsecs; | |
109 | // Double_t date=421.1949327; | |
110 | // t.Convert(date,days,secs,nsecs); | |
111 | // | |
112 | // days=875; | |
113 | // secs=23; | |
114 | // nsecs=9118483; | |
115 | // date=t.Convert(days,secs,nsecs); | |
116 | // | |
117 | // Double_t mjdate=40563.823744; | |
118 | // Double_t epoch=t.GetJE(mjdate,"mjd"); | |
119 | // | |
120 | //--- Author: Nick van Eijndhoven 28-jan-2005 Utrecht University. | |
121 | //- Modified: NvE $Date$ Utrecht University. | |
122 | /////////////////////////////////////////////////////////////////////////// | |
123 | ||
124 | #include "AliTimestamp.h" | |
125 | #include "Riostream.h" | |
126 | ||
127 | ClassImp(AliTimestamp) // Class implementation to enable ROOT I/O | |
128 | ||
129 | AliTimestamp::AliTimestamp() : TTimeStamp() | |
130 | { | |
131 | // Default constructor | |
132 | // Creation of an AliTimestamp object and initialisation of parameters. | |
133 | // All attributes are initialised to the current date/time as specified | |
134 | // in the docs of TTimeStamp. | |
135 | ||
136 | FillJulian(); | |
137 | } | |
138 | /////////////////////////////////////////////////////////////////////////// | |
139 | AliTimestamp::AliTimestamp(TTimeStamp& t) : TTimeStamp(t) | |
140 | { | |
141 | // Creation of an AliTimestamp object and initialisation of parameters. | |
142 | // All attributes are initialised to the values of the input TTimeStamp. | |
143 | ||
144 | FillJulian(); | |
145 | } | |
146 | /////////////////////////////////////////////////////////////////////////// | |
147 | AliTimestamp::~AliTimestamp() | |
148 | { | |
149 | // Destructor to delete dynamically allocated memory. | |
150 | } | |
151 | /////////////////////////////////////////////////////////////////////////// | |
152 | AliTimestamp::AliTimestamp(const AliTimestamp& t) : TTimeStamp(t) | |
153 | { | |
154 | // Copy constructor | |
155 | ||
156 | fMJD=t.fMJD; | |
157 | fJsec=t.fJsec; | |
158 | fJns=t.fJns; | |
159 | fCalcs=t.fCalcs; | |
160 | fCalcns=t.fCalcns; | |
161 | } | |
162 | /////////////////////////////////////////////////////////////////////////// | |
163 | void AliTimestamp::Date(Int_t mode) | |
164 | { | |
165 | // Print date/time info. | |
166 | // | |
167 | // mode = 1 ==> Only the TTimeStamp yy-mm-dd hh:mm:ss:ns info is printed | |
168 | // 2 ==> Only the Julian parameter info is printed | |
169 | // 3 ==> Both the TTimeStamp and Julian parameter info is printed | |
170 | // | |
171 | // The default is mode=3. | |
172 | // | |
173 | // Note : In case the (M/T)JD falls outside the TTimeStamp range, | |
174 | // the TTimeStamp info will not be printed. | |
175 | ||
176 | Int_t mjd,mjsec,mjns; | |
177 | GetMJD(mjd,mjsec,mjns); | |
178 | ||
179 | if ((mode==1 || mode==3) && mjd>=40587) cout << " " << AsString() << endl; | |
180 | if (mode==2 || mode==3) | |
181 | { | |
182 | Int_t jd,jsec,jns; | |
183 | GetJD(jd,jsec,jns); | |
184 | Int_t tjd,tjsec,tjns; | |
185 | GetTJD(tjd,tjsec,tjns); | |
186 | cout << " Julian Epoch : " << setprecision(25) << GetJE() << endl; | |
187 | cout << " JD : " << jd << " sec : " << jsec << " ns : " << jns | |
188 | << " Fractional : " << setprecision(25) << GetJD() << endl; | |
189 | cout << " MJD : " << mjd << " sec : " << mjsec << " ns : " << mjns | |
190 | << " Fractional : " << setprecision(25) << GetMJD() << endl; | |
191 | cout << " TJD : " << tjd << " sec : " << tjsec << " ns : " << tjns | |
192 | << " Fractional : " << setprecision(25) << GetTJD() << endl; | |
193 | } | |
194 | } | |
195 | /////////////////////////////////////////////////////////////////////////// | |
196 | 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 | |
197 | { | |
198 | // Provide the (fractional) Julian Date (JD) corresponding to the UT date | |
199 | // and time in the Gregorian calendar as specified by the input arguments. | |
200 | // | |
201 | // The input arguments represent the following : | |
202 | // y : year in UT (e.g. 1952, 2003 etc...) | |
203 | // m : month in UT (1=jan 2=feb etc...) | |
204 | // d : day in UT (1-31) | |
205 | // hh : elapsed hours in UT (0-23) | |
206 | // mm : elapsed minutes in UT (0-59) | |
207 | // ss : elapsed seconds in UT (0-59) | |
208 | // ns : remaining fractional elapsed second of UT in nanosecond | |
209 | // | |
210 | // This algorithm is valid for all AD dates in the Gregorian calendar | |
211 | // following the recipe of R.W. Sinnott Sky & Telescope 82, (aug. 1991) 183. | |
212 | // See also http://scienceworld.wolfram.com/astronomy/JulianDate.html | |
213 | // | |
214 | // In case of invalid input, a value of -1 is returned. | |
215 | // | |
216 | // Note : | |
217 | // ------ | |
218 | // This memberfunction only provides the JD corresponding to the | |
219 | // UT input arguments. It does NOT set the corresponding Julian parameters | |
220 | // for the current AliTimestamp instance. | |
221 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
222 | // To set the Julian parameters for the current AliTimestamp instance, | |
223 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
224 | // or TTimeStamp. | |
225 | ||
226 | if (y<0 || m<1 || m>12 || d<1 || d>31) return -1; | |
227 | if (hh<0 || hh>23 || mm<0 || mm>59 || ss<0 || ss>59 || ns<0 || ns>1e9) return -1; | |
228 | ||
229 | // The UT daytime in fractional hours | |
230 | Double_t ut=double(hh)+double(mm)/60.+(double(ss)+double(ns)*1.e-9)/3600.; | |
231 | ||
232 | Double_t JD=0; | |
233 | ||
234 | JD=367*y-int(7*(y+int((m+9)/12))/4) | |
235 | -int(3*(int((y+(m-9)/7)/100)+1)/4) | |
236 | +int(275*m/9)+d+1721028.5+ut/24.; | |
237 | ||
238 | return JD; | |
239 | } | |
240 | /////////////////////////////////////////////////////////////////////////// | |
241 | 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 | |
242 | { | |
243 | // Provide the (fractional) Modified Julian Date corresponding to the UT | |
244 | // date and time in the Gregorian calendar as specified by the input arguments. | |
245 | // | |
246 | // The input arguments represent the following : | |
247 | // y : year in UT (e.g. 1952, 2003 etc...) | |
248 | // m : month in UT (1=jan 2=feb etc...) | |
249 | // d : day in UT (1-31) | |
250 | // hh : elapsed hours in UT (0-23) | |
251 | // mm : elapsed minutes in UT (0-59) | |
252 | // ss : elapsed seconds in UT (0-59) | |
253 | // ns : remaining fractional elapsed second of UT in nanosecond | |
254 | // | |
255 | // This algorithm is valid for all AD dates in the Gregorian calendar | |
256 | // following the recipe of R.W. Sinnott Sky & Telescope 82, (aug. 1991) 183. | |
257 | // See also http://scienceworld.wolfram.com/astronomy/JulianDate.html | |
258 | // | |
259 | // In case of invalid input, a value of -1 is returned. | |
260 | // | |
261 | // Note : | |
262 | // ------ | |
263 | // This memberfunction only provides the MJD corresponding to the | |
264 | // UT input arguments. It does NOT set the corresponding Julian parameters | |
265 | // for the current AliTimestamp instance. | |
266 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
267 | // To set the Julian parameters for the current AliTimestamp instance, | |
268 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
269 | // or TTimeStamp. | |
270 | ||
271 | Double_t JD=GetJD(y,m,d,hh,mm,ss,ns); | |
272 | ||
273 | if (JD<0) return JD; | |
274 | ||
275 | Double_t MJD=JD-2400000.5; | |
276 | ||
277 | return MJD; | |
278 | } | |
279 | /////////////////////////////////////////////////////////////////////////// | |
280 | 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 | |
281 | { | |
282 | // Provide the (fractional) Truncated Julian Date corresponding to the UT | |
283 | // date and time in the Gregorian calendar as specified by the input arguments. | |
284 | // | |
285 | // The input arguments represent the following : | |
286 | // y : year in UT (e.g. 1952, 2003 etc...) | |
287 | // m : month in UT (1=jan 2=feb etc...) | |
288 | // d : day in UT (1-31) | |
289 | // hh : elapsed hours in UT (0-23) | |
290 | // mm : elapsed minutes in UT (0-59) | |
291 | // ss : elapsed seconds in UT (0-59) | |
292 | // ns : remaining fractional elapsed second of UT in nanosecond | |
293 | // | |
294 | // This algorithm is valid for all AD dates in the Gregorian calendar | |
295 | // following the recipe of R.W. Sinnott Sky & Telescope 82, (aug. 1991) 183. | |
296 | // See also http://scienceworld.wolfram.com/astronomy/JulianDate.html | |
297 | // | |
298 | // In case of invalid input, a value of -1 is returned. | |
299 | // | |
300 | // Note : | |
301 | // ------ | |
302 | // This memberfunction only provides the TJD corresponding to the | |
303 | // UT input arguments. It does NOT set the corresponding Julian parameters | |
304 | // for the current AliTimestamp instance. | |
305 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
306 | // To set the Julian parameters for the current AliTimestamp instance, | |
307 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
308 | // or TTimeStamp. | |
309 | ||
310 | Double_t JD=GetJD(y,m,d,hh,mm,ss,ns); | |
311 | ||
312 | if (JD<0) return JD; | |
313 | ||
314 | Double_t TJD=JD-2440000.5; | |
315 | ||
316 | return TJD; | |
317 | } | |
318 | /////////////////////////////////////////////////////////////////////////// | |
319 | Double_t AliTimestamp::GetJE(Double_t date,TString mode) const | |
320 | { | |
321 | // Provide the Julian Epoch (JE) corresponding to the specified date. | |
322 | // The argument "mode" indicates the type of the argument "date". | |
323 | // | |
324 | // Available modes are : | |
325 | // mode = "jd" ==> date represents the Julian Date | |
326 | // = "mjd" ==> date represents the Modified Julian Date | |
327 | // = "tjd" ==> date represents the Truncated Julian Date | |
328 | // | |
329 | // The default is mode="jd". | |
330 | // | |
331 | // In case of invalid input, a value of -99999 is returned. | |
332 | // | |
333 | // Note : | |
334 | // ------ | |
335 | // This memberfunction only provides the JE corresponding to the | |
336 | // input arguments. It does NOT set the corresponding Julian parameters | |
337 | // for the current AliTimestamp instance. | |
338 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
339 | // To set the Julian parameters for the current AliTimestamp instance, | |
340 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
341 | // or TTimeStamp. | |
342 | ||
343 | if ((mode != "jd") && (mode != "mjd") && (mode != "tjd")) return -99999; | |
344 | ||
345 | Double_t jd=date; | |
346 | if (mode=="mjd") jd=date+2400000.5; | |
347 | if (mode=="tjd") jd=date+2440000.5; | |
348 | ||
349 | Double_t je=2000.+(jd-2451545.)/365.25; | |
350 | ||
351 | return je; | |
352 | } | |
353 | /////////////////////////////////////////////////////////////////////////// | |
354 | void AliTimestamp::Convert(Double_t date,Int_t& days,Int_t& secs,Int_t& ns) const | |
355 | { | |
356 | // Convert date as fractional day count into integer days, secs and ns. | |
357 | // | |
358 | // Note : Due to computer accuracy the ns value may become inaccurate. | |
359 | // | |
360 | // The arguments represent the following : | |
361 | // date : The input date as fractional day count | |
362 | // days : Number of elapsed days | |
363 | // secs : Remaining number of elapsed seconds | |
364 | // ns : Remaining fractional elapsed second in nanoseconds | |
365 | // | |
366 | // Note : | |
367 | // ------ | |
368 | // This memberfunction only converts the input date into the corresponding | |
369 | // integer parameters. It does NOT set the corresponding Julian parameters | |
370 | // for the current AliTimestamp instance. | |
371 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
372 | // To set the Julian parameters for the current AliTimestamp instance, | |
373 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
374 | // or TTimeStamp. | |
375 | ||
376 | days=int(date); | |
377 | date=date-double(days); | |
378 | Int_t daysecs=24*3600; | |
379 | date=date*double(daysecs); | |
380 | secs=int(date); | |
381 | date=date-double(secs); | |
382 | ns=int(date*1.e9); | |
383 | } | |
384 | /////////////////////////////////////////////////////////////////////////// | |
385 | Double_t AliTimestamp::Convert(Int_t days,Int_t secs,Int_t ns) const | |
386 | { | |
387 | // Convert date in integer days, secs and ns into fractional day count. | |
388 | // | |
389 | // Note : Due to computer accuracy the ns precision may be lost. | |
390 | // | |
391 | // The input arguments represent the following : | |
392 | // days : Number of elapsed days | |
393 | // secs : Remaining number of elapsed seconds | |
394 | // ns : Remaining fractional elapsed second in nanoseconds | |
395 | // | |
396 | // Note : | |
397 | // ------ | |
398 | // This memberfunction only converts the input integer parameters into the | |
399 | // corresponding fractional day count. It does NOT set the corresponding | |
400 | // Julian parameters for the current AliTimestamp instance. | |
401 | // As such the TTimeStamp limitations do NOT apply to this memberfunction. | |
402 | // To set the Julian parameters for the current AliTimestamp instance, | |
403 | // please use the corresponding SET() memberfunctions of either AliTimestamp | |
404 | // or TTimeStamp. | |
405 | ||
406 | Double_t frac=double(secs)+double(ns)*1.e-9; | |
407 | Int_t daysecs=24*3600; | |
408 | frac=frac/double(daysecs); | |
409 | Double_t date=double(days)+frac; | |
410 | return date; | |
411 | } | |
412 | /////////////////////////////////////////////////////////////////////////// | |
413 | void AliTimestamp::FillJulian() | |
414 | { | |
415 | // Calculation and setting of the Julian date/time parameters corresponding | |
416 | // to the current TTimeStamp date/time parameters. | |
417 | ||
418 | UInt_t y,m,d,hh,mm,ss; | |
419 | ||
420 | GetDate(kTRUE,0,&y,&m,&d); | |
421 | GetTime(kTRUE,0,&hh,&mm,&ss); | |
422 | Int_t ns=GetNanoSec(); | |
423 | ||
424 | Double_t mjd=GetMJD(y,m,d,hh,mm,ss,ns); | |
425 | ||
426 | fMJD=int(mjd); | |
427 | fJsec=GetSec()%(24*3600); // Daytime in elapsed seconds | |
428 | fJns=ns; // Remaining fractional elapsed second in nanoseconds | |
429 | ||
430 | // Store the TTimeStamp seconds and nanoseconds values | |
431 | // for which this Julian calculation was performed. | |
432 | fCalcs=GetSec(); | |
433 | fCalcns=GetNanoSec(); | |
434 | } | |
435 | /////////////////////////////////////////////////////////////////////////// | |
436 | void AliTimestamp::GetMJD(Int_t& mjd,Int_t& sec, Int_t& ns) | |
437 | { | |
438 | // Provide the Modified Julian Date (MJD) and time corresponding to the | |
439 | // currently stored AliTimestamp date/time parameters. | |
440 | // | |
441 | // The returned arguments represent the following : | |
442 | // mjd : The modified Julian date. | |
443 | // sec : The number of seconds elapsed within the MJD. | |
444 | // ns : The remaining fractional number of seconds (in ns) elapsed within the MJD. | |
445 | ||
446 | if (fCalcs != GetSec() || fCalcns != GetNanoSec()) FillJulian(); | |
447 | ||
448 | mjd=fMJD; | |
449 | sec=fJsec; | |
450 | ns=fJns; | |
451 | } | |
452 | /////////////////////////////////////////////////////////////////////////// | |
453 | Double_t AliTimestamp::GetMJD() | |
454 | { | |
455 | // Provide the (fractional) Modified Julian Date (MJD) corresponding to the | |
456 | // currently stored AliTimestamp date/time parameters. | |
457 | // | |
458 | // Due to computer accuracy the ns precision may be lost. | |
459 | // It is advised to use the (mjd,sec,ns) getter instead. | |
460 | ||
461 | Int_t mjd=0; | |
462 | Int_t sec=0; | |
463 | Int_t ns=0; | |
464 | GetMJD(mjd,sec,ns); | |
465 | ||
466 | Double_t date=Convert(mjd,sec,ns); | |
467 | ||
468 | return date; | |
469 | } | |
470 | /////////////////////////////////////////////////////////////////////////// | |
471 | void AliTimestamp::GetTJD(Int_t& tjd,Int_t& sec, Int_t& ns) | |
472 | { | |
473 | // Provide the Truncated Julian Date (TJD) and time corresponding to the | |
474 | // currently stored AliTimestamp date/time parameters. | |
475 | // | |
476 | // The returned arguments represent the following : | |
477 | // tjd : The modified Julian date. | |
478 | // sec : The number of seconds elapsed within the MJD. | |
479 | // ns : The remaining fractional number of seconds (in ns) elapsed within the MJD. | |
480 | ||
481 | Int_t mjd=0; | |
482 | GetMJD(mjd,sec,ns); | |
483 | ||
484 | tjd=mjd-40000; | |
485 | } | |
486 | /////////////////////////////////////////////////////////////////////////// | |
487 | Double_t AliTimestamp::GetTJD() | |
488 | { | |
489 | // Provide the (fractional) Truncated Julian Date (TJD) corresponding to the | |
490 | // currently stored AliTimestamp date/time parameters. | |
491 | // | |
492 | // Due to computer accuracy the ns precision may be lost. | |
493 | // It is advised to use the (mjd,sec,ns) getter instead. | |
494 | ||
495 | Int_t tjd=0; | |
496 | Int_t sec=0; | |
497 | Int_t ns=0; | |
498 | GetTJD(tjd,sec,ns); | |
499 | ||
500 | Double_t date=Convert(tjd,sec,ns); | |
501 | ||
502 | return date; | |
503 | } | |
504 | /////////////////////////////////////////////////////////////////////////// | |
505 | void AliTimestamp::GetJD(Int_t& jd,Int_t& sec, Int_t& ns) | |
506 | { | |
507 | // Provide the Julian Date (JD) and time corresponding to the currently | |
508 | // stored AliTimestamp date/time parameters. | |
509 | // | |
510 | // The returned arguments represent the following : | |
511 | // jd : The Julian date. | |
512 | // sec : The number of seconds elapsed within the JD. | |
513 | // ns : The remaining fractional number of seconds (in ns) elapsed within the JD. | |
514 | ||
515 | Int_t mjd=0; | |
516 | GetMJD(mjd,sec,ns); | |
517 | ||
518 | jd=mjd+2400000; | |
519 | sec+=12*3600; | |
520 | if (sec >= 24*3600) | |
521 | { | |
522 | sec-=24*3600; | |
523 | jd+=1; | |
524 | } | |
525 | } | |
526 | /////////////////////////////////////////////////////////////////////////// | |
527 | Double_t AliTimestamp::GetJD() | |
528 | { | |
529 | // Provide the (fractional) Julian Date (JD) corresponding to the currently | |
530 | // stored AliTimestamp date/time parameters. | |
531 | // | |
532 | // Due to computer accuracy the ns precision may be lost. | |
533 | // It is advised to use the (jd,sec,ns) getter instead. | |
534 | ||
535 | Int_t jd=0; | |
536 | Int_t sec=0; | |
537 | Int_t ns=0; | |
538 | GetJD(jd,sec,ns); | |
539 | ||
540 | Double_t date=Convert(jd,sec,ns); | |
541 | ||
542 | return date; | |
543 | } | |
544 | /////////////////////////////////////////////////////////////////////////// | |
545 | Double_t AliTimestamp::GetJE() | |
546 | { | |
547 | // Provide the Julian Epoch (JE) corresponding to the currently stored | |
548 | // AliTimestamp date/time parameters. | |
549 | ||
550 | Double_t jd=GetJD(); | |
551 | Double_t je=GetJE(jd); | |
552 | return je; | |
553 | } | |
554 | /////////////////////////////////////////////////////////////////////////// | |
555 | void AliTimestamp::SetMJD(Int_t mjd,Int_t sec,Int_t ns) | |
556 | { | |
557 | // Set the Modified Julian Date (MJD) and time and update the TTimeStamp | |
558 | // parameters accordingly (if possible). | |
559 | // | |
560 | // Note : | |
561 | // ------ | |
562 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
563 | // which corresponds to the start of MJD=40587. | |
564 | // Using the corresponding MJD of this EPOCH allows construction of | |
565 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
566 | // Obviously this TTimeStamp implementation would prevent usage of MJD values | |
567 | // smaller than 40587. | |
568 | // However, this AliTimestamp facility provides support for the full range | |
569 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
570 | // is restricted to the values allowed by the TTimeStamp implementation. | |
571 | // For these earlier MJD values, the standard TTimeStamp parameters will | |
572 | // be set corresponding to the start of the TTimeStamp EPOCH. | |
573 | // This implies that for these earlier MJD values the TTimeStamp parameters | |
574 | // do not match the Julian parameters of AliTimestamp. | |
575 | // | |
576 | // The input arguments represent the following : | |
577 | // mjd : The modified Julian date. | |
578 | // sec : The number of seconds elapsed within the MJD. | |
579 | // ns : The remaining fractional number of seconds (in ns) elapsed within the MJD. | |
580 | ||
581 | if (sec<0 || ns<0) | |
582 | { | |
583 | cout << " *AliTimestamp::SetMJD* Invalid input." | |
584 | << " sec : " << sec << " ns : " << ns << endl; | |
585 | return; | |
586 | } | |
587 | ||
588 | fMJD=mjd; | |
589 | fJsec=sec; | |
590 | fJns=ns; | |
591 | ||
592 | Int_t epoch=40587; | |
593 | ||
594 | if (mjd<epoch) | |
595 | { | |
596 | Set(0,kFALSE,0,kFALSE); | |
597 | } | |
598 | else | |
599 | { | |
600 | // The elapsed time since start of EPOCH | |
601 | Int_t days=mjd-epoch; | |
602 | UInt_t secs=days*24*3600; | |
603 | secs+=sec; | |
604 | Set(secs,kFALSE,0,kFALSE); | |
605 | Int_t date=GetDate(); | |
606 | Int_t time=GetTime(); | |
607 | Set(date,time,ns,kTRUE,0); | |
608 | } | |
609 | ||
610 | // Denote that the Julian and TTimeStamp parameters are synchronised, | |
611 | // even in the case the MJD falls outside the TTimeStamp validity range. | |
612 | // The latter still allows retrieval of Julian parameters for these | |
613 | // earlier times. | |
614 | fCalcs=GetSec(); | |
615 | fCalcns=GetNanoSec(); | |
616 | } | |
617 | /////////////////////////////////////////////////////////////////////////// | |
618 | void AliTimestamp::SetMJD(Double_t mjd) | |
619 | { | |
620 | // Set the Modified Julian Date (MJD) and time and update the TTimeStamp | |
621 | // parameters accordingly (if possible). | |
622 | // | |
623 | // Note : | |
624 | // ------ | |
625 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
626 | // which corresponds to the start of MJD=40587. | |
627 | // Using the corresponding MJD of this EPOCH allows construction of | |
628 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
629 | // Obviously this TTimeStamp implementation would prevent usage of MJD values | |
630 | // smaller than 40587. | |
631 | // However, this AliTimestamp facility provides support for the full range | |
632 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
633 | // is restricted to the values allowed by the TTimeStamp implementation. | |
634 | // For these earlier MJD values, the standard TTimeStamp parameters will | |
635 | // be set corresponding to the start of the TTimeStamp EPOCH. | |
636 | // This implies that for these earlier MJD values the TTimeStamp parameters | |
637 | // do not match the Julian parameters of AliTimestamp. | |
638 | // | |
639 | // Due to computer accuracy the ns precision may be lost. | |
640 | // It is advised to use the (mjd,sec,ns) setting instead. | |
641 | // | |
642 | // The input argument represents the following : | |
643 | // mjd : The modified Julian date as fractional day count. | |
644 | ||
645 | Int_t days=0; | |
646 | Int_t secs=0; | |
647 | Int_t ns=0; | |
648 | Convert(mjd,days,secs,ns); | |
649 | SetMJD(days,secs,ns); | |
650 | } | |
651 | /////////////////////////////////////////////////////////////////////////// | |
652 | void AliTimestamp::SetJD(Int_t jd,Int_t sec,Int_t ns) | |
653 | { | |
654 | // Set the Julian Date (JD) and time and update the TTimeStamp | |
655 | // parameters accordingly (if possible). | |
656 | // | |
657 | // Note : | |
658 | // ------ | |
659 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
660 | // which corresponds to JD=2440587.5 or the start of MJD=40587. | |
661 | // Using the corresponding MJD of this EPOCH allows construction of | |
662 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
663 | // Obviously this TTimeStamp implementation would prevent usage of values | |
664 | // smaller than JD=2440587.5. | |
665 | // However, this AliTimestamp facility provides support for the full range | |
666 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
667 | // is restricted to the values allowed by the TTimeStamp implementation. | |
668 | // For these earlier JD values, the standard TTimeStamp parameters will | |
669 | // be set corresponding to the start of the TTimeStamp EPOCH. | |
670 | // This implies that for these earlier (M)JD values the TTimeStamp parameters | |
671 | // do not match the Julian parameters of AliTimestamp. | |
672 | // | |
673 | // The input arguments represent the following : | |
674 | // jd : The Julian date. | |
675 | // sec : The number of seconds elapsed within the JD. | |
676 | // ns : The remaining fractional number of seconds (in ns) elapsed within the JD. | |
677 | ||
678 | Int_t mjd=jd-2400000; | |
679 | sec-=12*3600; | |
680 | if (sec<0) | |
681 | { | |
682 | sec+=24*3600; | |
683 | mjd-=1; | |
684 | } | |
685 | ||
686 | SetMJD(mjd,sec,ns); | |
687 | } | |
688 | /////////////////////////////////////////////////////////////////////////// | |
689 | void AliTimestamp::SetJD(Double_t jd) | |
690 | { | |
691 | // Set the Julian Date (JD) and time and update the TTimeStamp | |
692 | // parameters accordingly (if possible). | |
693 | // | |
694 | // Note : | |
695 | // ------ | |
696 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
697 | // which corresponds to JD=2440587.5 or the start of MJD=40587. | |
698 | // Using the corresponding MJD of this EPOCH allows construction of | |
699 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
700 | // Obviously this TTimeStamp implementation would prevent usage of values | |
701 | // smaller than JD=2440587.5. | |
702 | // However, this AliTimestamp facility provides support for the full range | |
703 | // of (M)JD values, but the setting of the corresponding TTimeStamp parameters | |
704 | // is restricted to the values allowed by the TTimeStamp implementation. | |
705 | // For these earlier JD values, the standard TTimeStamp parameters will | |
706 | // be set corresponding to the start of the TTimeStamp EPOCH. | |
707 | // This implies that for these earlier (M)JD values the TTimeStamp parameters | |
708 | // do not match the Julian parameters of AliTimestamp. | |
709 | // | |
710 | // Due to computer accuracy the ns precision may be lost. | |
711 | // It is advised to use the (jd,sec,ns) setting instead. | |
712 | // | |
713 | // The input argument represents the following : | |
714 | // jd : The Julian date as fractional day count. | |
715 | ||
716 | Int_t days=0; | |
717 | Int_t secs=0; | |
718 | Int_t ns=0; | |
719 | Convert(jd,days,secs,ns); | |
720 | ||
721 | SetJD(days,secs,ns); | |
722 | } | |
723 | /////////////////////////////////////////////////////////////////////////// | |
724 | void AliTimestamp::SetTJD(Int_t tjd,Int_t sec,Int_t ns) | |
725 | { | |
726 | // Set the Truncated Julian Date (TJD) and time and update the TTimeStamp | |
727 | // parameters accordingly (if possible). | |
728 | // | |
729 | // Note : | |
730 | // ------ | |
731 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
732 | // which corresponds to JD=2440587.5 or the start of TJD=587. | |
733 | // Using the corresponding MJD of this EPOCH allows construction of | |
734 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
735 | // Obviously this TTimeStamp implementation would prevent usage of values | |
736 | // smaller than TJD=587. | |
737 | // However, this AliTimestamp facility provides support for the full range | |
738 | // of (T)JD values, but the setting of the corresponding TTimeStamp parameters | |
739 | // is restricted to the values allowed by the TTimeStamp implementation. | |
740 | // For these earlier JD values, the standard TTimeStamp parameters will | |
741 | // be set corresponding to the start of the TTimeStamp EPOCH. | |
742 | // This implies that for these earlier (T)JD values the TTimeStamp parameters | |
743 | // do not match the Julian parameters of AliTimestamp. | |
744 | // | |
745 | // The input arguments represent the following : | |
746 | // tjd : The Truncated Julian date. | |
747 | // sec : The number of seconds elapsed within the JD. | |
748 | // ns : The remaining fractional number of seconds (in ns) elapsed within the JD. | |
749 | ||
750 | Int_t mjd=tjd+40000; | |
751 | ||
752 | SetMJD(mjd,sec,ns); | |
753 | } | |
754 | /////////////////////////////////////////////////////////////////////////// | |
755 | void AliTimestamp::SetTJD(Double_t tjd) | |
756 | { | |
757 | // Set the Truncated Julian Date (TJD) and time and update the TTimeStamp | |
758 | // parameters accordingly (if possible). | |
759 | // | |
760 | // Note : | |
761 | // ------ | |
762 | // The TTimeStamp EPOCH starts at 01-jan-1970 00:00:00 UTC | |
763 | // which corresponds to JD=2440587.5 or the start of TJD=587. | |
764 | // Using the corresponding MJD of this EPOCH allows construction of | |
765 | // the yy-mm-dd hh:mm:ss:ns TTimeStamp from a given input MJD and time. | |
766 | // Obviously this TTimeStamp implementation would prevent usage of values | |
767 | // smaller than TJD=587. | |
768 | // However, this AliTimestamp facility provides support for the full range | |
769 | // of (T)JD values, but the setting of the corresponding TTimeStamp parameters | |
770 | // is restricted to the values allowed by the TTimeStamp implementation. | |
771 | // For these earlier JD values, the standard TTimeStamp parameters will | |
772 | // be set corresponding to the start of the TTimeStamp EPOCH. | |
773 | // This implies that for these earlier (T)JD values the TTimeStamp parameters | |
774 | // do not match the Julian parameters of AliTimestamp. | |
775 | // | |
776 | // Due to computer accuracy the ns precision may be lost. | |
777 | // It is advised to use the (jd,sec,ns) setting instead. | |
778 | // | |
779 | // The input argument represents the following : | |
780 | // tjd : The Truncated Julian date as fractional day count. | |
781 | ||
782 | Int_t days=0; | |
783 | Int_t secs=0; | |
784 | Int_t ns=0; | |
785 | Convert(tjd,days,secs,ns); | |
786 | ||
787 | SetTJD(days,secs,ns); | |
788 | } | |
789 | /////////////////////////////////////////////////////////////////////////// |