Rinex3ObsHeader.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_RINEX3OBSHEADER_HPP
#define GNSSTK_RINEX3OBSHEADER_HPP
 
#include <vector>
#include <list>
#include <map>
#include <set>
#include <iostream>
#include <iomanip>
 
#include "gnsstk_export.h"
#include "CivilTime.hpp"
#include "FFStream.hpp"
#include "Rinex3ObsBase.hpp"
#include "Triple.hpp"
#include "RinexSatID.hpp"
#include "RinexObsID.hpp"
#include "XmitAnt.hpp"
 
 
namespace gnsstk
{
 
 
 
   class Rinex3ObsHeader : public Rinex3ObsBase
   {
   public:
 
      Rinex3ObsHeader();
 
      void clear();
 
      GNSSTK_EXPORT
      static const std::string hsVersion;           
      GNSSTK_EXPORT
      static const std::string hsRunBy;             
      GNSSTK_EXPORT
      static const std::string hsComment;           
      GNSSTK_EXPORT
      static const std::string hsMarkerName;        
      GNSSTK_EXPORT
      static const std::string hsMarkerNumber;      
      GNSSTK_EXPORT
      static const std::string hsMarkerType;        
      GNSSTK_EXPORT
      static const std::string hsObserver;          
      GNSSTK_EXPORT
      static const std::string hsReceiver;          
      GNSSTK_EXPORT
      static const std::string hsAntennaType;       
      GNSSTK_EXPORT
      static const std::string hsAntennaPosition;   
      GNSSTK_EXPORT
      static const std::string hsAntennaDeltaHEN;   
      GNSSTK_EXPORT
      static const std::string hsAntennaDeltaXYZ;   
      GNSSTK_EXPORT
      static const std::string hsAntennaPhaseCtr;   
      GNSSTK_EXPORT
      static const std::string hsAntennaBsightXYZ;  
      GNSSTK_EXPORT
      static const std::string hsAntennaZeroDirAzi; 
      GNSSTK_EXPORT
      static const std::string hsAntennaZeroDirXYZ; 
      GNSSTK_EXPORT
      static const std::string hsCenterOfMass;      
      GNSSTK_EXPORT
      static const std::string hsNumObs;            
      GNSSTK_EXPORT
      static const std::string hsSystemNumObs;      
      GNSSTK_EXPORT
      static const std::string hsWaveFact;          
      GNSSTK_EXPORT
      static const std::string hsSigStrengthUnit;   
      GNSSTK_EXPORT
      static const std::string hsInterval;          
      GNSSTK_EXPORT
      static const std::string hsFirstTime;         
      GNSSTK_EXPORT
      static const std::string hsLastTime;          
      GNSSTK_EXPORT
      static const std::string hsReceiverOffset;    
      GNSSTK_EXPORT
      static const std::string hsSystemDCBSapplied; 
      GNSSTK_EXPORT
      static const std::string hsSystemPCVSapplied; 
      GNSSTK_EXPORT
      static const std::string hsSystemScaleFac;    
      GNSSTK_EXPORT
      static const std::string hsSystemPhaseShift;  
      GNSSTK_EXPORT
      static const std::string hsGlonassSlotFreqNo; 
      GNSSTK_EXPORT
      static const std::string hsGlonassCodPhsBias; 
      GNSSTK_EXPORT
      static const std::string hsLeapSeconds;       
      GNSSTK_EXPORT
      static const std::string hsNumSats;           
      GNSSTK_EXPORT
      static const std::string hsPrnObs;            
      GNSSTK_EXPORT
      static const std::string hsEoH;               
      GNSSTK_EXPORT
      static const std::string hsAntennaStandard;   
      GNSSTK_EXPORT
      static const std::string hsAntennaRegional;   
 
