SatPass.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_SATELLITE_PASS_INCLUDE
#define GNSSTK_SATELLITE_PASS_INCLUDE
 
#include <map>
#include <ostream>
#include <string>
#include <vector>
 
#include "gnsstk_export.h"
#include "Epoch.hpp"
#include "TimeString.hpp"
#include "Exception.hpp"
#include "GNSSconstants.hpp"
#include "RinexObsData.hpp"
#include "RinexObsHeader.hpp"
#include "RinexSatID.hpp"
#include "RinexUtilities.hpp"
 
namespace gnsstk
{
 
   class SatPass
   {
   protected:
      // --------------- SatPassData data structure for internal use only
      struct SatPassData
      {
         // member data ----------------------------------
         unsigned short flag;
 
         unsigned int userflag;
 
         unsigned int ndt;
 
         double toffset;
 
         std::vector<double> data;
 
         std::vector<unsigned short> lli, ssi;
 
         // private member functions ---------------------
 
         SatPassData(unsigned short n = 4)
            : flag(SatPass::OK), userflag(0), ndt(0), toffset(0.0)
         {
            data = std::vector<double>(n, 0.0);
            lli  = std::vector<unsigned short>(n, 0);
            ssi  = std::vector<unsigned short>(n, 0);
         }
 
         // d'tor, copy c'tor and operator= are built by compiler,
         // but operator= will not work correctly, b/c a deep copy is needed.
         SatPassData& operator=(const SatPassData& right)
         {
            if (&right != this)
            {
               flag     = right.flag;
               userflag = right.userflag;
               ndt      = right.ndt;
               toffset  = right.toffset;
               data.resize(right.data.size());
               lli.resize(right.lli.size());
               ssi.resize(right.ssi.size());
               int i;
               for (i = 0; i < right.data.size(); i++)
                  data[i] = right.data[i];
               for (i = 0; i < right.lli.size(); i++)
                  lli[i] = right.lli[i];
               for (i = 0; i < right.ssi.size(); i++)
                  ssi[i] = right.ssi[i];
            }
 
            return *this;
         }
      }; // end struct SatPassData
 
      // --------------- private member data -----------------------------
      int Status;
 
      double dt;
 
      RinexSatID sat;
 
      std::map<std::string, unsigned int> indexForLabel;
      std::map<unsigned int, std::string> labelForIndex;
 
      // above determined at construction; the rest determined by input data
 
      Epoch firstTime, lastTime;
 
      unsigned int ngood;
 
      std::vector<SatPassData> spdvector;
 
      // --------------- private member functions ------------------------
 
      void init(const RinexSatID& sat, double dt,
                std::vector<std::string> obstypes);
 
      int pushBack(const Epoch tt, SatPassData& spd);
 
      struct SatPassData getData(unsigned int i) const;
 
   public:
      // ------------------ friends --------------------------------------
      friend class gdc;
 
      friend class SatPassIterator;
 
      friend int SatPassFromRinexFiles(std::vector<std::string>& filenames,
                                       std::vector<std::string>& obstypes,
                                       double dt, std::vector<SatPass>& SPList,
                                       std::vector<RinexSatID> exSats,
                                       bool lenient, Epoch beginTime,
                                       Epoch endTime);
 
      // ------------------ configuration --------------------------------
      SatPass(const RinexSatID& sat, double dt);
 
      SatPass(const RinexSatID& sat, double dt,
              std::vector<std::string> obstypes);
 
      SatPass& operator=(const SatPass& right);
 
      // Add data to the arrays at timetag tt; calls must be made in time order.
      // Caller sets the flag to either BAD or OK later using flag().
 
      int addData(const Epoch& tt, std::vector<std::string>& obstypes,
                  std::vector<double>& data);
 
      int addData(const Epoch& tt, const std::vector<std::string>& obstypes,
                  const std::vector<double>& data,
                  const std::vector<unsigned short>& lli,
                  const std::vector<unsigned short>& ssi,
                  const unsigned short flag = SatPass::OK);
 
