SinexTypes.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_SINEXTYPES_HPP
#define GNSSTK_SINEXTYPES_HPP
 
//lgpl-license START
//lgpl-license END
 
//dod-release-statement START
//dod-release-statement END
 
#include "Triple.hpp"
#include "SinexBase.hpp"
#include "SinexHeader.hpp"  
 
namespace gnsstk
{
   namespace Sinex
   {
 
 
      struct DataType
      {
 
         virtual ~DataType() {}
 
         virtual operator std::string() const = 0;
         virtual void operator=(const std::string& line) = 0;
 
         virtual void dump(std::ostream& s) const {}
 
      }; // struct DataType
 
 
      struct FileReference : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 21;
         static const size_t       MAX_LINE_LEN = 80;
 
         FileReference() {}
         FileReference(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~FileReference() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  infoType;  
         std::string  infoValue; 
 
      }; // struct FileReference
 
 
      struct FileComment : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 1;
         static const size_t       MAX_LINE_LEN = 80;
 
         FileComment() {}
         FileComment(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~FileComment() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  comment;
 
      }; // struct FileComment
 
 
      struct InputHistory : public DataType, Header
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 67;
         static const size_t       MAX_LINE_LEN = 79;
 
         InputHistory() {}
         InputHistory(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~InputHistory() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         char  fileCode;   
 
      }; // struct InputHistory
 
 
      struct InputFile : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 49;
         static const size_t       MAX_LINE_LEN = 80;
 
         InputFile() {}
         InputFile(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~InputFile() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  agencyCode;
         Time         creationTime;
         std::string  fileName;
         std::string  fileDesc;
 
      }; // struct InputFile
 
 
      struct InputAck : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 6;
         static const size_t       MAX_LINE_LEN = 80;
 
         InputAck() {}
         InputAck(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~InputAck() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  agencyCode;
         std::string  agencyDesc;
 
      }; // struct InputAck
 
 
      struct NutationData : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 11;
         static const size_t       MAX_LINE_LEN = 80;
 
         NutationData() {}
         NutationData(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~NutationData() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  nutationCode;
         std::string  nutationDesc;
 
      }; // struct NutationData
 
 
      struct PrecessionData : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 11;
         static const size_t       MAX_LINE_LEN = 80;
 
         PrecessionData() {}
         PrecessionData(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~PrecessionData() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  precessionCode;
         std::string  precessionDesc;
 
      }; // struct PrecessionData
 
 
      struct SourceId : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 33;
         static const size_t       MAX_LINE_LEN = 80;
 
         SourceId() {}
         SourceId(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SourceId() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  sourceCode;
         std::string  iers;
         std::string  icrf;
         std::string  comment;
 
      }; // struct SourceId
 
 
      struct SiteId : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 75;
         static const size_t       MAX_LINE_LEN = 75;
 
         SiteId() {}
         SiteId(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SiteId() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  siteCode;      
         std::string  pointCode;     
         std::string  monumentId;    
         char         obsCode;       
         std::string  siteDesc;      
         uint16_t     longitudeDeg;  
         uint8_t      longitudeMin;  
         float        longitudeSec;  
         int16_t      latitudeDeg;   
         uint8_t      latitudeMin;   
         float        latitudeSec;   
         double       height;        
 
      }; // struct SiteId
 
 
      struct SiteData : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 71;
         static const size_t       MAX_LINE_LEN = 71;
 
         SiteData() {}
         SiteData(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SiteData() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  siteCodeSol;    
         std::string  pointCodeSol;   
         std::string  solutionIdSol;  
         std::string  siteCodeInp;    
         std::string  pointCodeInp;   
         std::string  solutionIdInp;  
         char         obsCode;        
         Time         timeStart;      
         Time         timeEnd;        
         std::string  agencyCode;     
         Time         creationTime;   
 
      }; // struct SiteData
 
 
      struct SiteReceiver : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 70;
         static const size_t       MAX_LINE_LEN = 80;
 
         SiteReceiver() {}
         SiteReceiver(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SiteReceiver() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  siteCode;      
         std::string  pointCode;     
         std::string  solutionId;    
         char         obsCode;       
         Time         timeSince;
         Time         timeUntil;
         std::string  rxType;        
         std::string  rxSerialNo;    
         std::string  rxFirmware;    
 
      }; // struct SiteReceiver
 
 
      struct SiteAntenna : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 64;
         static const size_t       MAX_LINE_LEN = 68;
 
