DiscCorr.hpp

Go to the documentation of this file.

#pragma ident "$Id: DiscCorr.hpp 2293 2010-02-12 18:14:16Z btolman $"

//============================================================================
//
//  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

#ifndef GPSTK_DISCONTINUITY_CORRECTOR_INCLUDE
#define GPSTK_DISCONTINUITY_CORRECTOR_INCLUDE

#include "DayTime.hpp"
#include "GSatID.hpp"
#include "RinexObsHeader.hpp"
#include "SatPass.hpp"
#include "Exception.hpp"

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <map>

namespace gpstk {


   class GDCconfiguration {
   public:
      GDCconfiguration(void) { initialize(); }
         // destructor
      ~GDCconfiguration(void) { CFG.clear(); CFGdescription.clear(); }

      void setParameter(std::string cmd) throw(gpstk::Exception);

      void setParameter(std::string label, double value) throw(gpstk::Exception);

      double getParameter(std::string label) throw() { return CFG[label]; }

      void setDebugStream(std::ostream& os) { p_oflog = &os; }

      void DisplayParameterUsage(std::ostream& os, bool advanced=false)
         throw(gpstk::Exception);

      std::string Version() throw() { return GDCVersion; }

   protected:

      std::map <std::string,double> CFG;

      std::map <std::string,std::string> CFGdescription;

      std::ostream *p_oflog;

      void initialize(void);

      static 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;

         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);
         }

         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("insufficient data",0) != std::string::npos)
               passN = strtol(words[1].c_str(),0,10);
            if(line.find("list of Segments",0) != std::string::npos)
               passN = strtol(words[1].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);
         }
         nWLslips = nWLslipGross + nWLslipSmall;
         nGFslips = nGFslipGross + nGFslipSmall;
      }  // end constructor/parser

      int passN,nGFslips,nWLslips,nGFslipGross,nGFslipSmall,nWLslipGross,nWLslipSmall;
      double WLsig,GFsig;
   }; // end class GDCreturn

   int DiscontinuityCorrector(SatPass& SP,
                              GDCconfiguration& config,
                              std::vector<std::string>& EditCmds,
                              std::string& retMsg)
      throw(Exception);


}  // end namespace gpstk

//------------------------------------------------------------------------------------
#endif

---