      int addData(const RinexObsData& robs);
 
      // -------------------------- get and set routines
      // -------------------------- can change ssi, lli, data, but not
      // times,sat,dt,ngood,count get and set flag so you can update ngood
      // lvalue for the data or SSI/LLI arrays of this SatPass at index i
 
      int& status() { return Status; }
 
      int getStatus() const { return Status; }
 
      double& data(unsigned int i, const std::string& type);
 
      double& timeoffset(unsigned int i);
 
      unsigned short& LLI(unsigned int i, const std::string& type);
 
      unsigned short& SSI(unsigned int i, const std::string& type);
 
      // -------------------------------- set only
      // --------------------------------
      static double setMaxGap(double gap)
      {
         maxGap = gap;
         return maxGap;
      }
 
      void setOutputFormat(std::string fmt, int round = 3)
      {
         outFormat = fmt;
         outRound  = round;
      }
 
      std::string getOutputFormat() { return outFormat; }
 
      void setFlag(unsigned int i, unsigned short flag);
 
      void setUserFlag(unsigned int i, unsigned int inflag);
 
      // -------------------------------- get only
      // --------------------------------
      double getMaxGap() const { return maxGap; }
 
      std::vector<std::string> getObsTypes()
      {
         std::vector<std::string> v;
         for (int i = 0; i < labelForIndex.size(); i++)
            v.push_back(labelForIndex[i]);
         return v;
      }
 
      unsigned short getFlag(unsigned int i) const;
 
      unsigned int getUserFlag(unsigned int i) const;
 
      Epoch getFirstTime() const;
 
      Epoch getLastTime() const;
 
      Epoch getFirstGoodTime() const
      {
         for (int j = 0; j < spdvector.size(); j++)
            if (spdvector[j].flag & OK)
            {
               return time(j);
            }
         return CommonTime::END_OF_TIME;
      }
 
      Epoch getLastGoodTime() const
      {
         for (int j = spdvector.size() - 1; j >= 0; j--)
            if (spdvector[j].flag & OK)
            {
               return time(j);
            }
         return CommonTime::BEGINNING_OF_TIME;
      }
 
      RinexSatID getSat() const { return sat; }
 
      double getDT() const { return dt; }
 
      int getNgood() const { return ngood; }
 
      unsigned int size() const { return spdvector.size(); }
 
      unsigned int getCount(unsigned int i) const;
 
      double data(unsigned int i, const std::string& type1, const std::string& type2) const;
 
      unsigned short LLI(unsigned int i, const std::string& type1, const std::string& type2);
 
      unsigned short SSI(unsigned int i, const std::string& type1, const std::string& type2);
 
      inline bool hasType(std::string type) const
      {
         return (indexForLabel.find(type) != indexForLabel.end());
      }
 
      std::vector<std::string> getObstypes()
      {
         std::vector<std::string> ots;
         for (int i = 0; i < labelForIndex.size(); i++)
            ots.push_back(labelForIndex[i]);
         return ots;
      }
 
      // -------------------------------- utils
      // ---------------------------------
      void clear() { spdvector.clear(); }
 
      Epoch time(unsigned int i) const;
 
      int index(const Epoch& tt) const
      {
         int count = countForTime(tt);
         if (count < 0)
         {
            return -1;
         }
         for (int i = 0; i < spdvector.size(); i++)
            if (count == spdvector[i].ndt)
            {
               return i;
            }
         return -1;
      }
 
