Changeset 2607 for trunk/MagicSoft/Mars/mbase

Timestamp:

12/05/03 16:06:34 (21 years ago)

Author:

tbretz

Message:

*** empty log message ***

Location:

trunk/MagicSoft/Mars/mbase

Files:

• MTime.cc (modified) (2 diffs)
• MTime.h (modified) (3 diffs)

trunk/MagicSoft/Mars/mbase/MTime.cc

@@ -38 +38 @@
 //  - removed fTimeStamp[2]
 //
+// Version 3:
+// ----------
+//  - removed fDurtaion - we may put it back when it is needed
+//  - complete rewrite of the data members (old ones completely replaced)
+//
 /////////////////////////////////////////////////////////////////////////////
 #include "MTime.h"
 
 #include <iomanip>
+#include <sys/time.h> // struct timeval
 
 #include <TTime.h>
 
 #include "MLog.h"
+#include "MAstro.h"
 
 ClassImp(MTime);
@@ -51 +58 @@
 using namespace std;
 
-void MTime::SetTime(const TTime &t)
+void MTime::GetDate(UShort_t &y, Byte_t &m, Byte_t &d) const
 {
-    SetTime((ULong_t)t);
+    MAstro::Mjd2Ymd((Long_t)fTime<0?fMjd-1:fMjd, y, m, d);
+}
+
+Bool_t MTime::Set(UShort_t y, Byte_t m, Byte_t d, Byte_t h, Byte_t min, Byte_t s, UShort_t ms, UInt_t ns)
+{
+    if (h>23 || min>59 || s>59 || ms>999 || ns>999999)
+        return kFALSE;
+
+    const Int_t mjd = MAstro::Ymd2Mjd(y, m, d);
+    if (mjd<0)
+        return kFALSE;
+
+    const ULong_t tm = ((((h*60+min)*60)+s)*1000)+ms;
+
+    return Set(mjd, tm, ns);
+}
+
+void MTime::SetSystemTimer(const struct timeval &tv)
+{
+    const ULong_t hor = 3600000; // One Hour in milliseconds
+
+    const UInt_t mjd = tv.tv_sec/(60*60*24) + 40587;
+    const Long_t tm  = (tv.tv_usec/1000)%(24*hor);
+
+    Set(mjd, tm, tv.tv_usec*1000);
+}
+
+void MTime::Now()
+{
+#ifdef __LINUX__
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    SetSystemTimer(tv);
+#else
+    Reset();
+#endif
 }
 
 void MTime::Print(Option_t *) const
 {
-    *fLog << GetDescriptor() << ": " << dec << setfill('0');
-    *fLog << setw(2) << (int)fHour << ":";
-    *fLog << setw(2) << (int)fMin  << ":";
-    *fLog << setw(2) << (int)fSec  << ".";
-    *fLog << setw(9) << fNanoSec << endl;
+    UShort_t yea, ms;
+    Byte_t mon, day, h, m, s;
+
+    GetDate(yea, mon, day);
+    GetTime(h, m, s, ms);
+
+    *fLog << GetDescriptor() << ": ";
+    *fLog << Form("%4d/%02d/%02d %02d:%02d:%02d.%03d (+%dns)",
+                  yea, mon, day, h, m, s, ms, fNanoSec) << endl;
 } 

trunk/MagicSoft/Mars/mbase/MTime.h

@@ -14 +14 @@
 #endif
 
