Epoch.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 3.0 of the License, or
//  any later version.
//
//  The GNSSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
 
#ifndef GNSSTK_EPOCH_HPP
#define GNSSTK_EPOCH_HPP
 
#include "MathBase.hpp"
#include "Exception.hpp"
#include "StringUtils.hpp"
 
#include "GPSZcount.hpp"
#include "CommonTime.hpp"
#include "TimeTag.hpp"
#include "SystemTime.hpp"
 
#include "JulianDate.hpp"
#include "MJD.hpp"
#include "YDSTime.hpp"
#include "CivilTime.hpp"
#include "GPSWeekZcount.hpp"
#include "GPSWeekSecond.hpp"
#include "BDSWeekSecond.hpp"
#include "GALWeekSecond.hpp"
#include "QZSWeekSecond.hpp"
 
namespace gnsstk
{
 
   class Epoch
   {
   public:
      NEW_EXCEPTION_CLASS(EpochException, gnsstk::Exception);
 
      NEW_EXCEPTION_CLASS(FormatException, gnsstk::Exception);
 
      static const double ONE_NSEC_TOLERANCE;
      static const double ONE_USEC_TOLERANCE;
      static const double ONE_MSEC_TOLERANCE;
      static const double ONE_SEC_TOLERANCE;
      static const double ONE_MIN_TOLERANCE;
      static const double ONE_HOUR_TOLERANCE;
 
      static double EPOCH_TOLERANCE;
 
      static const Epoch BEGINNING_OF_TIME;
      static const Epoch END_OF_TIME;
 
      static std::string PRINT_FORMAT;
 
 
      static double setEpochTolerance(double tol)
         noexcept
      { return EPOCH_TOLERANCE = tol; }
 
      static double getEpochTolerance()
         noexcept
      { return EPOCH_TOLERANCE; }
 
      Epoch& setTolerance(double tol)
         noexcept;
 
      double getTolerance() const noexcept
      { return tolerance; }
 
 
 
      Epoch(const TimeTag& tt = SystemTime());
 
      Epoch(const CommonTime& ct)
         noexcept;
 
      Epoch(const WeekSecond& tt,
            short year);
 
      Epoch(const GPSZcount& gzc)
         noexcept;
 
         // Other Constructors:
         // gps 29-bit zcount w/ epoch determined by current system time
         //     (GPSZcount29 + SystemTime)
 
      ~Epoch()
         noexcept
      {}
 
 
      Epoch(const Epoch &right)
         noexcept;
 
      Epoch& operator=(const Epoch& right)
         noexcept;
 
 
 
      double operator-(const Epoch& right) const
         noexcept;
 
      Epoch operator+(double sec) const;
 
      Epoch operator-(double sec) const;
 
      Epoch& operator+=(double sec);
 
      Epoch& operator-=(double sec);
 
      Epoch& addSeconds(double seconds);
 
      Epoch& addSeconds(long seconds);
 
      Epoch& addMilliSeconds(long msec);
 
      Epoch& addMicroSeconds(long usec);
 
 
      bool operator==(const Epoch &right) const
         noexcept;
      bool operator!=(const Epoch &right) const
         noexcept;
      bool operator<(const Epoch &right) const
         noexcept;
      bool operator>(const Epoch &right) const
         noexcept;
      bool operator<=(const Epoch &right) const
         noexcept;
      bool operator>=(const Epoch &right) const
         noexcept;
 
 
      template <class TimeTagType>
      TimeTagType get() const;
 
      inline long double JD() const;
 
      inline long double MJD() const;
 
      inline short year() const;
 
      inline short month() const;
 
      inline short day() const;
 
      inline short dow() const;
 
      inline short hour() const;
 
      inline short minute() const;
 
      inline double second() const;
 
      inline double sod() const;
 
      inline short GPSModWeek() const;
 
      inline short GPSweek10() const;
 
      inline long GPSzcount() const;
 
      inline long GPSzcountFloor() const;
 
      inline unsigned long GPSzcount32() const;
 
      inline unsigned long GPSzcount32Floor() const;
 
      inline double GPSsow() const;
 
      inline short GPSweek() const;
 
      inline double BDSsow() const;
 
      inline short BDSweek() const;
 
      inline short BDSModWeek() const;
 
      inline double QZSsow() const;
 
      inline short QZSweek() const;
 
      inline short QZSModWeek() const;
 
      inline double GALsow() const;
 
      inline short GALweek() const;
 
      inline short GALModWeek() const;
 
      inline short doy() const;
 
      inline struct timeval unixTime() const;
 
      operator GPSZcount() const;
 
      operator CommonTime() const
         noexcept;
 
 
      Epoch& set(const TimeTag& tt = SystemTime());
 
      Epoch& set(const WeekSecond& tt,
                 short year);
 
      Epoch& set(const CommonTime& c)
         noexcept;
 
      Epoch& set(const GPSZcount& z);
 
      Epoch& setTime(const CommonTime& ct);
 
