SP3NavDataFactory.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_SP3NAVDATAFACTORY_HPP
#define GNSSTK_SP3NAVDATAFACTORY_HPP
 
#include "NavDataFactoryWithStoreFile.hpp"
#include "SP3Data.hpp"
#include "SP3Header.hpp"
#include "gnsstk_export.h"
 
namespace gnsstk
{
 
 
   class SP3NavDataFactory : public NavDataFactoryWithStoreFile
   {
   public:
      enum class ClkInterpType
      {
         Linear,
         Lagrange
      };
      GNSSTK_EXPORT static const ObsID oidGPS, oidGalileo, oidQZSS, oidGLONASS,
         oidBeiDou;
      GNSSTK_EXPORT static const NavType ntGPS, ntGalileo, ntQZSS, ntGLONASS,
         ntBeiDou;
 
      SP3NavDataFactory();
 
      virtual ~SP3NavDataFactory()
      {
      }
 
      bool find(const NavMessageID& nmid, const CommonTime& when,
                NavDataPtr& navOut, SVHealth xmitHealth, NavValidityType valid,
                NavSearchOrder order) override;
 
      bool process(const std::string& filename,
                   NavDataFactoryCallback& cb) override;
 
      bool addDataSource(const std::string& source) override;
 
      std::string getFactoryFormats() const override;
 
      static bool convertToOrbit(const SP3Header& head, const SP3Data& navIn,
                                 bool isC, NavDataPtr& navOut);
 
      static bool convertToClock(const SP3Header& head, const SP3Data& navIn,
                                 bool isC, NavDataPtr& clkOut);
 
      static bool transNavMsgID(const NavMessageID& nmidIn,
                                NavMessageID& nmidOut);
 
      void clearClock()
      { data.erase(NavMessageType::Clock); }
 
      void useRinexClockData(bool useRC = true);
 
      TimeSystem getTimeSystem() const
      { return storeTimeSystem; }
 
      bool isPosDataGapCheck()
      { return checkDataGapPos; }
 
      void disableDataGapCheck()
      { checkDataGapPos = checkDataGapClk = false; }
 
      void disablePosDataGapCheck()
      { checkDataGapPos = false; }
 
      double getPosGapInterval() const
      { return gapIntervalPos; }
 
      void setPosGapInterval(double interval)
      { checkDataGapPos = true; gapIntervalPos = interval; }
 
      bool isClkDataGapCheck()
      { return checkDataGapClk; }
 
      void disableClkDataGapCheck()
      { checkDataGapClk = false; }
 
      double getClkGapInterval() const
      { return gapIntervalClk; }
 
      void setClkGapInterval(double interval)
      { checkDataGapClk = true; gapIntervalClk = interval; }
 
      bool isPosIntervalCheck()
      { return checkIntervalPos; }
 
      bool isClkIntervalCheck()
      { return checkIntervalClk; }
 
      void disableIntervalCheck()
      { checkIntervalPos = checkIntervalClk = false; }
 
      void disablePosIntervalCheck()
      { checkIntervalPos = false; }
 
      void disableClockIntervalCheck()
      { checkIntervalClk = false; }
 
      double getPosMaxInterval() const
      { return maxIntervalPos; }
 
      double getClockMaxInterval() const
      { return maxIntervalClk; }
 
      void setPosMaxInterval(double interval)
      { checkIntervalPos = true; maxIntervalPos = interval; }
 
      void setClockMaxInterval(double interval)
      { checkIntervalClk = true; maxIntervalClk = interval; }
 
      void rejectBadPositions(bool flag)
      { rejectBadPosFlag = flag; }
 
      void rejectBadClocks(bool flag)
      { rejectBadClockFlag = flag; }
 
      void rejectPredPositions(bool flag)
      { rejectPredPosFlag = flag; }
 
      void rejectPredClocks(bool flag)
      { rejectPredClockFlag = flag; }
 
      double getPositionTimeStep(const SatID& sat) const;
 
      double getClockTimeStep(const SatID& sat) const;
 
      unsigned int getPositionInterpOrder() const
      { return 2*halfOrderPos; }
 
      void setPositionInterpOrder(unsigned int order)
      { halfOrderPos = (order+1)/2; }
 
      unsigned int getClockInterpOrder() const
      { return 2*halfOrderClk; }
 
      void setClockInterpOrder(unsigned int order);
 
      void setClockLagrangeInterp();
 
      void setClockLinearInterp();
 
      void dumpConfig(std::ostream& s) const;
 
   private:
      bool addRinexClock(const std::string& source, NavDataFactoryCallback& cb);
      
      bool store(bool process, NavDataFactoryCallback& cb, NavDataPtr& obj);
 
      bool findGeneric(NavMessageType nmt, const NavSatelliteID& nsid,
                       const CommonTime& when, NavDataPtr& navData);
 
      bool findIterator(NavSatMap::iterator& sati,
                        const CommonTime& when, NavDataPtr& navData,
                        unsigned halfOrder, bool findEph,
                        bool checkDataGap, bool checkInterval,
                        double gapInterval, double maxInterval);
 
      void interpolateEph(const NavMap::iterator& ti1,
                          const NavMap::iterator& ti3,
                          const CommonTime& when, NavDataPtr& navData);
 
      void interpolateClk(const NavMap::iterator& ti1,
                          const NavMap::iterator& ti3,
                          const CommonTime& when, NavDataPtr& navData);
 
      bool loadIntoMap(const std::string& filename,
                       NavMessageMap& navMap,
                       NavNearMessageMap& navNearMap,
                       OffsetCvtMap& ofsMap) override
      { return false; }
 
      static bool setSignal(const SatID& sat, NavMessageID& signal);
 
      double nomTimeStep(const NavMessageID& nmid) const;
 
      TimeSystem storeTimeSystem;
 
      bool checkDataGapPos;
 
      double gapIntervalPos;
 
      bool checkDataGapClk;
 
      double gapIntervalClk;
 
      bool checkIntervalPos;
 
      double maxIntervalPos;
 
      bool checkIntervalClk;
 
      double maxIntervalClk;
 
      unsigned halfOrderPos;
 
      unsigned halfOrderClk;
 
      bool useSP3clock;
 
      bool rejectBadPosFlag;
 
      bool rejectBadClockFlag;
 
      bool rejectPredPosFlag;
 
      bool rejectPredClockFlag;
 
      ClkInterpType interpType;
   };
 
 
}
 
#endif // GNSSTK_SP3NAVDATAFACTORY_HPP