DiscCorr.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_DISCONTINUITY_CORRECTOR_INCLUDE
#define GNSSTK_DISCONTINUITY_CORRECTOR_INCLUDE
 
#include "gnsstk_export.h"
#include "Epoch.hpp"
#include "Exception.hpp"
#include "RinexObsHeader.hpp"
#include "RinexSatID.hpp"
#include "SatPass.hpp"
 
#include <fstream>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
 
namespace gnsstk
{
 
   class GDCconfiguration
   {
   public:
      GDCconfiguration() { initialize(); }
      ~GDCconfiguration()
      {
         CFG.clear();
         CFGdescription.clear();
      }
 
      void setParameter(std::string cmd);
 
      void setParameter(const std::string& label, double value);
 
      double getParameter(const std::string& label)
      {
         if (CFG.find(label) == CFG.end())
         {
            return 0.0; // TD throw?
         }
         return CFG[label];
      }
 
      std::string getDescription(const std::string& label)
      {
         if (CFGdescription.find(label) == CFGdescription.end())
         {
            return std::string("Invalid label");
         }
         return CFGdescription[label];
      }
 
      void setDebugStream(std::ostream& os) { p_oflog = &os; }
 
      void DisplayParameterUsage(std::ostream& os, bool advanced = false);
 
      std::string Version() { return GDCVersion; }
 
   protected:
      std::map<std::string, double> CFG;
 
      std::map<std::string, std::string> CFGdescription;
 
      std::ostream *p_oflog;
 
      void initialize();
 
      GNSSTK_EXPORT
      static const std::string GDCVersion;
 
   }; // end class GDCconfiguration
 
   class GDCreturn
   {
   public:
      explicit GDCreturn(std::string msg)
      {
         passN    = -1;
         nGFslips = nWLslips = 0;
         nGFslipGross = nWLslipGross = 0;
         nGFslipSmall = nWLslipSmall = 0;
         WLsig = GFsig = 0.0;
         sat           = "";
         GLOn          = -99;
 
         std::string::size_type pos;
         std::string word, line;
         std::vector<std::string> lines, words;
         if (msg.empty())
         {
            return;
         }
         // split into lines
         while (1)
         {
            pos = msg.find_first_not_of("\n");
            if (pos > 0)
            {
               msg.erase(0, pos);
            }
            if (msg.empty())
            {
               break;
            }
            pos = msg.find_first_of("\n");
            if (pos > 0)
            {
               word = msg.substr(0, pos);
               msg.erase(0, pos);
            }
            else
            {
               word = msg;
               msg.clear();
            }
            lines.push_back(word);
         }
 
         ptsdeleted = ptsgood = 0;
         for (int i = 0; i < lines.size(); i++)
         {
            line = lines[i];
            if (line.empty())
            {
               continue;
            }
            // split line into words
            words.clear();
            while (1)
            {
               pos = line.find_first_not_of(" \t\n");
               if (pos != 0 && pos != std::string::npos)
               {
                  line.erase(0, pos);
               }
               if (line.empty())
               {
                  break;
               }
               pos = line.find_first_of(" \t\n");
               if (pos == std::string::npos)
               {
                  word = line;
               }
               else
               {
                  word = line.substr(0, pos);
               }
               if (!word.empty())
               {
                  words.push_back(word);
                  line.erase(0, word.length() + 1);
               }
            }
 
            // std::cout << "Line " << i << ":";
            // for(int j=0; j<words.size(); j++) std::cout << " /" << words[j]
            // << "/"; std::cout << std::endl;
 
            line = lines[i];
            // std::cout << line << std::endl;
            if (line.find("WL sigma in cycles", 0) != std::string::npos)
            {
               passN = strtol(words[1].c_str(), 0, 10);
            }
            else if (line.find("insufficient data", 0) != std::string::npos)
            {
               passN = strtol(words[1].c_str(), 0, 10);
            }
            else if (line.find("list of Segments", 0) != std::string::npos)
            {
               passN = strtol(words[1].c_str(), 0, 10);
            }
            if (line.find("bias(wl)", 0) != std::string::npos)
            {
               sat  = words[2];
               word = words[5];
               pos  = word.find_first_of("/");
               if (pos > 0)
               {
                  word = words[5].substr(0, pos);
               }
               ptsgood += strtol(word.c_str(), 0, 10);
            }
            if (line.find("WL slip gross", 0) != std::string::npos)
            {
               nWLslipGross = strtol(words[3].c_str(), 0, 10);
            }
            if (line.find("WL slip small", 0) != std::string::npos)
            {
               nWLslipSmall = strtol(words[3].c_str(), 0, 10);
            }
            if (line.find("GF slip gross", 0) != std::string::npos)
            {
               nGFslipGross = strtol(words[3].c_str(), 0, 10);
            }
            if (line.find("GF slip small", 0) != std::string::npos)
            {
               nGFslipSmall = strtol(words[3].c_str(), 0, 10);
            }
            if (line.find("sigma GF variation", 0) != std::string::npos)
            {
               GFsig = strtod(words[3].c_str(), 0);
            }
            if (line.find("WL sigma in cycles", 0) != std::string::npos)
            {
               WLsig = strtod(words[3].c_str(), 0);
            }
            if (line.find("points deleted", 0) != std::string::npos)
            {
               ptsdeleted += strtol(words[3].c_str(), 0, 10);
            }
            if (line.find("GLONASS frequency channel", 0) != std::string::npos)
            {
               GLOn = strtod(words[3].c_str(), 0);
            }
         }
 
         nWLslips = nWLslipGross + nWLslipSmall;
         nGFslips = nGFslipGross + nGFslipSmall;
 
      } // end constructor/parser
 
      int passN, GLOn;
      int nGFslips, nWLslips, nGFslipGross, nGFslipSmall, nWLslipGross,
         nWLslipSmall;
      int ptsdeleted, ptsgood;
      double WLsig, GFsig;
      std::string sat;
 
   }; // end class GDCreturn
 
   int DiscontinuityCorrector(SatPass& SP, GDCconfiguration& config,
                              std::vector<std::string>& EditCmds,
                              std::string& retMsg, int GLOn = -99);
 
 
} // end namespace gnsstk
 
//------------------------------------------------------------------------------------
#endif