      enum Field
      {
         validInvalid = 0,                    
         validVersion,                        
         validFirst = validVersion,           
         validRunBy,                          
         validComment,                        
         validMarkerName,                     
         validMarkerNumber,                   
         validMarkerType,                     
         validObserver,                       
         validReceiver,                       
         validAntennaType,                    
         validAntennaPosition,                
         validAntennaDeltaHEN,                
         validAntennaDeltaXYZ,                
         validAntennaPhaseCtr,                
         validAntennaBsightXYZ,               
         validAntennaZeroDirAzi,              
         validAntennaZeroDirXYZ,              
         validCenterOfMass,                   
         validNumObs,                         
         validSystemNumObs,                   
         validWaveFact,                       
         validSigStrengthUnit,                
         validInterval,                       
         validFirstTime,                      
         validLastTime,                       
         validReceiverOffset,                 
         validSystemDCBSapplied,              
         validSystemPCVSapplied,              
         validSystemScaleFac,                 
         validSystemPhaseShift,               
         validGlonassSlotFreqNo,              
         validGlonassCodPhsBias,              
         validLeapSeconds,                    
         validNumSats,                        
         validPrnObs,                         
         validLast                            
      };
 
      class Rinex3CorrInfo
      {
      public:
         std::string satSys;  
         std::string name;    
         std::string source;  
      };
 
      class ExtraWaveFact
      {
      public:
         std::vector<SatID> satList;
         short wavelengthFactor[2];
         ExtraWaveFact& setWavelengthFactor(short wf1, short wf2)
         {
            wavelengthFactor[0] = wf1;
            wavelengthFactor[1] = wf2;
            return *this;
         }
         short getWavelengthFactor1()
         { return wavelengthFactor[0]; }
         short getWavelengthFactor2()
         { return wavelengthFactor[1]; }
      };
 
      typedef std::vector<std::string> StringVec;
      typedef std::vector<int> IntVec;
      typedef std::map<RinexSatID, IntVec> PRNNumObsMap;
      typedef std::map<RinexObsID, int> ScaleFacMap;
      typedef std::map<std::string, ScaleFacMap> SysScaleFacMap;
      typedef std::vector<RinexObsID> RinexObsVec;
      typedef std::map<std::string, RinexObsVec> RinexObsMap;
      typedef std::map<std::string, RinexObsID> ObsIDMap;
      typedef std::map<std::string, ObsIDMap> VersionObsMap;
      typedef std::map<RinexSatID, double> SVPhsShftMap;
      typedef std::map<RinexObsID, SVPhsShftMap> ObsPhsShftMap;
      typedef std::map<std::string, ObsPhsShftMap> SysPhsShftMap;
      typedef std::map<RinexSatID, int> GLOFreqNumMap;
      typedef std::map<RinexObsID, double> GLOCodPhsBias;
      typedef std::map<std::string,std::string> DisAmbMap;
      typedef std::vector<Rinex3CorrInfo> CorrVec;
      typedef std::vector<ExtraWaveFact> FactorVector;
      typedef std::set<Field> FieldSet;
 
      class Fields
      {
      public:
         Fields() = default;
         Fields(const FieldSet& fields)
               : fieldsSet(fields)
         {}
         bool operator==(const Fields& rhs) const
         { return fieldsSet == rhs.fieldsSet; }
         bool operator!=(const Fields& rhs) const
         { return !(fieldsSet == rhs.fieldsSet); }
         Fields& set(Field f)
         { fieldsSet.insert(f); return *this; }
         Fields& clear(Field f)
         { fieldsSet.erase(f); return *this; }
         bool isSet(Field f) const
         { return fieldsSet.count(f) > 0; }
         void clear()
         { fieldsSet.clear(); }
         bool empty() const
         { return fieldsSet.empty(); }
         Fields operator&(const Fields& rhs) const;
         Fields operator|(const Fields& rhs) const;
         Field operator&(Field rhs) const;
         Fields& operator|=(Field rhs)
         { return set(rhs); }
         Fields& operator^=(Field rhs)
         { return clear(rhs); }
         bool isValid(const Fields& present) const;
         static bool isValid(double version, const Fields& present)
         { return getRequired(version).isValid(present); }
         void describeMissing(const Fields& valid, Exception& exc);
         static Fields getRequired(double version);
 
         FieldSet fieldsSet;
      };
 
      GNSSTK_EXPORT
      static const Fields allValid2, allValid30, allValid301, allValid302,
         allValid303;
 
      StringVec R2ObsTypes;
 
      VersionObsMap mapSysR2toR3ObsID;
 
      DisAmbMap R2DisambiguityMap;
 
 
      double version;                  
      std::string fileType;            
      std::string fileSys;
      bool preserveVerType;
      SatID fileSysSat;                
      std::string fileProgram;         
      std::string fileAgency;          
      std::string date;                
 