      void renameObstypes(std::map<std::string, std::string>& subst)
      {
         unsigned int i;
         std::map<std::string, std::string>::const_iterator it = subst.begin();
         std::map<unsigned int, std::string>::iterator jt;
         while (it != subst.end())
         {
            if (indexForLabel.find(it->first) == indexForLabel.end())
            {
               continue;
            }
 
            i = indexForLabel[it->first];
            indexForLabel.insert(
               std::map<std::string, unsigned int>::value_type(it->second, i));
            indexForLabel.erase(it->first);
 
            for (jt = labelForIndex.begin(); jt != labelForIndex.end(); ++jt)
            {
               if (jt->second != it->first)
               {
                  continue;
               }
               i = jt->first;
               labelForIndex.erase(i);
               labelForIndex.insert(
                  std::map<unsigned int, std::string>::value_type(i,
                                                                  it->second));
            }
 
            ++it;
         }
      }
 
      // sorting ----------------------------------------------------------
      bool operator<(const SatPass& right) const
      {
         if (firstTime == right.firstTime)
         {
            return (sat < right.sat);
         }
         return firstTime < right.firstTime;
      }
 
      // edit -------------------------------------------------------------
      bool includesTime(const Epoch& tt) const;
 
      int trimAfter(const Epoch ttag);
 
      bool split(int N, SatPass& newSP);
 
      void decimate(const int N, Epoch refTime = CommonTime::BEGINNING_OF_TIME);
 
      // compare ----------------------------------------------------------
      bool hasOverlap(const SatPass& that, double *pdelt = NULL,
                      Epoch *pttb = NULL, Epoch *ptte = NULL);
 
      bool hasCommonView(const SatPass& that, double *pdelt = NULL,
                         Epoch *pttb = NULL, Epoch *ptte = NULL)
      {
         if (sat != that.sat)
         {
            return false;
         }
         return hasOverlap(that, pdelt, pttb, ptte);
      }
 
      // analysis - also see SatPassUtilities -----------------------------
      bool getGLOchannel(int& n, std::string& msg);
 
      void smooth(bool smoothPR, bool smoothPH, std::string& msg,
                  const double& wl1 = L1_WAVELENGTH_GPS,
                  const double& wl2 = L2_WAVELENGTH_GPS);
 
      void smoothSF(bool smoothPR, bool smoothPH, std::string& msg,
                    const int freq, double wl);
 
      // output -----------------------------------------------------------
      std::string
      toString(std::string msg = "",
               std::string fmt =
                  "%04Y/%02m/%02d %02H:%02M:%06.3f = %04F %w %10.3g")
      {
         std::ostringstream os;
         os << msg << " " << sat << " N " << std::setw(4) << size() << " good "
            << std::setw(4) << ngood << " times "
            << printTime(getFirstTime(), fmt) << " to "
            << printTime(getLastTime(), fmt) << " obs:";
         std::vector<std::string> ots = getObstypes();
         for (int i = 0; i < ots.size(); i++)
            os << " " << ots[i];
         return os.str();
      }
      void dump(std::ostream& os, const std::string& msg1,
                const std::string& msg2 = std::string());
 
      friend std::ostream& operator<<(std::ostream& os, SatPass& sp);
 
      // public member data -----------------------------------------------
      GNSSTK_EXPORT
      static const unsigned short BAD;
 
      GNSSTK_EXPORT
      static const unsigned short OK;
 
      GNSSTK_EXPORT
      static const unsigned short LL1;
 
      GNSSTK_EXPORT
      static const unsigned short LL2;
 
      GNSSTK_EXPORT
      static const unsigned short LL3;
 
      GNSSTK_EXPORT 
      static double maxGap;
 
      GNSSTK_EXPORT
      static int outRound;
      GNSSTK_EXPORT
      static std::string outFormat;
      GNSSTK_EXPORT
      static std::string longfmt;
 
   protected:
      int countForTime(const Epoch& tt) const
      {
         return int((tt - firstTime) / dt + 0.5);
      }
 
   }; // end class SatPass
 
   std::ostream& operator<<(std::ostream& os, gnsstk::SatPass& sp);
 
} // end namespace gnsstk
 
// -----------------------------------------------------------------------------------
#endif // GNSSTK_SATELLITE_PASS_INCLUDE