-class TTime;
+#ifndef ROOT_TTime
+#include <TTime.h>
+#endif
+
+struct timeval;
 
 class MTime : public MParContainer
 {
+    friend bool operator==(MTime &t1, MTime &t2);
+    friend bool operator!=(MTime &t1, MTime &t2);
+    friend bool operator< (MTime &t1, MTime &t2);
+    friend bool operator> (MTime &t1, MTime &t2);
+    //friend bool operator<=(MTime &t1, MTime &t2);
+    //friend bool operator>=(MTime &t1, MTime &t2);
+
 private:
-    //UInt_t   fTimeStamp[2]; // type of raw event which should be processed by this task
-    UInt_t   fDuration;     // time of validity
+     UInt_t fMjd;     // [d]  Day in the century        (Day of sun rise)
+     TTime  fTime;    // [ms] Time of Day               (-11h<=x<13h)
+     UInt_t fNanoSec; // [ns] NanoSec part of TimeOfDay (<1000000)
 
-    Byte_t   fHour;
-    Byte_t   fMin;
-    Byte_t   fSec;
-    UInt_t   fNanoSec;
-
-    /*
-     UInt_t   fMjd;     // Day in the century        (Day of sun rise)
-     TTime    fTime;    // Time of Day               (43,200,000<x<43,200,000)
-     UShort_t fNanoSec; // NanoSec part of TimeOfDay (<1000)
-     */
+     ULong_t GetTime24() const
+     {
+         const ULong_t hor = 3600000; // One Hour in milliseconds
+         return (Long_t)fTime<0 ? (Long_t)fTime+24*hor : (ULong_t)fTime;
+     }
 
 public:
@@ -39 +46 @@
         fTitle = title;
 
-        SetTime((ULong_t)0);
+        Reset();
     }
 
     MTime(MTime& t) { *this = t; }
 
+    void Reset() { fMjd=0; fTime=0; fNanoSec=0; }
+
     void operator=(MTime &t)
     {
-        fDuration = t.fDuration;
-        fHour     = t.fHour;
-        fMin      = t.fMin;
-        fSec      = t.fSec;
-        fNanoSec  = t.fNanoSec;
+        fMjd     = t.fMjd;
+        fTime    = t.fTime;
+        fNanoSec = t.fNanoSec;
     }
 
     void Print(Option_t *t=NULL) const;
 
-    void SetCT1Time(UInt_t t1, UInt_t t0)
+    void Now();
+
+    Double_t GetMjd() const
+    {
+        return fMjd+((Long_t)fTime+fNanoSec/1e6)/1000;
+    }
+
+    void SetSystemTimer(const struct timeval &tv);
+
+    Bool_t Set(UInt_t mjd, ULong_t ms, UInt_t ns=0)
+    {
+        const ULong_t hor = 3600000; // One Hour in milliseconds
+        if (ms>24*hor-1 || ns>999999)
+            return kFALSE;
+
+        const Bool_t am = ms < hor*13;
+
+        fMjd     = am ? mjd : mjd + 1;
+        fTime    = (Long_t)(am ? ms  : ms - hor*24);
+        fNanoSec = ns%1000000;
+
+        return kTRUE;
+    }
+
+    Bool_t Set(UShort_t y, Byte_t m, Byte_t d, Byte_t h, Byte_t min, Byte_t s, UShort_t ms, UInt_t ns=0);
+
+    void SetCT1Time(UInt_t mjd, UInt_t t1, UInt_t t0)
     {
         // int   isecs_since_midday; // seconds passed since midday before sunset (JD of run start)
         // int   isecfrac_200ns;     // fractional part of isecs_since_midday
         // fTime->SetTime(isecfrac_200ns, isecs_since_midday);
-        fNanoSec  = 200*t1;
-        fSec      = t0%60;
-        t0 /= 60;
-        fMin      = t0%60;
-        t0 /= 60;
-        fHour     = (t0+12)%24;
+        const ULong_t hor = 3600000; // One Hour in milliseconds
+
+        fNanoSec         = (200*t1)%1000000;
+        const ULong_t ms = (200*t1)/1000000 + t0+12*hor;
+
+        fTime = (Long_t)(ms<13*hor ? ms : ms-24*hor);
+
+        fMjd = mjd+1;
     }
