BrcKeplerOrbit.cpp

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.
//
//==============================================================================
 
#include <stdio.h>
#include "BrcKeplerOrbit.hpp"
#include <cmath>
 
namespace gnsstk
{
   using namespace std;
   using namespace gnsstk;
 
   BrcKeplerOrbit::BrcKeplerOrbit()
      noexcept
   {
      dataLoaded = false;
 
      PRNID = 0;
 
      satSys = "";
 
      healthy = false;
 
      URAoe = 0;
 
      Cuc = Cus = Crc = Crs = Cic = Cis = M0 = dn = dndot =
         ecc = A = Ahalf =Adot = OMEGA0 = i0 = w = OMEGAdot = idot = 0.0;
   }
 
   BrcKeplerOrbit::BrcKeplerOrbit(const std::string satSysArg,
                                  const ObsID obsIDArg,
                                  const short PRNIDArg,
                                  const CommonTime beginFitArg,
                                  const CommonTime endFitArg,
                                  const CommonTime ToeArg,
                                  const short URAoeArg, const bool healthyArg,
                                  const double CucArg, const double CusArg,
                                  const double CrcArg, const double CrsArg,
                                  const double CicArg, const double CisArg,
                                  const double M0Arg, const double dnArg,
                                  const double dndotArg, const double eccArg,
                                  const double AArg, const double AhalfArg,
                                  const double AdotArg, const double OMEGA0Arg,
                                  const double i0Arg, const double wArg,
                                  const double OMEGAdotARg,
                                  const double idotArg )
   {
      loadData(satSysArg, obsIDArg, PRNIDArg, beginFitArg, endFitArg, ToeArg,
               URAoeArg, healthyArg, CucArg, CusArg, CrcArg,
               CrsArg, CicArg, CisArg, M0Arg, dnArg, dndotArg, eccArg, AArg,
               AhalfArg, AdotArg, OMEGA0Arg, i0Arg, wArg, OMEGAdotARg, idotArg);
   }
 
   BrcKeplerOrbit::BrcKeplerOrbit(const ObsID obsIDArg, const short PRNID,
                                  const short fullweeknum,
                                  const long subframe1[10],
                                  const long subframe2[10],
                                  const long subframe3[10] )
   {
      loadData(obsIDArg, PRNID,fullweeknum, subframe1, subframe2, subframe3 );
   }
 
 
   bool BrcKeplerOrbit::operator==(const BrcKeplerOrbit& right) const noexcept
   {
      return ((dataLoaded == right.dataLoaded) &&
              (satSys == right.satSys) &&
              (obsID == right.obsID) &&
              (PRNID == right.PRNID) &&
              (Toe == right.Toe) &&
              (URAoe == right.URAoe) &&
              (healthy == right.healthy) &&
              (Cuc == right.Cuc) &&
              (Cus == right.Cus) &&
              (Crc == right.Crc) &&
              (Crs == right.Crs) &&
              (Cic == right.Cic) &&
              (Cis == right.Cis) &&
              (M0 == right.M0) &&
              (dn == right.dn) &&
              (dndot == right.dndot) &&
              (ecc == right.ecc) &&
              (A == right.A) &&
              (Ahalf == right.Ahalf) &&
              (Adot == right.Adot) &&
              (OMEGA0 == right.OMEGA0) &&
              (i0 == right.i0) &&
              (w == right.w) &&
              (OMEGAdot == right.OMEGAdot) &&
              (idot == right.idot) &&
              (beginFit == right.beginFit) &&
              (endFit == right.endFit));
   }
 
 
   void BrcKeplerOrbit::loadData(const std::string satSysArg,
                                 const ObsID obsIDArg,
                                 const short PRNIDArg,
                                 const CommonTime beginFitArg,
                                 const CommonTime endFitArg,
                                 const CommonTime ToeArg,
                                 const short URAoeArg, const bool healthyArg,
                                 const double CucArg, const double CusArg,
                                 const double CrcArg, const double CrsArg,
                                 const double CicArg, const double CisArg,
                                 const double M0Arg, const double dnArg,
                                 const double dndotArg, const double eccArg,
                                 const double AArg, const double AhalfArg,
                                 const double AdotArg, const double OMEGA0Arg,
                                 const double i0Arg, const double wArg,
                                 const double OMEGAdotARg, const double idotArg)
   {
      satSys      = satSysArg;
      obsID       = obsIDArg;
      PRNID       = PRNIDArg;
      beginFit    = beginFitArg;
      endFit      = endFitArg;
      Toe         = ToeArg;
      URAoe       = URAoeArg;
      healthy     = healthyArg;
      Cuc         = CucArg;
      Cus         = CusArg;
      Crc         = CrcArg;
      Crs         = CrsArg;
      Cic         = CicArg;
      Cis         = CisArg;
      M0          = M0Arg;
      dn          = dnArg;
      dndot       = dndotArg;
      ecc         = eccArg;
      A           = AArg;
      Ahalf       = AhalfArg;
      Adot        = AdotArg;
      OMEGA0      = OMEGA0Arg;
      i0          = i0Arg;
      w           = wArg;
      OMEGAdot    = OMEGAdotARg;
      idot        = idotArg;
      dataLoaded  = true;
   }
 
