GalIBits.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_GALIBITS_HPP
#define GNSSTK_GALIBITS_HPP
 
namespace gnsstk
{
   namespace galinav
   {
      enum FullBitInfo
      {
         fsbType = 0, 
         fnbType = 6, 
         fscType = 1, 
      };
 
         // This enum is only used here and it's being used to avoid confusion
         // on vector indices.  Using enums instead of constants because it
         // doesn't result in memory allocation.  Also not using strongly typed
         // enums because we actually want these values to be implicitly cast
         // to integer values.
      enum WTIndex
      {
         wt1 = 0,  
         wt2 = 1,  
         wt3 = 2,  
         wt4 = 3,  
         wt5 = 4,  
         wt7 = 0,  
         wt8 = 1,  
         wt9 = 2,  
         wt10 = 3, 
         numEphWTs = 5, 
         numAlmWTs = 4  
      };
 
      enum EphBitInfo
      {
         esbIOD = fsbType+fnbType, 
         enbIOD = 10,
         escIOD = 1,
 
         esit0e = wt1, 
         esbt0e = esbIOD+enbIOD,  
         enbt0e = 14,  
         esct0e = 60,  
 
         esiM0  = wt1, 
         esbM0 = esbt0e+enbt0e, 
         enbM0 = 32,   
         escM0  = -31, 
 
         esiEcc  = wt1, 
         esbEcc = esbM0+enbM0, 
         enbEcc = 32,   
         escEcc  = -33, 
 
         esiAhalf = wt1, 
         esbAhalf = esbEcc+enbEcc, 
         enbAhalf = 32,   
         escAhalf = -19, 
 
         esiOMEGA0  = wt2, 
         esbOMEGA0 = esbIOD+enbIOD,  
         enbOMEGA0 = 32,   
         escOMEGA0  = -31, 
 
         esii0  = wt2, 
         esbi0 = esbOMEGA0+enbOMEGA0, 
         enbi0 = 32,   
         esci0  = -31, 
 
         esiw  = wt2, 
         esbw = esbi0+enbi0, 
         enbw = 32,   
         escw  = -31, 
 
         esiidot = wt2, 
         esbidot = esbw+enbw, 
         enbidot = 14,  
         escidot = -43, 
 
         esiOMEGAdot = wt3, 
         esbOMEGAdot = esbIOD+enbIOD, 
         enbOMEGAdot = 24,  
         escOMEGAdot = -43, 
 
         esidn = wt3, 
         esbdn = esbOMEGAdot+enbOMEGAdot,  
         enbdn = 16,  
         escdn = -43, 
 
         esiCuc = wt3, 
         esbCuc = esbdn+enbdn, 
         enbCuc = 16,  
         escCuc = -29, 
 
         esiCus = wt3, 
         esbCus = esbCuc+enbCuc, 
         enbCus = 16,  
         escCus = -29, 
 
         esiCrc = wt3, 
         esbCrc = esbCus+enbCus, 
         enbCrc = 16,  
         escCrc = -5,  
 
         esiCrs = wt3, 
         esbCrs = esbCrc+enbCrc,  
         enbCrs = 16,  
         escCrs = -5,  
 
         esiSISA = wt3,
         esbSISA = esbCrs+enbCrs,
         enbSISA = 8,
         escSISA = 1,
 
         esiSVID = wt4,
         esbSVID = esbIOD+enbIOD,
         enbSVID = 6,
         escSVID = 1,
 
         esiCic = wt4, 
         esbCic = esbSVID+enbSVID,  
         enbCic = 16,  
         escCic = -29, 
 
         esiCis = wt4, 
         esbCis = esbCic+enbCic, 
         enbCis = 16,  
         escCis = -29, 
 
         esit0c = wt4, 
         esbt0c = esbCis+enbCis, 
         enbt0c = 14,  
         esct0c = 60,   
 
         esiaf0 = wt4, 
         esbaf0 = esbt0c+enbt0c, 
         enbaf0 = 31,  
         escaf0 = -34, 
 
         esiaf1 = wt4, 
         esbaf1 = esbaf0+enbaf0, 
         enbaf1 = 21,  
         escaf1 = -46, 
 
         esiaf2 = wt4, 
         esbaf2 = esbaf1+enbaf1, 
         enbaf2 = 6,   
         escaf2 = -59, 
      };
 
      enum IonoBitInfo
      {
         isiai0 = wt5,
         isbai0 = fsbType+fnbType,
         inbai0 = 11,
         iscai0 = -2,
 
         isiai1 = wt5,
         isbai1 = isbai0+inbai0,
         inbai1 = 11,
         iscai1 = -8,
 
         isiai2 = wt5,
         isbai2 = isbai1+inbai1,
         inbai2 = 14,
         iscai2 = -15,
 
