rinexobsheader.hpp

gps源代码

      static const RinexObsType L5;
      static const RinexObsType D5;
      static const RinexObsType S5;
      // Galileo only
      static const RinexObsType C6;
      static const RinexObsType L6;
      static const RinexObsType D6;
      static const RinexObsType S6;
      static const RinexObsType C7;
      static const RinexObsType L7;
      static const RinexObsType D7;
      static const RinexObsType S7;
      static const RinexObsType C8;
      static const RinexObsType L8;
      static const RinexObsType D8;
      static const RinexObsType S8;

         //@}

      static const std::vector<RinexObsType> StandardRinexObsTypes;
      static std::vector<RinexObsType> RegisteredRinexObsTypes;

         /// Holds the data for the extra Wavelength Factor lines
      struct ExtraWaveFact
      {
            /// List of PRNs with this wavelength factor.
         std::vector<SatID> satList;
            /// The vector of wavelength factor values.
         short wavelengthFactor[2];
      };

         /** @name RinexObsHeaderValues
          */ 
         //@{
      double version;                        ///< RINEX VERSION & TYPE
      std::string fileType;                  ///< RINEX FILETYPE (Observation Navigation etc)
      //std::string system_str;              ///< The string (for file i/o) giving the RINEX system 
      RinexSatID system;                     ///< The RINEX satellite system
      std::string fileProgram,               ///< The program used to generate this file
         fileAgency,                         ///< Who ran the program.
         date;                               ///< When the program was run.
      std::vector<std::string> commentList;  ///< Comments in header (optional)
      std::string markerName,                ///< MARKER NAME
         markerNumber;                       ///< MARKER NUMBER (optional)
      std::string observer,                  ///< OBSERVER : who collected the data
         agency;                             ///< OBSERVER'S AGENCY
      std::string recNo,                     ///< RECEIVER NUMBER
         recType,                            ///< RECEIVER TYPE
         recVers;                            ///< RECEIVER VERSION
      std::string antNo,                     ///< ANTENNA NUMBER
         antType;                            ///< ANTENNA TYPE
      gpstk::Triple antennaPosition;         ///< APPROXIMATE POSITION XYZ
      gpstk::Triple antennaOffset;           ///< ANTENNA: DELTA H/E/N
      short wavelengthFactor[2];             ///< default WAVELENGTH FACTORS
      std::vector<ExtraWaveFact> extraWaveFactList; ///< extra (per PRN) WAVELENGTH FACTORS
      std::vector<RinexObsType> obsTypeList; ///< NUMBER & TYPES OF OBSERV
      double interval;                       ///< INTERVAL (optional)
      DayTime firstObs ;                     ///< TIME OF FIRST OBS
      RinexSatID firstSystem;                ///< RINEX satellite system of FIRST OBS timetag
      DayTime lastObs ;                      ///< TIME OF LAST OBS (optional)
      RinexSatID lastSystem;                 ///< RINEX satellite system of LAST OBS timetag
      int receiverOffset;                    ///< RCV CLOCK OFFS APPL (optional)
      int leapSeconds;                       ///< LEAP SECONDS (optional)
      short numSVs;                          ///< NUMBER OF SATELLITES in following map (optional)
      std::map<SatID, std::vector<int> > numObsForSat; ///<  PRN / # OF OBS (optional)
      unsigned long valid; ///< Bits set when individual header members are present and valid
      int numObs; ///< used to save the number of obs on # / TYPES continuation lines.
      RinexSatID lastPRN; ///< used to save the current PRN while reading PRN/OBS continuation lines.
         //@}
     
         /// Destructor
      virtual ~RinexObsHeader() {}

         // The next four lines is our common interface
         /// RinexObsHeader is a "header" so this function always returns true.
      virtual bool isHeader() const {return true;}
     
         /**
          * This is a simple Debug output function.
          * It simply outputs the version, name and antenna number of this
          * RINEX header.
          */
      virtual void dump(std::ostream& s) const;

         /**
          * This function converts the string in \a oneObs to a RinexObsType.
          */
      static RinexObsType convertObsType(const std::string& oneObs)
         throw(FFStreamError);

         /**
          * This function converts the RinexObsType in \a oneObs to a string.
          */
      static std::string convertObsType(const RinexObsType& oneObs) 
         throw(FFStreamError);

         /**
          * Parse a single header record, and modify valid accordingly.
          * Used by reallyGetRecord for both RinexObsHeader and RinexObsData.
          */
      void ParseHeaderRecord(std::string& line)
         throw(FFStreamError);

         /// Compute the number of valid header records which WriteHeaderRecords() will write
      int NumberHeaderRecordsToBeWritten(void) const throw();

         /**
          * Write all valid header records to the given stream.
          * Used by reallyPutRecord for both RinexObsHeader and RinexObsData.
          */
      void WriteHeaderRecords(FFStream& s) const
         throw(FFStreamError, gpstk::StringUtils::StringException);

         /// Return boolean : is this a valid Rinex header?
      bool isValid() const { return ((valid & allValid20) == allValid20); }
         
   protected:
         /**
          * outputs this record to the stream correctly formatted.
          */
      virtual void reallyPutRecord(FFStream& s) const
         throw(std::exception, FFStreamError,
               gpstk::StringUtils::StringException);

         /**
          * This function retrieves the RINEX Header from the given FFStream.
          * If an stream error is encountered, the stream is reset to its
          *  original position and its fail-bit is set.
          * @throws StringException when a StringUtils function fails
          * @throws FFStreamError when exceptions(failbit) is set and
          *  a read or formatting error occurs.  This also resets the
          *  stream to its pre-read position.
          */
      virtual void reallyGetRecord(FFStream& s) 
         throw(std::exception, FFStreamError,
               gpstk::StringUtils::StringException);

      friend class RinexObsData;

   private:
         /// Converts the daytime \a dt into a Rinex Obs time
         /// string for the header
      std::string writeTime(const DayTime& dt) const;

         /**
          * This function sets the time for this header.
          * It looks at \a line to obtain the needed information.
          */
      DayTime parseTime(const std::string& line) const;

   }; // end class RinexObsHeader

      /// operator == for RinexObsHeader::RinexObsType
   inline bool operator==(const RinexObsHeader::RinexObsType& x,
      const RinexObsHeader::RinexObsType& y) { return (x.type == y.type); }

      /// operator < for RinexObsHeader::RinexObsType
   inline bool operator<(const RinexObsHeader::RinexObsType& x,
      const RinexObsHeader::RinexObsType& y) { return (x.type < y.type); }

      /// operator << for RinexObsHeader::RinexObsType
   inline std::ostream& operator<<(std::ostream& s,
                                   const RinexObsHeader::RinexObsType rot)
      {
         return s << "Type=" << rot.type
            << ", Description=" << rot.description
            << ", Units=" << rot.units;
      }

      /// Function to allow user to define a new RINEX observation type
   int RegisterExtendedRinexObsType(std::string t,
                                    std::string d=std::string("(undefined)"),
                                    std::string u=std::string("undefined"),
                                    unsigned int dep=0);

      /// Pretty print a list of standard Rinex observation types
   void DisplayStandardRinexObsTypes(std::ostream& s);

      /// Pretty print a list of registered extended Rinex observation types
   void DisplayExtendedRinexObsTypes(std::ostream& s);

   //@}

} // namespace

#endif