RinexObsHeader.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_RINEXOBSHEADER_HPP
#define GNSSTK_RINEXOBSHEADER_HPP
 
#include <vector>
#include <list>
#include <map>
#include <iostream>
#include <iomanip>
 
#include "gnsstk_export.h"
#include "CommonTime.hpp"
#include "FFStream.hpp"
#include "RinexObsBase.hpp"
#include "Triple.hpp"
#include "RinexSatID.hpp"
#include "gnsstk_export.h"
 
namespace gnsstk
{
 
 
   struct RinexObsType
   {
      std::string type;          
      std::string description;   
      std::string units;         
      unsigned int depend;
      RinexObsType() : type(std::string("UN")),description(std::string("Unknown or Invalid")),
                       units(std::string("")),depend(0) {}
      RinexObsType(std::string t, std::string d, std::string u, unsigned int dep=0) :
            type(t),description(d),units(u),depend(dep) {}
      GNSSTK_EXPORT static const unsigned int C1depend;
      GNSSTK_EXPORT static const unsigned int L1depend;
      GNSSTK_EXPORT static const unsigned int L2depend;
      GNSSTK_EXPORT static const unsigned int P1depend;
      GNSSTK_EXPORT static const unsigned int P2depend;
      GNSSTK_EXPORT static const unsigned int EPdepend;
      GNSSTK_EXPORT static const unsigned int PSdepend;
   };
 
 
// Guards are here since an identical struct is used in RinexObsHeader
// and Rinex3NavHeader
#ifndef GNSSTK_EXTRAWAVEFACT
#define GNSSTK_EXTRAWAVEFACT
   struct ExtraWaveFact
   {
      std::vector<SatID> satList;
      short wavelengthFactor[2];
   };
#endif  // GNSSTK_EXTRAWAVEFACT
 
 
   class RinexObsHeader : public RinexObsBase
   {
   public:
 
      RinexObsHeader()
            : version(2.11), interval(0.0), receiverOffset(0), leapSeconds(0),
              numSVs(0), valid(0), numObs(0)
      {
         clear();
      }
 
      inline void clear()
      {
//         version = 2.11;
         valid = 0;
         commentList.clear();
         wavelengthFactor[0] = wavelengthFactor[1] = 1;
         extraWaveFactList.clear();
         obsTypeList.clear();
         numObsForSat.clear();
         numObs = 0;
         lastPRN.id = -1;
      }
 
 
      GNSSTK_EXPORT
      static const std::string versionString;         
      GNSSTK_EXPORT
      static const std::string runByString;           
      GNSSTK_EXPORT
      static const std::string commentString;         
      GNSSTK_EXPORT
      static const std::string markerNameString;      
      GNSSTK_EXPORT
      static const std::string markerNumberString;    
      GNSSTK_EXPORT
      static const std::string observerString;        
      GNSSTK_EXPORT
      static const std::string receiverString;        
      GNSSTK_EXPORT
      static const std::string antennaTypeString;     
      GNSSTK_EXPORT
      static const std::string antennaPositionString; 
      GNSSTK_EXPORT
      static const std::string antennaOffsetString;   
      GNSSTK_EXPORT
      static const std::string waveFactString;        
      GNSSTK_EXPORT
      static const std::string numObsString;          
      GNSSTK_EXPORT
      static const std::string intervalString;        
      GNSSTK_EXPORT
      static const std::string firstTimeString;       
      GNSSTK_EXPORT
      static const std::string lastTimeString;        
      GNSSTK_EXPORT
      static const std::string receiverOffsetString;  
      GNSSTK_EXPORT
      static const std::string leapSecondsString;     
      GNSSTK_EXPORT
      static const std::string numSatsString;         
      GNSSTK_EXPORT
      static const std::string prnObsString;          
      GNSSTK_EXPORT
      static const std::string endOfHeader;           
 
 
      enum validBits
      {
         versionValid         = 0x01,      
         runByValid           = 0x02,      
         commentValid         = 0x04,      
         markerNameValid      = 0x08,      
         markerNumberValid    = 0x010,     
         observerValid        = 0x020,     
         receiverValid        = 0x040,     
         antennaTypeValid     = 0x080,     
         antennaPositionValid = 0x0100,    
         antennaOffsetValid   = 0x0200,    
         waveFactValid        = 0x0400,    
         obsTypeValid         = 0x0800,    
         intervalValid        = 0x01000,   
         firstTimeValid       = 0x02000,   
         lastTimeValid        = 0x04000,   
         receiverOffsetValid  = 0x08000,   
         leapSecondsValid     = 0x0100000, 
         numSatsValid         = 0x0200000, 
         prnObsValid          = 0x0400000, 
 
         endValid = 0x080000000,        
 