         SiteAntenna() {}
         SiteAntenna(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SiteAntenna() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  siteCode;         
         std::string  pointCode;        
         std::string  solutionId;       
         char         obsCode;          
         Time         timeSince;
         Time         timeUntil;
         std::string  antennaType;      
         std::string  antennaSerialNo;  
 
      }; // struct SiteAntenna
 
 
      struct SitePhaseCenter : public DataType
      {
         static const size_t       MIN_LINE_LEN = 71;
         static const size_t       MAX_LINE_LEN = 80;
 
         SitePhaseCenter() {}
         SitePhaseCenter(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SitePhaseCenter() {}
 
         virtual operator std::string() const;
         virtual void operator=(const std::string& line);
 
         virtual void dump(std::ostream& s) const;
 
         std::string  antennaType;         
         std::string  antennaSerialNo;     
         Triple       offsetA;             
         Triple       offsetB;             
         std::string  antennaCalibration;  
 
      }; // struct SitePhaseCenter
 
 
      struct SiteGpsPhaseCenter : public SitePhaseCenter
      {
         static const std::string  BLOCK_TITLE;
 
         enum Frequencies
         {
            L1L2 = 0   
 
         } frequencies;
 
         SiteGpsPhaseCenter()
               : frequencies(L1L2) {}
         SiteGpsPhaseCenter(const std::string& line, size_t num = 0)
               : SitePhaseCenter(line), frequencies( (Frequencies)(num % 1) ) {}
 
         virtual ~SiteGpsPhaseCenter() {}
 
         void dump(std::ostream& s) const;
 
      }; // struct SiteGpsPhaseCenter
 
 
      struct SiteGalPhaseCenter : public SitePhaseCenter
      {
         static const std::string  BLOCK_TITLE;
 
         enum Frequencies
         {
            L1L5 = 0,  
            L6L7,      
            L8x        
 
         } frequencies;
 
         SiteGalPhaseCenter()
               : frequencies(L1L5) {}
         SiteGalPhaseCenter(const std::string& line, size_t num = 0)
               : SitePhaseCenter(line), frequencies( (Frequencies)(num % 3) ) {}
 
         virtual ~SiteGalPhaseCenter() {}
 
         void dump(std::ostream& s) const;
 
      }; // struct SiteGalPhaseCenter
 
 
      struct SiteEccentricity : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 72;
         static const size_t       MAX_LINE_LEN = 72;
 
         SiteEccentricity() {}
         SiteEccentricity(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SiteEccentricity() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  siteCode;     
         std::string  pointCode;    
         std::string  solutionId;   
         char         obsCode;      
         Time         timeSince;
         Time         timeUntil;
         std::string  refSystem;    
         Triple       eccentricity; 
 
      }; // struct SiteEccentricity
 
 
      struct SatelliteId : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 48;
         static const size_t       MAX_LINE_LEN = 67;
 
         SatelliteId() {}
         SatelliteId(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SatelliteId() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  svCode;       
         std::string  prn;          
         std::string  cosparId;     
         char         obsCode;      
         Time         timeSince;
         Time         timeUntil;
         std::string  antennaType;  
 
      }; // struct SatelliteId
 
 
      struct SatellitePhaseCenter : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 66;
         static const size_t       MAX_LINE_LEN = 66;
 
         SatellitePhaseCenter() {}
         SatellitePhaseCenter(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SatellitePhaseCenter() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  svCode;     
         char         freqCodeA;  
         Triple       offsetA;    
         char         freqCodeB;  
         Triple       offsetB;    
         std::string  antennaCalibration;  
         char         pcvType;    
         char         pcvModel;   
 
      }; // struct SatellitePhaseCenter
 
 
      struct BiasEpoch : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 54;
         static const size_t       MAX_LINE_LEN = 54;
 
         BiasEpoch() {}
         BiasEpoch(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~BiasEpoch() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  siteCode;    
         std::string  pointCode;   
         std::string  solutionId;  
         char         biasType;    
         Time         firstTime;
         Time         lastTime;
         Time         meanTime;
 
      }; // struct BiasEpoch
 
 
      struct SolutionStatistics : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 54;
         static const size_t       MAX_LINE_LEN = 54;
 
         SolutionStatistics() {}
         SolutionStatistics(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionStatistics() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  infoType;   
         long double  infoValue;  
 
      }; // struct SolutionStatistics
 
 
      struct SolutionEpoch : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 54;
         static const size_t       MAX_LINE_LEN = 54;
 