   void BrcKeplerOrbit::loadData(const ObsID obsIDArg, const short PRNIDArg,
                                 const short fullweeknum,
                                 const long subframe1[10],
                                 const long subframe2[10],
                                 const long subframe3[10])
   {
      double ficked[60];
 
         //Load overhead members
      satSys = "G";
      obsID = obsIDArg;
      PRNID = PRNIDArg;
      short iodc = 0;
 
         //Convert Subframe 1
      if (!subframeConvert(subframe1, fullweeknum, ficked))
      {
         InvalidParameter exc("Subframe 1 not valid.");
         GNSSTK_THROW(exc);
      }
 
      short weeknum = static_cast<short>( ficked[5] );
      short accFlag = static_cast<short>( ficked[7] );
      short health  = static_cast<short>( ficked[8] );
      URAoe = accFlag;
      healthy = false;
      if (health == 0)
         healthy = true;
      iodc = static_cast<short>( ldexp( ficked[9], -11 ) );
 
         //Convert Subframe 2
      if (!subframeConvert(subframe2, fullweeknum, ficked))
      {
         InvalidParameter exc("Subframe 2 not valid.");
         GNSSTK_THROW(exc);
      }
 
      Crs    = ficked[6];
      dn     = ficked[7];
      M0     = ficked[8];
      Cuc    = ficked[9];
      ecc    = ficked[10];
      Cus    = ficked[11];
      Ahalf  = ficked[12];
      A      = Ahalf*Ahalf;
      double ToeSOW = ficked[13];
/*
  double diff = Txmit - ToeSOW;
  if (diff > HALFWEEK)          // NOTE: This USED to be in DayTime, but DayTime is going away.  Where is it now?
  weeknum++;                 // Convert week # of transmission to week # of epoch time when Toc is forward across a week boundary
  else if (diff < -HALFWEEK)
  weeknum--;                 // Convert week # of transmission to week # of epoch time when Toc is back across a week boundary
*/
      Toe = GPSWeekSecond(weeknum, ToeSOW, TimeSystem::GPS);
      short fiti = static_cast<short>(ficked[14]);
      short fitHours = getLegacyFitInterval(iodc, fiti);
      long beginFitSOW = ToeSOW - (fitHours/2)*3600;
      long endFitSOW = ToeSOW + (fitHours/2)*3600;
      short beginFitWk = weeknum;
      short endFitWk = weeknum;
      if (beginFitSOW < 0)
      {
         beginFitSOW += FULLWEEK;
         beginFitWk--;
      }
      beginFit = GPSWeekSecond(beginFitWk, beginFitSOW, TimeSystem::GPS);
 
      if (endFitSOW >= FULLWEEK)
      {
         endFitSOW -= FULLWEEK;
         endFitWk++;
      }
      endFit = GPSWeekSecond(endFitWk, endFitSOW, TimeSystem::GPS);
 
         //Convert Subframe 3
      if (!subframeConvert(subframe3, fullweeknum, ficked))
      {
         InvalidParameter exc("Subframe3 not valid.");
         GNSSTK_THROW(exc);
      }
 
      Cic      = ficked[5];
      OMEGA0   = ficked[6];
      Cis      = ficked[7];
      i0       = ficked[8];
      Crc      = ficked[9];
      w        = ficked[10];
      OMEGAdot = ficked[11];
      idot     = ficked[13];
 
      dndot      = 0.0;
      Adot       = 0.0;
      dataLoaded = true;
 
      return;
   }
 
   bool BrcKeplerOrbit::hasData() const
   {
      return(dataLoaded);
   }
 