         isiIDFR1 = wt5,
         isbIDFR1 = isbai2+inbai2,
         inbIDFR1 = 1,
         iscIDFR1 = 1,
 
         isiIDFR2 = wt5,
         isbIDFR2 = isbIDFR1+inbIDFR1,
         inbIDFR2 = 1,
         iscIDFR2 = 1,
 
         isiIDFR3 = wt5,
         isbIDFR3 = isbIDFR2+inbIDFR2,
         inbIDFR3 = 1,
         iscIDFR3 = 1,
 
         isiIDFR4 = wt5,
         isbIDFR4 = isbIDFR3+inbIDFR3,
         inbIDFR4 = 1,
         iscIDFR4 = 1,
 
         isiIDFR5 = wt5,
         isbIDFR5 = isbIDFR4+inbIDFR4,
         inbIDFR5 = 1,
         iscIDFR5 = 1,
 
         isiBGDa = wt5,
         isbBGDa = isbIDFR5+inbIDFR5,
         inbBGDa = 10,
         iscBGDa = -32,
 
         isiBGDb = wt5,
         isbBGDb = isbBGDa+inbBGDa,
         inbBGDb = 10,
         iscBGDb = -32,
 
         isiE5bhs = wt5,
         isbE5bhs = isbBGDb+inbBGDb,
         inbE5bhs = 2,
         iscE5bhs = 1,
 
         isiE1Bhs = wt5,
         isbE1Bhs = isbE5bhs+inbE5bhs,
         inbE1Bhs = 2,
         iscE1Bhs = 1,
 
         isiE5bdvs = wt5,
         isbE5bdvs = isbE1Bhs+inbE1Bhs,
         inbE5bdvs = 1,
         iscE5bdvs = 1,
 
         isiE1Bdvs = wt5,
         isbE1Bdvs = isbE5bdvs+inbE5bdvs,
         inbE1Bdvs = 1,
         iscE1Bdvs = 1,
 
         isiWN = wt5,
         isbWN = isbE1Bdvs+inbE1Bdvs,
         inbWN = 12,
         iscWN = 1,
 
         isiTOW = wt5,
         isbTOW = isbWN+inbWN,
         inbTOW = 20,
         iscTOW = 1,
      };
 
      enum ClockBitInfo
      {
         csbA0 = fsbType+fnbType,
         cnbA0 = 32,
         cscA0 = -30,
 
         csbA1 = csbA0+cnbA0,
         cnbA1 = 24,
         cscA1 = -50,
 
         csbdtLS = csbA1+cnbA1,
         cnbdtLS = 8,
         cscdtLS = 1,
 
         csbtot = csbdtLS+cnbdtLS,
         cnbtot = 8,
         csctot = 3600,
 
         csbWNot = csbtot+cnbtot,
         cnbWNot = 8,
         cscWNot = 1,
 
         csbWNlsf = csbWNot+cnbWNot,
         cnbWNlsf = 8,
         cscWNlsf = 1,
 
         csbDN = csbWNlsf+cnbWNlsf,
         cnbDN = 3,
         cscDN = 1,
 
         csbdtLSF = csbDN+cnbDN,
         cnbdtLSF = 8,
         cscdtLSF = 1,
 
         csbTOW = csbdtLSF+cnbdtLSF,
         cnbTOW = 20,
         cscTOW = 1,
      };
 
      enum AlmBitInfo
      {
         asbIODa = fsbType+fnbType, 
         anbIODa = 4,
         ascIODa = 1,
 
         asiWNa_A = wt7,
         asiWNa_B = wt9,
         asbWNa = asbIODa+anbIODa,
         anbWNa = 2,
         ascWNa = 1,
 
         asit0a_A = wt7,
         asit0a_B = wt9,
         asbt0a = asbWNa+anbWNa,
         anbt0a = 10,
         asct0a = 600,
 
            // SV(SVID1)
            // Number of bits and scale factor are the same for all the SVs
            // so only define those once.
 
         asiSVID_1 = wt7,
         asbSVID_1 = asbt0a+anbt0a,
         anbSVID = 6,
         ascSVID = 1,
 
         asidAhalf_1 = wt7,
         asbdAhalf_1 = asbSVID_1+anbSVID,
         anbdAhalf = 13,
         ascdAhalf = -9,
 
         asiEcc_1 = wt7,
         asbEcc_1 = asbdAhalf_1+anbdAhalf,
         anbEcc = 11,
         ascEcc = -16,
 
         asiw_1 = wt7,
         asbw_1 = asbEcc_1+anbEcc,
         anbw = 16,
         ascw = -15,
 
         asidi_1 = wt7,
         asbdi_1 = asbw_1+anbw,
         anbdi = 11,
         ascdi = -14,
 