      bool preserveDate;
      StringVec commentList;           
      std::string markerName;          
      std::string markerNumber;        
      std::string markerType;          
      std::string observer;            
      std::string agency;              
      std::string recNo;               
      std::string recType;             
      std::string recVers;             
      std::string antNo;               
      std::string antType;             
      gnsstk::Triple antennaPosition;   
      gnsstk::Triple antennaDeltaHEN;   
      gnsstk::Triple antennaDeltaXYZ;   
      std::string antennaSatSys;       
      std::string antennaObsCode;      
      gnsstk::Triple antennaPhaseCtr;   
      gnsstk::Triple antennaBsightXYZ;  
      double        antennaZeroDirAzi; 
      gnsstk::Triple antennaZeroDirXYZ; 
      gnsstk::Triple centerOfMass;      
      RinexObsMap mapObsTypes;         
      short wavelengthFactor[2];       
      FactorVector extraWaveFactList;  
      std::string sigStrengthUnit;     
      double interval;                 
      CivilTime firstObs;              
      CivilTime lastObs;               
      int receiverOffset;              
      CorrVec infoDCBS;                
      CorrVec infoPCVS;                
      SysScaleFacMap sysSfacMap;       
      SysPhsShftMap sysPhaseShift;     
      GLOFreqNumMap glonassFreqNo;     
      GLOCodPhsBias glonassCodPhsBias; 
      int leapSeconds;                 
      short numSVs;                    
      PRNNumObsMap numObsForSat;       
 
      XmitAnt xmitAnt;                 
 
      RinexObsVec obsTypeList;
 
      Fields valid;
      bool validEoH;
      bool PisY;
 
      GNSSTK_EXPORT static int debug;
 
      virtual ~Rinex3ObsHeader()
      {}
 
         // The next four lines comprise our common interface.
 
      virtual bool isHeader() const
      { return true; }
 
      virtual void dump(std::ostream& s) const
      { dump(s, version); }
 
      void dump(std::ostream& s, double dumpVersion) const;
 
      virtual std::size_t getObsIndex(const std::string& type ) const;
 
      virtual std::size_t getObsIndex(const std::string& sys,
                                      const RinexObsID& obsID ) const;
 
      void parseHeaderRecord(std::string& line);
 
      int numberHeaderRecordsToBeWritten(void) const noexcept;
 
      void writeHeaderRecords(FFStream& s) const;
 
      bool isValid() const
      { return (validEoH && Fields::isValid(version, valid)); }
 
      void prepareVer2Write(void);
 
      bool compare(const Rinex3ObsHeader& right,
                   StringVec& diffs,
                   const StringVec& inclExclList,
                   bool incl = false);
 
      static std::string asString(Field b);
      static Field asField(const std::string& s);
 
      Rinex3ObsHeader& setWavelengthFactor(short wf1, short wf2)
      {
         wavelengthFactor[0] = wf1;
         wavelengthFactor[1] = wf2;
         return *this;
      }
      short getWavelengthFactor1()
      { return wavelengthFactor[0]; }
      short getWavelengthFactor2()
      { return wavelengthFactor[1]; }
 
   protected:
 
 
      virtual void reallyPutRecord(FFStream& s) const;
 
      virtual void reallyGetRecord(FFStream& s);
 
 
      std::vector<RinexObsID> mapR2ObsToR3Obs_G();
      std::vector<RinexObsID> mapR2ObsToR3Obs_R();
      std::vector<RinexObsID> mapR2ObsToR3Obs_E();
      std::vector<RinexObsID> mapR2ObsToR3Obs_S();
 
      void remapObsTypes(RinexObsMap& remapped,
                         std::map<std::string,unsigned>& obsCount)
         const;
 
      friend class Rinex3ObsData;
 
 
   private:
 
      std::string writeTime(const CivilTime& civtime) const;
 
      CivilTime parseTime(const std::string& line) const;
 
      RinexObsID sysPhaseShiftObsID;
      std::string satSysTemp;
      std::string satSysPrev;
      int numObs;
      int numObsPrev;
      RinexSatID lastPRN;
      int factor, factorPrev;
 
   }; // end class Rinex3ObsHeader
 
   std::ostream& operator<<(std::ostream& s, const Rinex3ObsHeader::Fields& v);
 
 
} // namespace
 
#endif // GNSSTK_RINEX3OBSHEADER_HPP