   bool BrcKeplerOrbit::isHealthy() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return(healthy);
   }
 
   bool BrcKeplerOrbit::withinFitInterval(const CommonTime ct) const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      if (ct >= beginFit && ct <= endFit) return(true);
      return(false);
   }
 
   Xvt BrcKeplerOrbit::svXvt(const CommonTime& t) const
   {
      Xvt sv;
 
      GPSWeekSecond gpsws = (Toe);
      double ToeSOW = gpsws.sow;
      double ea;              // eccentric anomaly //
      double delea;           // delta eccentric anomaly during iteration */
      double elapte;          // elapsed time since Toe
         //double elaptc;          // elapsed time since Toc
      double q,sinea,cosea;
      double GSTA,GCTA;
      double amm;
      double meana;           // mean anomaly
      double F,G;             // temporary real variables
      double alat,talat,c2al,s2al,du,dr,di,U,R,truea,AINC;
      double ANLON,cosu,sinu,xip,yip,can,san,cinc,sinc;
      double xef,yef,zef,dek,dlk,div,domk,duv,drv;
      double dxp,dyp,vxef,vyef,vzef;
      GPSEllipsoid ell;
 
      double sqrtgm = SQRT(ell.gm());
 
         // Check for ground transmitter
      double twoPI = 2.0e0 * PI;
      double lecc;               // eccentricity
      double tdrinc;            // dt inclination
 
      lecc = ecc;
      tdrinc = idot;
 
         // Compute time since ephemeris & clock epochs
      elapte = t - getOrbitEpoch();
         //CommonTime orbEp = getOrbitEpoch();
         //elapte = t - orbEp;
 
         // Compute mean motion
      amm  = (sqrtgm / (A*Ahalf)) + dn;
 
 
         // In-plane angles
         //     meana - Mean anomaly
         //     ea    - Eccentric anomaly
         //     truea - True anomaly
 
      meana = M0 + elapte * amm;
      meana = fmod(meana, twoPI);
 
      ea = meana + lecc * ::sin(meana);
 
      int loop_cnt = 1;
      do  {
         F = meana - ( ea - lecc * ::sin(ea));
         G = 1.0 - lecc * ::cos(ea);
         delea = F/G;
         ea = ea + delea;
         loop_cnt++;
      } while ( (fabs(delea) > 1.0e-11 ) && (loop_cnt <= 20) );
 
         // Compute clock corrections
      sv.relcorr = svRelativity(t);
         // This appears to be only a string for naming
      sv.frame = RefFrame(RefFrameSys::WGS84, t);
 
         // Compute true anomaly
      q     = SQRT( 1.0e0 - lecc*lecc);
      sinea = ::sin(ea);
      cosea = ::cos(ea);
      G     = 1.0e0 - lecc * cosea;
 
         //  G*SIN(TA) AND G*COS(TA)
      GSTA  = q * sinea;
      GCTA  = cosea - lecc;
 
         //  True anomaly
      truea = atan2 ( GSTA, GCTA );
 
         // Argument of lat and correction terms (2nd harmonic)
      alat  = truea + w;
      talat = 2.0e0 * alat;
      c2al  = ::cos( talat );
      s2al  = ::sin( talat );
 
      du  = c2al * Cuc +  s2al * Cus;
      dr  = c2al * Crc +  s2al * Crs;
      di  = c2al * Cic +  s2al * Cis;
 
         // U = updated argument of lat, R = radius, AINC = inclination
      U    = alat + du;
      R    = A*G  + dr;
      AINC = i0 + tdrinc * elapte  +  di;
 
         //  Longitude of ascending node (ANLON)
      ANLON = OMEGA0 + (OMEGAdot - ell.angVelocity()) *
         elapte - ell.angVelocity() * ToeSOW;
 
         // In plane location
      cosu = ::cos( U );
      sinu = ::sin( U );
 
      xip  = R * cosu;
      yip  = R * sinu;
 
         //  Angles for rotation to earth fixed
      can  = ::cos( ANLON );
      san  = ::sin( ANLON );
      cinc = ::cos( AINC  );
      sinc = ::sin( AINC  );
 
         // Earth fixed - meters
      xef  =  xip*can  -  yip*cinc*san;
      yef  =  xip*san  +  yip*cinc*can;
      zef  =              yip*sinc;
 
      sv.x[0] = xef;
      sv.x[1] = yef;
      sv.x[2] = zef;
 
         // Compute velocity of rotation coordinates
      dek = amm / G;
      dlk = amm * q / (G*G);
      div = tdrinc - 2.0e0 * dlk *
         ( Cic  * s2al - Cis * c2al );
      domk = OMEGAdot - ell.angVelocity();
      duv = dlk*(1.e0+ 2.e0 * (Cus*c2al - Cuc*s2al) );
      drv = A * lecc * dek * sinea - 2.e0 * dlk *
         ( Crc * s2al - Crs * c2al ) + Adot * G;
 
      dxp = drv*cosu - R*sinu*duv;
      dyp = drv*sinu + R*cosu*duv;
 
         // Calculate velocities
      vxef = dxp*can - xip*san*domk - dyp*cinc*san
         + yip*( sinc*san*div - cinc*can*domk);
      vyef = dxp*san + xip*can*domk + dyp*cinc*can
         - yip*( sinc*can*div + cinc*san*domk);
      vzef = dyp*sinc + yip*cinc*div;
 
         // Move results into output variables
      sv.v[0] = vxef;
      sv.v[1] = vyef;
      sv.v[2] = vzef;
      sv.health = healthy ? Xvt::Healthy : Xvt::Unhealthy;
 
      return sv;
   }
 
   double BrcKeplerOrbit::svRelativity(const CommonTime& t) const
   {
      GPSEllipsoid ell;
      double twoPI  = 2.0e0 * PI;
      double sqrtgm = SQRT(ell.gm());
      double elapte = t - getOrbitEpoch();
      double amm    = (sqrtgm / (A*Ahalf)) + dn;
      double meana,F,G,delea;
 
      meana = M0 + elapte * amm;
      meana = fmod(meana, twoPI);
      double ea = meana + ecc * ::sin(meana);
 
      int loop_cnt = 1;
      do {
         F     = meana - ( ea - ecc * ::sin(ea));
         G     = 1.0 - ecc * ::cos(ea);
         delea = F/G;
         ea    = ea + delea;
         loop_cnt++;
      } while ( (ABS(delea) > 1.0e-11 ) && (loop_cnt <= 20) );
      double dtr = REL_CONST * ecc * Ahalf * ::sin(ea);
      return dtr;
   }
 
   CommonTime BrcKeplerOrbit::getOrbitEpoch() const
   {
      return Toe;
   }
 
   CommonTime BrcKeplerOrbit::getBeginningOfFitInterval() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return beginFit;
   }
 
   CommonTime BrcKeplerOrbit::getEndOfFitInterval() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return endFit;
   }
 
   short BrcKeplerOrbit::getPRNID() const
   {
      if(!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return PRNID;
   }
 
   ObsID BrcKeplerOrbit::getObsID() const
   {
      if(!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return obsID;
   }
 
   short BrcKeplerOrbit::getFullWeek()  const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      GPSWeekSecond gpsws(Toe);
      return (gpsws.week);
   }
 
   double BrcKeplerOrbit::getAccuracy()  const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      double accuracy = ura2CNAVaccuracy(URAoe);
      return accuracy;
   }
 
   void BrcKeplerOrbit::setAccuracy(const double& acc)
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      URAoe = accuracy2ura(acc);
   }
 
   short BrcKeplerOrbit::getURAoe() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return URAoe;
   }
 
   double BrcKeplerOrbit::getCus() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Cus;
   }
 
   double BrcKeplerOrbit::getCrs() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Crs;
   }
 
   double BrcKeplerOrbit::getCis() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Cis;
   }
 
   double BrcKeplerOrbit::getCrc() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Crc;
   }
 
   double BrcKeplerOrbit::getCuc() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Cuc;
   }
 
   double BrcKeplerOrbit::getCic() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Cic;
   }
 
   double BrcKeplerOrbit::getToe() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      GPSWeekSecond gpsws(Toe);
      return gpsws.sow;
   }
 
   double BrcKeplerOrbit::getM0() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return M0;
   }
 
   double BrcKeplerOrbit::getDn() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return dn;
   }
 
   double BrcKeplerOrbit::getEcc() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return ecc;
   }
 
   double BrcKeplerOrbit::getA() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return A;
   }
 
   double BrcKeplerOrbit::getAhalf() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Ahalf;
   }
 
   double BrcKeplerOrbit::getAdot() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return Adot;
   }
 
   double BrcKeplerOrbit::getDnDot() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return dndot;
   }
 
   double BrcKeplerOrbit::getOmega0() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return OMEGA0;
   }
 
   double BrcKeplerOrbit::getI0() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return i0;
   }
 
   double BrcKeplerOrbit::getW() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return w;
   }
 
   double BrcKeplerOrbit::getOmegaDot() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return OMEGAdot;
   }
 
   double BrcKeplerOrbit::getIDot() const
   {
      if (!dataLoaded)
      {
         InvalidRequest exc("Required data not stored.");
         GNSSTK_THROW(exc);
      }
      return idot;
   }
 
   static void timeDisplay( ostream & os, const CommonTime& t )
   {
         // Convert to CommonTime struct from GPS wk,SOW to M/D/Y, H:M:S.
      GPSWeekSecond dummyTime;
      dummyTime = GPSWeekSecond(t);
      os << setw(4) << dummyTime.week << "(";
      os << setw(4) << (dummyTime.week & 0x03FF) << ")  ";
      os << setw(6) << setfill(' ') << dummyTime.sow << "   ";
 
      switch (dummyTime.getDayOfWeek())
      {
         case 0: os << "Sun-0"; break;
         case 1: os << "Mon-1"; break;
         case 2: os << "Tue-2"; break;
         case 3: os << "Wed-3"; break;
         case 4: os << "Thu-4"; break;
         case 5: os << "Fri-5"; break;
         case 6: os << "Sat-6"; break;
         default: break;
      }
      os << "   " << (static_cast<YDSTime>(t)).printf("%3j   %5.0s  ")
         << (static_cast<CivilTime>(t)).printf("%02m/%02d/%04Y   %02H:%02M:%02S");
   }
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
   static void shortcut(ostream & os, const long HOW )
   {
      short DOW, hour, min, sec;
      long SOD, SOW;
      short SOH;
 
      SOW  = static_cast<long>( HOW );
      DOW  = static_cast<short>( SOW / SEC_PER_DAY );
      SOD  = SOW - static_cast<long>( DOW * SEC_PER_DAY );
      hour = static_cast<short>( SOD/3600 );
 
      SOH = static_cast<short>( SOD - (hour*3600) );
      min = SOH/60;
 
      sec = SOH - min * 60;
      switch (DOW)
      {
         case 0: os << "Sun-0"; break;
         case 1: os << "Mon-1"; break;
         case 2: os << "Tue-2"; break;
         case 3: os << "Wed-3"; break;
         case 4: os << "Thu-4"; break;
         case 5: os << "Fri-5"; break;
         case 6: os << "Sat-6"; break;
         default: break;
      }
 
      os << ":" << setfill('0')
         << setw(2) << hour
         << ":" << setw(2) << min
         << ":" << setw(2) << sec
         << setfill(' ');
   }