         allValid20 = 0x080002FEB,
         allValid21 = 0x080002FEB,
         allValid211 = 0x080002BEB
      };
 
 
      GNSSTK_EXPORT static const RinexObsType UN;
      GNSSTK_EXPORT static const RinexObsType L1;
      GNSSTK_EXPORT static const RinexObsType L2;
      GNSSTK_EXPORT static const RinexObsType C1;
      GNSSTK_EXPORT static const RinexObsType C2;
      GNSSTK_EXPORT static const RinexObsType P1;
      GNSSTK_EXPORT static const RinexObsType P2;
      GNSSTK_EXPORT static const RinexObsType D1;
      GNSSTK_EXPORT static const RinexObsType D2;
      GNSSTK_EXPORT static const RinexObsType S1;
      GNSSTK_EXPORT static const RinexObsType S2;
      GNSSTK_EXPORT static const RinexObsType T1;
      GNSSTK_EXPORT static const RinexObsType T2;
      GNSSTK_EXPORT static const RinexObsType C5;
      GNSSTK_EXPORT static const RinexObsType L5;
      GNSSTK_EXPORT static const RinexObsType D5;
      GNSSTK_EXPORT static const RinexObsType S5;
         // Galileo only
      GNSSTK_EXPORT static const RinexObsType C6;
      GNSSTK_EXPORT static const RinexObsType L6;
      GNSSTK_EXPORT static const RinexObsType D6;
      GNSSTK_EXPORT static const RinexObsType S6;
      GNSSTK_EXPORT static const RinexObsType C7;
      GNSSTK_EXPORT static const RinexObsType L7;
      GNSSTK_EXPORT static const RinexObsType D7;
      GNSSTK_EXPORT static const RinexObsType S7;
      GNSSTK_EXPORT static const RinexObsType C8;
      GNSSTK_EXPORT static const RinexObsType L8;
      GNSSTK_EXPORT static const RinexObsType D8;
      GNSSTK_EXPORT static const RinexObsType S8;
 
 
      GNSSTK_EXPORT
      static const std::vector<RinexObsType> StandardRinexObsTypes;
      GNSSTK_EXPORT
      static std::vector<RinexObsType> RegisteredRinexObsTypes;
 
 
      double version;                        
      std::string fileType;                  
         //std::string system_str;              ///< The string (for file i/o) giving the RINEX system
      RinexSatID system;                     
      std::string fileProgram,               
         fileAgency,                         
         date;                               
      std::vector<std::string> commentList;  
      std::string markerName,                
         markerNumber;                       
      std::string observer,                  
         agency;                             
      std::string recNo,                     
         recType,                            
         recVers;                            
      std::string antNo,                     
         antType;                            
      gnsstk::Triple antennaPosition;         
      gnsstk::Triple antennaOffset;           
      short wavelengthFactor[2];             
      std::vector<ExtraWaveFact> extraWaveFactList; 
      std::vector<RinexObsType> obsTypeList; 
      double interval;                       
      CommonTime firstObs ;                     
      RinexSatID firstSystem;                
      CommonTime lastObs ;                      
      RinexSatID lastSystem;                 
      int receiverOffset;                    
      int leapSeconds;                       
      short numSVs;                          
      std::map<SatID, std::vector<int> > numObsForSat; 
      unsigned long valid; 
      int numObs; 
      RinexSatID lastPRN; 
 
      virtual ~RinexObsHeader() {}
 
         // The next four lines is our common interface
      virtual bool isHeader() const {return true;}
 
      virtual void dump(std::ostream& s) const;
 
      static RinexObsType convertObsType(const std::string& oneObs);
 
      static std::string convertObsType(const RinexObsType& oneObs);
 
      void ParseHeaderRecord(std::string& line);
 
      int NumberHeaderRecordsToBeWritten(void) const noexcept;
 
      void WriteHeaderRecords(FFStream& s) const;
 
      bool isValid() const { return ((valid & allValid20) == allValid20); }
 
   protected:
      virtual void reallyPutRecord(FFStream& s) const;
 
      virtual void reallyGetRecord(FFStream& s);
 
      friend class RinexObsData;
 
   private:
      std::string writeTime(const CommonTime& dt) const;
 
      CommonTime parseTime(const std::string& line) const;
 
   }; // end class RinexObsHeader
 
   inline bool operator==(const RinexObsType& x,
                          const RinexObsType& y) { return (x.type == y.type); }
 
   inline bool operator<(const RinexObsType& x,
                         const RinexObsType& y) { return (x.type < y.type); }
 
   inline std::ostream& operator<<(std::ostream& s,
                                   const RinexObsType rot)
   {
      return s << "Type=" << rot.type
               << ", Description=" << rot.description
               << ", Units=" << rot.units;
   }
 
   int RegisterExtendedRinexObsType(std::string t,
                                    std::string d=std::string("(undefined)"),
                                    std::string u=std::string("undefined"),
                                    unsigned int dep=0);
 
   void DisplayStandardRinexObsTypes(std::ostream& s);
 
   void DisplayExtendedRinexObsTypes(std::ostream& s);
 
 
} // namespace
 
#endif