         asiOMEGA0_1 = wt7,
         asbOMEGA0_1 = asbdi_1+anbdi,
         anbOMEGA0 = 16,
         ascOMEGA0 = -15,
 
         asiOMEGAdot_1 = wt7,
         asbOMEGAdot_1 = asbOMEGA0_1+anbOMEGA0,
         anbOMEGAdot = 11,
         ascOMEGAdot = -33,
 
         asiM0_1 = wt7,
         asbM0_1 = asbOMEGAdot_1+anbOMEGAdot,
         anbM0 = 16,
         ascM0 = -15,
 
         asiaf0_1 = wt8,
         asbaf0_1 = asbIODa+anbIODa,
         anbaf0 = 16,
         ascaf0 = -19,
 
         asiaf1_1 = wt8,
         asbaf1_1 = asbaf0_1+anbaf0,
         anbaf1 = 13,
         ascaf1 = -38,
 
         asiE5bhs_1 = wt8,
         asbE5bhs_1 = asbaf1_1+anbaf1,
         anbE5bhs = 2,
         ascE5bhs = 1,
 
         asiE1Bhs_1 = wt8,
         asbE1Bhs_1 = asbE5bhs_1+anbE5bhs,
         anbE1Bhs = 2,
         ascE1Bhs = 1,
 
            // SV(SVID2)
 
         asiSVID_2 = wt8,
         asbSVID_2 = asbE1Bhs_1+anbE1Bhs,
 
         asidAhalf_2 = wt8,
         asbdAhalf_2 = asbSVID_2+anbSVID,
 
         asiEcc_2 = wt8,
         asbEcc_2 = asbdAhalf_2+anbdAhalf,
 
         asiw_2 = wt8,
         asbw_2 = asbEcc_2+anbEcc,
 
         asidi_2 = wt8,
         asbdi_2 = asbw_2+anbw,
 
         asiOMEGA0_2 = wt8,
         asbOMEGA0_2 = asbdi_2+anbdi,
 
         asiOMEGAdot_2 = wt8,
         asbOMEGAdot_2 = asbOMEGA0_2+anbOMEGA0,
 
         asiM0_2 = wt9,
         asbM0_2 = asbt0a+anbt0a,
 
         asiaf0_2 = wt9,
         asbaf0_2 = asbM0_2+anbM0,
 
         asiaf1_2 = wt9,
         asbaf1_2 = asbaf0_2+anbaf0,
 
         asiE5bhs_2 = wt9,
         asbE5bhs_2 = asbaf1_2+anbaf1,
 
         asiE1Bhs_2 = wt9,
         asbE1Bhs_2 = asbE5bhs_2+anbE5bhs,
 
            // SV(SVID3)
 
         asiSVID_3 = wt9,
         asbSVID_3 = asbE1Bhs_2+anbE1Bhs,
 
         asidAhalf_3 = wt9,
         asbdAhalf_3 = asbSVID_3+anbSVID,
 
         asiEcc_3 = wt9,
         asbEcc_3 = asbdAhalf_3+anbdAhalf,
 
         asiw_3 = wt9,
         asbw_3 = asbEcc_3+anbEcc,
 
         asidi_3 = wt9,
         asbdi_3 = asbw_3+anbw,
 
         asiOMEGA0_3 = wt10,
         asbOMEGA0_3 = asbIODa+anbIODa,
 
         asiOMEGAdot_3 = wt10,
         asbOMEGAdot_3 = asbOMEGA0_3+anbOMEGA0,
 
         asiM0_3 = wt10,
         asbM0_3 = asbOMEGAdot_3+anbOMEGAdot,
 
         asiaf0_3 = wt10,
         asbaf0_3 = asbM0_3+anbM0,
 
         asiaf1_3 = wt10,
         asbaf1_3 = asbaf0_3+anbaf0,
 
         asiE5bhs_3 = wt10,
         asbE5bhs_3 = asbaf1_3+anbaf1,
 
         asiE1Bhs_3 = wt10,
         asbE1Bhs_3 = asbE5bhs_3+anbE5bhs,
 
         asiA0G = wt10,
         asbA0G = asbE1Bhs_3+anbE1Bhs,
         anbA0G = 16,
         ascA0G = -35,
 
         asiA1G = wt10,
         asbA1G = asbA0G+anbA0G,
         anbA1G = 12,
         ascA1G = -51,
 
         asit0G = wt10,
         asbt0G = asbA1G+anbA1G,
         anbt0G = 8,
         asct0G = 3600,
 
         asiWN0G = wt10,
         asbWN0G = asbt0G+anbt0G,
         anbWN0G = 6,
         ascWN0G = 1,
      };
   } // namespace galinav
} // namespace gnsstk
 
#endif // GNSSTK_GALIBITS_HPP