#pragma clang diagnostic pop
   void BrcKeplerOrbit::dump(ostream& s) const
      noexcept
   {
      const ios::fmtflags oldFlags = s.flags();
      s.setf(ios::fixed, ios::floatfield);
      s.setf(ios::right, ios::adjustfield);
      s.setf(ios::uppercase);
      s.precision(0);
      s.fill(' ');
 
      s << "****************************************************************"
        << "************" << endl
        << "Broadcast Ephemeris (Engineering Units)" << endl
        << endl
        << "PRN : " << setw(2) << PRNID << endl
        << endl;
 
      s << "              Week(10bt)     SOW     DOW   UTD     SOD"
        << "   MM/DD/YYYY   HH:MM:SS\n";
 
      s << endl;
      s << "Eph Epoch:    ";
      timeDisplay(s, getOrbitEpoch());
      s << endl;
 
      s.setf(ios::scientific, ios::floatfield);
      s.precision(8);
 
      s << endl
        << "           ORBIT PARAMETERS"
        << endl
        << endl
        << "Semi-major axis:       " << setw(16) << Ahalf  << " m**.5" << endl
        << "Motion correction:     " << setw(16) << dn     << " rad/sec"
        << endl
        << "Eccentricity:          " << setw(16) << ecc    << endl
        << "Arg of perigee:        " << setw(16) << w      << " rad" << endl
        << "Mean anomaly at epoch: " << setw(16) << M0     << " rad" << endl
        << "Right ascension:       " << setw(16) << OMEGA0 << " rad    "
        << setw(16) << OMEGAdot << " rad/sec" << endl
        << "Inclination:           " << setw(16) << i0     << " rad    "
        << setw(16) << idot     << " rad/sec" << endl;
 
      s << endl
        << "           HARMONIC CORRECTIONS"
        << endl
        << endl
        << "Radial        Sine: " << setw(16) << Crs << " m    Cosine: "
        << setw(16) << Crc << " m" << endl
        << "Inclination   Sine: " << setw(16) << Cis << " rad  Cosine: "
        << setw(16) << Cic << " rad" << endl
        << "In-track      Sine: " << setw(16) << Cus << " rad  Cosine: "
        << setw(16) << Cuc << " rad" << endl;
 
      s << endl;
 
      s.flags(oldFlags);
   } // end of BrcKeplerOrbit::dump()
 
   ostream& operator<<(ostream& s, const BrcKeplerOrbit& eph)
   {
      eph.dump(s);
      return s;
 
   } // end of operator<<
 
} // namespace