Rinex3ClockHeader.hpp

Go to the documentation of this file.

#pragma ident "$Id: Rinex3ClockHeader.hpp 3319 2012-09-19 16:58:10Z prestonherrmann $"

#ifndef GPSTK_RINEX3CLOCKHEADER_HPP
#define GPSTK_RINEX3CLOCKHEADER_HPP

//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk 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 2.1 of the License, or
//  any later version.
//
//  The GPSTk 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 GPSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  Octavian Andrei - FGI ( http://www.fgi.fi ). 2008
//
//============================================================================

// system
#include <vector>
#include <list>
#include <map>
#include <iostream>
#include <iomanip>
// GPSTk
#include "CommonTime.hpp"
#include "FFStream.hpp"
#include "Rinex3ClockBase.hpp"
#include "Triple.hpp"
#include "RinexSatID.hpp"



namespace gpstk
{

   class Rinex3ClockHeader : public Rinex3ClockBase
   {
   public:

      Rinex3ClockHeader() : 
         version(3.0), valid(false), timeFirst(CommonTime::BEGINNING_OF_TIME)
         {}


      void clear(void);


      static const std::string versionString;       
      static const std::string runByString;         
      static const std::string commentString;       
      static const std::string numObsString;        
      static const std::string timeSystemString;    
      static const std::string leapSecondsString;   
      static const std::string sysDCBString;        
      static const std::string sysPCVString;        
      static const std::string dataTypesString;     
      static const std::string stationNameString;   
      static const std::string calibrationClkString;
      static const std::string acNameString;        
      static const std::string numRefClkString;     
      static const std::string analysisClkRefString;
      static const std::string numStationsString;   
      static const std::string solnStaNameString;   
      static const std::string numSatsString;       
      static const std::string prnListString;       
      static const std::string endOfHeader;         


      enum validBits
      {
         versionValid         = 0x01,        
         runByValid           = 0x02,        
         commentValid         = 0x04,        
         numObsValid          = 0x08,        
         timeSystemValid      = 0x010,       
         leapSecondsValid     = 0x020,       
         sysDCBsValid         = 0x040,       
         sysPCVsValid         = 0x080,       
         dataTypesValid       = 0x0100,      
         stationNameValid     = 0x0200,      
         calibrationClkValid  = 0x0400,      
         acNameValid          = 0x0800,      
         numRefClkValid       = 0x01000,     
         analysisClkRefValid  = 0x02000,     
         numStationsValid     = 0x04000,     
         solnStaNameValid     = 0x08000,     
         numSatsValid         = 0x010000,    
         prnListValid         = 0x020000,    

         endValid = 0x080000000,          

         allValid = 0x08003FFFF

      };


      struct RefClk
      {
         std::string name;
         double sigma;
      };


      struct RefClkRecord
      {
         size_t nRef;
         std::list<RefClk> clk;
         double refWin[2];

         RefClkRecord() : nRef(0) 
         { refWin[0] = refWin[1] = 0.0; };
      };

      struct RinexClkType
      {
         std::string type;
         std::string description;
         RinexClkType() : type(std::string("UN")),
            description(std::string("Unknown or Invalid")) {}
         RinexClkType(std::string t, std::string d) :
            type(t),description(d) {}
      };


      static const RinexClkType UN;
      static const RinexClkType AR;
      static const RinexClkType AS;
      static const RinexClkType CR;
      static const RinexClkType DR;
      static const RinexClkType MS;

      //static const std::vector<ObsID> StandardRinex3ObsIDs;
      //static std::vector<ObsID> RegisteredRinex3ObsIDs;


      double version;                        
      std::string fileType;                  
      RinexSatID system;                     
      std::string fileProgram,               
         fileAgency,                         
         date;                               
      std::vector<std::string> commentList;  
      int numObsTyp;                         
      std::vector<std::string> obsTypeList;  
      std::string timeSystem;                
      int leapSeconds;                       
      int numTyp;                            
      std::vector<std::string> dataTypeList; 
      std::string clk0Name;                  
      std::string calName;                   
      std::string ac;                        
      std::string acName;                    
      CommonTime timeFirst;                  
      std::list<RefClkRecord> refClkList;    
      std::string trfName;                   
      int numSta,                            
         numSVs;                             
      std::vector<std::string> clkNameList;  
      std::vector<Triple> staCoordList;      

      unsigned long valid; 

      bool isPGM;          
      bool isAC;           



      virtual ~Rinex3ClockHeader() {}

         // The next four lines is our common interface
      virtual bool isHeader() const {return true;}


      virtual void dump(std::ostream& s) const;


      void ParseHeaderRecord(std::string& line)
         throw(FFStreamError);


      bool isValid() const { return ((valid & allValid) == allValid); }


   protected:

      virtual void reallyPutRecord(FFStream& s) const
         throw(std::exception, FFStreamError, StringUtils::StringException);

      virtual void reallyGetRecord(FFStream& s) 
         throw(std::exception, FFStreamError,StringUtils::StringException);

      friend class Rinex3ClockData;

   private:
      std::string writeTime(const CommonTime& dt) const;

      CommonTime parseTime(const std::string& line) const;

   }; // end class Rinex3ClockHeader


}  // End of namespace gpstk

#endif   // GPSTK_RINEX3CLOCKHEADER_HPP

---