Rinex3ObsFileLoader.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_RINEX3_FILE_LOADER_INCLUDE
#define GNSSTK_RINEX3_FILE_LOADER_INCLUDE
 
//------------------------------------------------------------------------------------
// system includes
#include <string>
#include <vector>
 
// GNSSTk
#include "CommonTime.hpp"
#include "Exception.hpp"
#include "MostCommonValue.hpp"
#include "Rinex3ObsData.hpp"
#include "Rinex3ObsHeader.hpp"
#include "stl_helpers.hpp" // vectorindex
 
// gnsstk-geomatics
#include "SatPass.hpp"
 
namespace gnsstk
{
 
   //--------------------------------------------------------------------------------
   class Rinex3ObsFileLoader
   {
   private:
      static const double dttol; 
 
      // input
      std::vector<std::string> filenames; 
      int nepochsToRead;                  
      bool saveData;                      
      std::string timefmt;                
      // editing
      double dtdec;                       
      CommonTime startTime, stopTime;     
 
      std::vector<std::string> inputWantedObsTypes;
 
      std::vector<std::string> wantedObsTypes;
 
      std::map<RinexSatID, std::vector<int>> SatObsCountMap;
 
      std::vector<int> countWantedObsTypes;
 
      // used internally
      MostCommonValue mcv;       
      CommonTime prevtime;       
      double rawdt;              
      std::vector<SatID> exSats; 
 
      std::map<SatID, std::string> mapSatStr;
 
      // output
      int nepochs;      
      double nominalDT; 
      CommonTime begDataTime, endDataTime;  
      std::vector<std::string> obstypes;    
      std::vector<Rinex3ObsHeader> headers; 
 
      std::vector<Rinex3ObsData> datastore;
 
      void init()
      {
         saveData      = false;
         nepochsToRead = -1;
         timefmt       = std::string("%04Y/%02m/%02d %02H:%02M:%02S");
         reset();
      }
 
   public:
      // constructors
      // ------------------------------------------------------------
      Rinex3ObsFileLoader() { init(); }
 
      Rinex3ObsFileLoader(std::string in_filename)
      {
         init();
         filenames.clear();
         headers.clear();
         filenames.push_back(in_filename);
      }
 
      Rinex3ObsFileLoader(std::vector<std::string> in_filenames)
      {
         init();
         files(in_filenames);
      }
 
      // resets ------------------------------------------------------------
      inline void reset()
      {
         nepochs = 0;
         // nominalDT: nominal timestep (rawdt or dtdec)
         dtdec = rawdt = nominalDT = -1.0;
         stopTime = begDataTime = CommonTime::END_OF_TIME;
         startTime = endDataTime = CommonTime::BEGINNING_OF_TIME;
         prevtime                = CommonTime::BEGINNING_OF_TIME;
 
         begDataTime.setTimeSystem(TimeSystem::Any);
         endDataTime.setTimeSystem(TimeSystem::Any);
         startTime.setTimeSystem(TimeSystem::Any);
         stopTime.setTimeSystem(TimeSystem::Any);
         prevtime.setTimeSystem(TimeSystem::Any);
 
         obstypes.clear();
         mcv.reset();
         datastore.clear();
         exSats.clear();
         headers.clear();
         inputWantedObsTypes.clear();
         wantedObsTypes.clear();
         SatObsCountMap.clear();
      }
 
      inline void reset(std::vector<std::string> in_filenames)
      {
         reset();
         files(in_filenames);
      }
 
      // configure: before loadFiles() -------------------------------------
      // configure: files, epochs, save?, time limits, etc -----------------
 
      inline void files(std::vector<std::string> in_filenames)
      {
         filenames.clear();
         filenames = in_filenames;
      }
 
      inline bool loadObsID(std::string srot)
      {
         if (srot.size() != 4)
         {
            return false;
         }
 
         // NB isValidRinexObsID() does not handle system = "*"
         bool is3(srot.substr(0, 1) == "*");
 
         // valid Rinex obs ID
         if (isValidRinexObsID(is3 ? srot.substr(1, 3) : srot))
         {
            if (vectorindex(inputWantedObsTypes, srot) == -1)
            {
               inputWantedObsTypes.push_back(srot);
               return true;
            }
         }
         return false;
      }
 
      inline void nEpochsToRead(int n) { nepochsToRead = n; }
 
      inline void saveTheData(bool b) { saveData = b; }
 
      inline bool dataSaved() { return saveData; }
 
      inline void setStartTime(const CommonTime& tt) { startTime = tt; }
 
      inline void setStopTime(const CommonTime& tt) { stopTime = tt; }
 
      inline void setDecimation(double dt) { dtdec = dt; }
 
      inline void setTimeFormat(std::string fmt) { timefmt = fmt; }
 
      inline void excludeSat(SatID sat) { exSats.push_back(sat); }
 
      inline void excludeSats(std::vector<SatID> sats)
      {
         for (int i = 0; i < sats.size(); i++)
            excludeSat(sats[i]);
      }
 
      // access results: after loadFiles() ---------------------------------
 
      std::string asString();
 
      inline CommonTime getDataBeginTime() const { return begDataTime; }
 
      inline CommonTime getDataEndTime() const { return endDataTime; }
 
      inline std::vector<std::string> getWantedObsTypes() const
      {
         return wantedObsTypes;
      }
 
      inline std::map<RinexSatID, std::vector<int>>
      getWantedSatObsCountMap() const
      {
         return SatObsCountMap;
      }
      inline std::vector<int> getTotalObsCounts() const
      {
         return countWantedObsTypes;
      }
 
      inline double getDT() { return nominalDT; }
 
      inline Rinex3ObsHeader getFullHeader(unsigned int i) const
      {
         return headers[i];
      }
 
      inline const int getStoreSize() const { return datastore.size(); }
 
      inline const std::vector<Rinex3ObsData>& getStore() const
      {
         return datastore;
      }
 
      // Read the files ----------------------------------------------------
 
      int loadFiles(std::string& errmsg, std::string& msg);
 
      // Utilities ---------------------------------------------------------
 
      int
      WriteSatPassList(const std::map<char, std::vector<std::string>>& obstypes,
                       const std::map<char, std::vector<int>>& indexLoadOT,
                       std::vector<SatPass>& SPList);
 
      void dumpSatObsTable(std::ostream& s) const;
 
      void dumpStoreEpoch(std::ostream& s,
                          const gnsstk::Rinex3ObsData& rod) const;
 
      void dumpStoreData(std::ostream& s) const;
 
   }; // end class Rinex3ObsFileLoader
 
   void dumpAllRinex3ObsTypes(std::ostream& s);
 
 
} // end namespace gnsstk
 
#endif // GNSSTK_RINEX3_FILE_LOADER_INCLUDE