-
-    void SetTime(ULong_t t)
+    /*
+    void SetSystemTime(const TTime &tm)
     {
-        // t [millisec]
-        fNanoSec  = (t*1000000)%1000;
-        t /= 1000;
-        fSec      = t%60;
-        t /= 60;
-        fMin      = t%60;
-        t /= 60;
-        fHour     = t%24;
+        fTime = (ULong_t)tm%(24*hor);
     }
-
-    void SetTime(const TTime &t);
-
-    void SetTime(Double_t t)
-    {
-        // t [s]
-        fNanoSec  = (UInt_t)(fmod(t, 1)*1e9);
-        fSec      = (Byte_t)fmod(t, 60);
-        t /= 60;
-        fMin      = (Byte_t)fmod(t, 60);
-        t /= 60;
-        fHour     = (Byte_t)fmod(t, 24);
-    }
-
-    void SetTime(Byte_t h, Byte_t m, Byte_t s, UInt_t ns)
-    {
-        fHour    = h;
-        fMin     = m;
-        fSec     = s;
-        fNanoSec = ns;
-    }
-
-    void SetDuration(UInt_t t)
-    {
-        fDuration = t;
-    }
-
-    UInt_t GetDuration()
-    {
-        return fDuration;
-    }
-
+     */
     operator double() const //[s]
     {
-        return fNanoSec/1e9+(fHour*60*60+fMin*60+fSec);
+        return fMjd*24*3600+((Long_t)fTime+fNanoSec*1e6)*1000;
     }
     double operator()() const //[s]
@@ -120 +117 @@
     }
 
-    Byte_t GetHour() const { return fHour; }
-    Byte_t GetMin() const { return fMin; }
-    Byte_t GetSec() const { return fSec; }
-    UInt_t GetNanoSec() const { return fNanoSec; }
+    void GetDate(UShort_t &y, Byte_t &m, Byte_t &d) const;
+    void GetTime(Byte_t &h, Byte_t &m, Byte_t &s, UShort_t &ms) const // Time of Day returned in the range [0h, 24h)
+    {
+        Long_t tm = GetTime24();
+        ms  = tm%1000;
+        tm /= 1000;
+        s   = tm%60;
+        tm /= 60;
+        m   = tm%60;
+        tm /= 60;
+        h   = tm;
+    }
+    Long_t GetTime() const // Time of Day returned in the range [-11h, 13h)
+    { return (Long_t)fTime; }
 
-    ClassDef(MTime, 2)  //A generalized MARS time stamp
+    void GetTime(Byte_t &h, Byte_t &m, Byte_t &s) const
+    {
+        UShort_t ms;
+        GetTime(h, m, s, ms);
+    }
+
+    ClassDef(MTime, 3)  //A generalized MARS time stamp
 };
 
-inline Double_t operator-(MTime &t1, MTime &t2)
+inline bool operator<(MTime &t1, MTime &t2)
 {
-    return t1()-t2();
+    if (t1.fMjd<t2.fMjd)
+        return true;
+    if (t1.fMjd==t2.fMjd && t1.fTime<t2.fTime)
+        return true;
+    if (t1.fMjd==t2.fMjd && t1.fTime==t2.fTime && t1.fNanoSec<t2.fNanoSec)
+        return true;
+    return false;
 }
-
-inline Bool_t operator<(MTime &t1, MTime &t2)
+inline bool operator>(MTime &t1, MTime &t2)
 {
-    return t1()<t2();
+    if (t1.fMjd>t2.fMjd)
+        return true;
+    if (t1.fMjd==t2.fMjd && t1.fTime>t2.fTime)
+        return true;
+    if (t1.fMjd==t2.fMjd && t1.fTime==t2.fTime && t1.fNanoSec>t2.fNanoSec)
+        return true;
+    return false;
 }
-
-inline Bool_t operator>(MTime &t1, MTime &t2)
+inline bool operator<=(MTime &t1, MTime &t2)
 {
-    return t1()>t2();
+    return !(t1>t2);
 }
-
-inline Bool_t operator<=(MTime &t1, MTime &t2)
+inline bool operator>=(MTime &t1, MTime &t2)
 {
-    return t1<=t2();
+    return !(t1<t2);
 }
-
-inline Bool_t operator>=(MTime &t1, MTime &t2)
+inline bool operator==(MTime &t1, MTime &t2)
 {
-    return t1()>=t2();
+    return t1.fNanoSec==t2.fNanoSec && t1.fTime==t2.fTime && t1.fMjd==t2.fMjd;
 }
-
-inline Bool_t operator==(MTime &t1, MTime &t2)
+inline bool operator!=(MTime &t1, MTime &t2)
 {
-    return t1()==t2();
+    return t1.fNanoSec!=t2.fNanoSec || t1.fTime!=t2.fTime || t1.fMjd!=t2.fMjd;
 }
-
 #endif