         SolutionEpoch() {}
         SolutionEpoch(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionEpoch() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         std::string  siteCode;    
         std::string  pointCode;   
         std::string  solutionId;  
         char         obsCode;     
         Time         startTime;
         Time         endTime;
         Time         meanTime;
 
      }; // struct SolutionEpoch
 
 
      struct SolutionEstimate : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 80;
         static const size_t       MAX_LINE_LEN = 80;
 
         SolutionEstimate() {}
         SolutionEstimate(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionEstimate() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         uint32_t     paramIndex;
         std::string  paramType;
         std::string  siteCode;    
         std::string  pointCode;   
         std::string  solutionId;  
         Time         epoch;
         std::string  paramUnits;
         char         constraintCode;
         long double  paramEstimate;
         double       paramStdDev;
 
      }; // struct SolutionEstimate
 
 
      struct SolutionApriori : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 80;
         static const size_t       MAX_LINE_LEN = 80;
 
         SolutionApriori() {}
         SolutionApriori(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionApriori() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         uint32_t     paramIndex;
         std::string  paramType;
         std::string  siteCode;    
         std::string  pointCode;   
         std::string  solutionId;  
         Time         epoch;
         std::string  paramUnits;
         char         constraintCode;
         long double  paramApriori;
         double       paramStdDev;
 
      }; // struct SolutionApriori
 
 
      struct SolutionMatrixEstimate : public DataType
      {
         static const size_t       MIN_LINE_LEN = 78;
         static const size_t       MAX_LINE_LEN = 78;
 
         SolutionMatrixEstimate() {}
         SolutionMatrixEstimate(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionMatrixEstimate() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         uint32_t     row;
         uint32_t     col;
         long double  val1;
         long double  val2;
         long double  val3;
 
      }; // struct SolutionMatrixEstimate
 
 
      struct SolutionMatrixEstimateLCorr : public SolutionMatrixEstimate
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixEstimateLCorr()
               : SolutionMatrixEstimate() {}
         SolutionMatrixEstimateLCorr(const std::string& line, size_t num = 0)
               : SolutionMatrixEstimate(line, num) {}
 
         virtual ~SolutionMatrixEstimateLCorr() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixEstimateUCorr : public SolutionMatrixEstimate
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixEstimateUCorr()
               : SolutionMatrixEstimate() {}
         SolutionMatrixEstimateUCorr(const std::string& line, size_t num = 0)
               : SolutionMatrixEstimate(line, num) {}
 
         virtual ~SolutionMatrixEstimateUCorr() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixEstimateLCova : public SolutionMatrixEstimate
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixEstimateLCova()
               : SolutionMatrixEstimate() {}
         SolutionMatrixEstimateLCova(const std::string& line, size_t num = 0)
               : SolutionMatrixEstimate(line, num) {}
 
         virtual ~SolutionMatrixEstimateLCova() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixEstimateUCova : public SolutionMatrixEstimate
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixEstimateUCova()
               : SolutionMatrixEstimate() {}
         SolutionMatrixEstimateUCova(const std::string& line, size_t num = 0)
               : SolutionMatrixEstimate(line, num) {}
 
         virtual ~SolutionMatrixEstimateUCova() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixEstimateLInfo : public SolutionMatrixEstimate
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixEstimateLInfo()
               : SolutionMatrixEstimate() {}
         SolutionMatrixEstimateLInfo(const std::string& line, size_t num = 0)
               : SolutionMatrixEstimate(line, num) {}
 
         virtual ~SolutionMatrixEstimateLInfo() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixEstimateUInfo : public SolutionMatrixEstimate
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixEstimateUInfo()
               : SolutionMatrixEstimate() {}
         SolutionMatrixEstimateUInfo(const std::string& line, size_t num = 0)
               : SolutionMatrixEstimate(line, num) {}
 
