AntexData.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 ANTEX_DATA_HPP
#define ANTEX_DATA_HPP
 
#include <map>
#include <string>
#include <vector>
 
#include "AntexBase.hpp"
#include "CivilTime.hpp"
#include "CommonTime.hpp"
#include "FFStream.hpp"
#include "Triple.hpp"
#include "gnsstk_export.h"
 
namespace gnsstk
{
 
 
   class AntexData : public AntexBase
   {
   public:
      GNSSTK_EXPORT
      static const std::string startAntennaString;    
      GNSSTK_EXPORT
      static const std::string typeSerNumString;      
      GNSSTK_EXPORT
      static const std::string methodString;          
      GNSSTK_EXPORT
      static const std::string daziString;            
      GNSSTK_EXPORT
      static const std::string zenithString;          
      GNSSTK_EXPORT
      static const std::string numFreqString;         
      GNSSTK_EXPORT
      static const std::string validFromString;       
      GNSSTK_EXPORT
      static const std::string validUntilString;      
      GNSSTK_EXPORT
      static const std::string sinexCodeString;       
      GNSSTK_EXPORT
      static const std::string dataCommentString;     
      GNSSTK_EXPORT
      static const std::string startFreqString;       
      GNSSTK_EXPORT
      static const std::string neuFreqString;         
      GNSSTK_EXPORT
      static const std::string endOfFreqString;       
      GNSSTK_EXPORT
      static const std::string startFreqRMSString;    
      GNSSTK_EXPORT
      static const std::string neuFreqRMSString;      
      GNSSTK_EXPORT
      static const std::string endOfFreqRMSString;    
      GNSSTK_EXPORT
      static const std::string endOfAntennaString;    
 
 
      enum validBits
      {
         startAntennaValid = 0x00001, 
         typeSerNumValid   = 0x00002, 
         methodValid       = 0x00004, 
         daziValid         = 0x00008, 
         zenithValid       = 0x00010, 
         numFreqValid      = 0x00020, 
         validFromValid    = 0x00040, 
         validUntilValid   = 0x00080, 
         sinexCodeValid    = 0x00100, 
         dataCommentValid  = 0x00200, 
         startFreqValid    = 0x00400, 
         neuFreqValid      = 0x00800, 
         endOfFreqValid    = 0x01000, 
         startFreqRMSValid = 0x02000, 
         neuFreqRMSValid   = 0x04000, 
         endOfFreqRMSValid = 0x08000, 
         endOfAntennaValid = 0x10000, 
         allValid13        = 0x11C3F  
      };
 
      GNSSTK_EXPORT static const std::vector<std::string> SatelliteTypes;
 
      typedef std::map<double, double> zenOffsetMap;
 
      typedef std::map<double, zenOffsetMap> azimZenMap;
 
      class antennaPCOandPCVData
      {
       public:
         double PCOvalue[3], PCOrms[3];
 
         bool hasAzimuth;
 
         azimZenMap PCVvalue, PCVrms;
 
      }; // end of class antennaPCOandPCVData
 
      // member data
 
      unsigned long valid;
 
      bool absolute;
 
      bool isRxAntenna;
 
      int PRN, SVN;
 
      char systemChar;
 
      unsigned int nFreq;
 
      double azimDelta;
 
      double zenRange[3];
 
      CommonTime validFrom, validUntil;
      std::string stringValidFrom, stringValidUntil;
 
      std::map<std::string, antennaPCOandPCVData> freqPCVmap;
 
      std::string type;     
      std::string serialNo; 
      std::string satCode;  
      std::string cospar;   
      std::string method;   
      std::string agency;   
      int noAntCalibrated;  
      std::string date;     
      std::string
         sinexCode;         
 
      std::vector<std::string> commentList;
 
      // member functions
 
      AntexData()
         : valid(0), absolute(true), PRN(0), SVN(0), nFreq(0),
           validFrom(CommonTime::BEGINNING_OF_TIME),
           validUntil(CommonTime::END_OF_TIME)
      {
      }
      virtual ~AntexData() {}
 
      virtual bool isData() const { return true; }
 
      bool isValid() const { return ((valid & allValid13) == allValid13); }
 
      bool isValid(CommonTime& time) const;
 
      std::string name() const;
 
      double getTotalPhaseCenterOffset(const std::string& freq,
                                       double azimuth,
                                       double elevation) const;
 
      Triple getPhaseCenterOffset(const std::string& freq) const;
 
      double getPhaseCenterVariation(const std::string& freq,
                                     double azimuth,
                                     double elev_nadir) const;
 
      virtual void dump(std::ostream& s, int detail = 0) const;
 
   protected:
      void evaluateZenithMap(double zen, const zenOffsetMap& eomap,
                             double& zen_lo, double& zen_hi, double& pco_lo,
                             double& pco_hi) const;
 
      virtual void reallyPutRecord(FFStream& s) const;
 
      virtual void reallyGetRecord(FFStream& s);
 
   private:
      void throwRecordOutOfOrder(unsigned long test, std::string& label);
 
      void ParseDataRecord(std::string& line);
 
      std::string writeTime(const CommonTime& dt) const;
 
      CommonTime parseTime(const std::string& line) const;
 
   }; // class AntexData
 
 
} // namespace gnsstk
 
#endif