      Epoch& setDate(const CommonTime& ct);
 
      Epoch& setLocalTime();
 
         // other sets:
         // ymdhms
         // week and sow (if week is 10-bit, set epoch from system time)
         // week and zcount (if week is 10-bit, set epoch from system time)
         // week, zcount, year (if week is 10-bit, set epoch from given year)
         // week, sow, year  (if week is 10-bit, set epoch from given year)
         // gps 29-bit zcount (epoch determined by system time)
         // gps full week and sow
         // gps full week and zcount
         // year, doy, sod
         // long double mjd
         // double mjd
         // Unix struct timeval
         // ANSI time
         // YMD, (year/doy) w/ time unchanged
         // HMS, sod w/ date unchanged
 
 
 
      Epoch& scanf(const std::string& str,
                   const std::string& fmt);
 
         // if you can see this, ignore the \'s below, as they are for
         // the nasty html-ifying of doxygen.  Browsers try and
         // interpret the % and they get all messed up.
      std::string printf(const std::string& fmt = PRINT_FORMAT) const;
 
   private:
 
      CommonTime core;
 
      double tolerance;
 
   };   // end class Epoch
 
   std::ostream& operator<<( std::ostream& s,
                             const Epoch& t );
 
 
   template <class TimeTagType>
   TimeTagType Epoch::get() const
   {
      try { return TimeTagType(core); }
      catch( Exception& e)
      {
         EpochException ee(e);
         GNSSTK_THROW(ee);
      }
   }
 
   long double Epoch::JD() const
   {
      return get<JulianDate>().jd;
   }
 
   long double Epoch::MJD() const
   {
      return get<gnsstk::MJD>().mjd;    // gnsstk to distinguish from Epoch::MJD
   }
 
   short Epoch::year() const
   {
      return static_cast<short>(get<CivilTime>().year);
   }
 
   short Epoch::month() const
   {
      return static_cast<short>(get<CivilTime>().month);
   }
 
   short Epoch::day() const
   {
      return static_cast<short>(get<CivilTime>().day);
   }
 
   short Epoch::dow() const
   {
      return (((static_cast<long>(JD()) % 7) + 1) % 7) ;
   }
 
   short Epoch::hour() const
   {
      return static_cast<short>(get<CivilTime>().hour);
   }
 
   short Epoch::minute() const
   {
      return static_cast<short>(get<CivilTime>().minute);
   }
 
   double Epoch::second() const
   {
      return get<CivilTime>().second;
   }
 
   double Epoch::sod() const
   {
      return get<YDSTime>().sod;
   }
 
   short Epoch::GPSweek10() const
   {
      return GPSModWeek();
   }
 
   short Epoch::GPSModWeek() const
   {
      return static_cast<short>(get<GPSWeekSecond>().getModWeek());
   }
 
   long Epoch::GPSzcount() const
   {
      return get<GPSWeekZcount>().zcount;
   }
 
   long Epoch::GPSzcountFloor() const
   {
      Epoch e = *this + .75; // add half a zcount
      return e.get<GPSWeekZcount>().zcount;
   }
 
   unsigned long Epoch::GPSzcount32() const
   {
      return get<GPSWeekZcount>().getZcount32();
   }
 
   unsigned long Epoch::GPSzcount32Floor() const
   {
      Epoch e = *this + .75; // add half a zcount
      return e.get<GPSWeekZcount>().getZcount32();
   }
 
   double Epoch::GPSsow() const
   {
      return get<GPSWeekSecond>().sow;
   }
 
   short Epoch::GPSweek() const
   {
      return static_cast<short>(get<GPSWeekSecond>().week);
   }
 
   double Epoch::BDSsow() const
   {
      return get<BDSWeekSecond>().sow;
   }
 
   short Epoch::BDSweek() const
   {
      return static_cast<short>(get<BDSWeekSecond>().week);
   }
 
   short Epoch::BDSModWeek() const
   {
      return static_cast<short>(get<BDSWeekSecond>().getModWeek());
   }
 
   double Epoch::QZSsow() const
   {
      return get<QZSWeekSecond>().sow;
   }
 
   short Epoch::QZSweek() const
   {
      return static_cast<short>(get<QZSWeekSecond>().week);
   }
 
   short Epoch::QZSModWeek() const
   {
      return static_cast<short>(get<QZSWeekSecond>().getModWeek());
   }
 
   double Epoch::GALsow() const
   {
      return get<GALWeekSecond>().sow;
   }
 
   short Epoch::GALweek() const
   {
      return static_cast<short>(get<GALWeekSecond>().week);
   }
 
   short Epoch::GALModWeek() const
   {
      return static_cast<short>(get<GALWeekSecond>().getModWeek());
   }
 
   short Epoch::doy() const
   {
      return static_cast<short>(get<YDSTime>().doy);
   }
 
   struct timeval Epoch::unixTime() const
   {
      return get<UnixTime>().tv;
   }
 
}  // namespace gnsstk
 
#endif   // GNSSTK_EPOCH_HPP