         virtual ~SolutionMatrixEstimateUInfo() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixApriori : public DataType
      {
         static const size_t       MIN_LINE_LEN = 78;
         static const size_t       MAX_LINE_LEN = 78;
 
         SolutionMatrixApriori() {}
         SolutionMatrixApriori(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionMatrixApriori() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         uint32_t     row;
         uint32_t     col;
         long double  val1;
         long double  val2;
         long double  val3;
 
      }; // struct SolutionMatrixApriori
 
 
      struct SolutionMatrixAprioriLCorr : public SolutionMatrixApriori
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixAprioriLCorr()
               : SolutionMatrixApriori() {}
         SolutionMatrixAprioriLCorr(const std::string& line, size_t num = 0)
               : SolutionMatrixApriori(line, num) {}
 
         virtual ~SolutionMatrixAprioriLCorr() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixAprioriUCorr : public SolutionMatrixApriori
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixAprioriUCorr()
               : SolutionMatrixApriori() {}
         SolutionMatrixAprioriUCorr(const std::string& line, size_t num = 0)
               : SolutionMatrixApriori(line, num) {}
 
         virtual ~SolutionMatrixAprioriUCorr() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixAprioriLCova : public SolutionMatrixApriori
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixAprioriLCova()
               : SolutionMatrixApriori() {}
         SolutionMatrixAprioriLCova(const std::string& line, size_t num = 0)
               : SolutionMatrixApriori(line, num) {}
 
         virtual ~SolutionMatrixAprioriLCova() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixAprioriUCova : public SolutionMatrixApriori
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixAprioriUCova()
               : SolutionMatrixApriori() {}
         SolutionMatrixAprioriUCova(const std::string& line, size_t num = 0)
               : SolutionMatrixApriori(line, num) {}
 
         virtual ~SolutionMatrixAprioriUCova() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixAprioriLInfo : public SolutionMatrixApriori
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixAprioriLInfo()
               : SolutionMatrixApriori() {}
         SolutionMatrixAprioriLInfo(const std::string& line, size_t num = 0)
               : SolutionMatrixApriori(line, num) {}
 
         virtual ~SolutionMatrixAprioriLInfo() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionMatrixAprioriUInfo : public SolutionMatrixApriori
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionMatrixAprioriUInfo()
               : SolutionMatrixApriori() {}
         SolutionMatrixAprioriUInfo(const std::string& line, size_t num = 0)
               : SolutionMatrixApriori(line, num) {}
 
         virtual ~SolutionMatrixAprioriUInfo() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionNormalEquationVector : public DataType
      {
         static const std::string  BLOCK_TITLE;
         static const size_t       MIN_LINE_LEN = 68;
         static const size_t       MAX_LINE_LEN = 68;
 
         SolutionNormalEquationVector() {}
         SolutionNormalEquationVector(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionNormalEquationVector() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         uint32_t     paramIndex;
         std::string  paramType;
         std::string  siteCode;       
         std::string  pointCode;      
         std::string  solutionId;     
         Time         epoch;
         std::string  paramUnits;
         char         constraintCode;
         long double  value;          
 
      }; // struct SolutionNormalEquationVector
 
 
      struct SolutionNormalEquationMatrix : public DataType
      {
         static const size_t       MIN_LINE_LEN = 78;
         static const size_t       MAX_LINE_LEN = 78;
 
         SolutionNormalEquationMatrix() {}
         SolutionNormalEquationMatrix(const std::string& line, size_t num = 0)
         { *this = line; }
 
         virtual ~SolutionNormalEquationMatrix() {}
 
         operator std::string() const;
         void operator=(const std::string& line);
 
         void dump(std::ostream& s) const;
 
         uint32_t     row;
         uint32_t     col;
         long double  val1;
         long double  val2;
         long double  val3;
 
      }; // struct SolutionNormalEquationMatrix
 
 
      struct SolutionNormalEquationMatrixL : public SolutionNormalEquationMatrix
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionNormalEquationMatrixL()
               : SolutionNormalEquationMatrix() {}
 
         SolutionNormalEquationMatrixL(const std::string& line, size_t num = 0)
               : SolutionNormalEquationMatrix(line, num) {}
 
         virtual ~SolutionNormalEquationMatrixL() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
      struct SolutionNormalEquationMatrixU : public SolutionNormalEquationMatrix
      {
         static const std::string  BLOCK_TITLE;
 
         SolutionNormalEquationMatrixU()
               : SolutionNormalEquationMatrix() {}
         SolutionNormalEquationMatrixU(const std::string& line, size_t num = 0)
               : SolutionNormalEquationMatrix(line, num) {}
 
         virtual ~SolutionNormalEquationMatrixU() {}
 
         void dump(std::ostream& s) const;
 
      };
 
 
   }  // namespace Sinex
 
}  // namespace gnsstk
 
#endif // GNSSTK_SINEXTYPES_HPP