SatPass.hpp

Go to the documentation of this file.

#pragma ident "$Id: SatPass.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_SATELLITE_PASS_INCLUDE
#define GPSTK_SATELLITE_PASS_INCLUDE

#include <vector>
#include <map>

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

namespace gpstk {

class SatPass {
public:
   // ------------------ configuration --------------------------------

   // public member functions -----------------------------------------

   SatPass(GSatID sat, double dt) throw();

   SatPass(GSatID sat, double dt, std::vector<std::string> obstypes) throw();

   // d'tor, copy c'tor are built by compiler; so is operator= but don't use it!
   SatPass& operator=(const SatPass& right) throw();

   // 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 DayTime tt, std::vector<std::string>& obstypes,
                                  std::vector<double>& data) throw(Exception);

   int addData(const DayTime tt, std::vector<std::string>& obstypes,
                                  std::vector<double>& data,
                                  std::vector<unsigned short>& lli,
                                  std::vector<unsigned short>& ssi,
                                  unsigned short flag=SatPass::OK)
      throw(Exception);

   int addData(const RinexObsData& robs) throw();

   void smooth(bool smoothPR, bool smoothPH, std::string& msg) throw(Exception);

   // -------------------------- 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(void) throw() { return Status; }

   double& data(unsigned int i, std::string type) throw(Exception);

   double& timeoffset(unsigned int i) throw(Exception);

   unsigned short& LLI(unsigned int i, std::string type) throw(Exception);

   unsigned short& SSI(unsigned int i, std::string type) throw(Exception);

   // -------------------------------- set routines ----------------------------

   static double setMaxGap(const double gap) { maxGap = gap; return maxGap; }

   void setOutputFormat(std::string fmt) { outFormat = fmt; };

   void setFlag(unsigned int i, unsigned short flag) throw(Exception);

   // -------------------------------- get routines ----------------------------

   double getMaxGap(void) const throw() { return maxGap; }

   std::vector<std::string> getObsTypes(void) throw() {
      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) throw(Exception);

   DayTime getFirstTime(void) const throw() { return firstTime; }
   
   //void resetFirstTime(DayTime& tt) throw()
   //   { firstTime = tt; }
   //void resetLastTime(DayTime& tt) throw()
   //   { lastTime = tt; }

   DayTime getLastTime(void) const throw() { return lastTime; }

   DayTime getFirstGoodTime(void) const throw() {
      for(int j=0; j<spdvector.size(); j++) if(spdvector[j].flag & OK) {
         return time(j);
      }
      return DayTime::END_OF_TIME;
   }

   DayTime getLastGoodTime(void) const throw() {
      for(int j=spdvector.size()-1; j>=0; j--) if(spdvector[j].flag & OK) {
         return time(j);
      }
      return DayTime::BEGINNING_OF_TIME;
   }

   GSatID getSat(void) const throw() { return sat; }

   double getDT(void) const throw() { return dt; }

   int getNgood(void) const throw() { return ngood; }

   unsigned int size(void) const throw() { return spdvector.size(); }

   unsigned int getCount(unsigned int i) const throw(Exception);

   // -------------------------------- utils ---------------------------------

   void clear(void) throw() { spdvector.clear(); }

   DayTime time(unsigned int i) const throw(Exception);

   bool includesTime(const DayTime& tt) const throw();

   bool split(int N, SatPass &newSP);

   void decimate(const int N, DayTime refTime=DayTime::BEGINNING_OF_TIME)
      throw(Exception);

   void dump(std::ostream& os, std::string msg1, std::string msg2=std::string())
      throw();

   bool operator<(const SatPass& right) const
      { return firstTime < right.firstTime; }

   // other ---------------------------------------------------------

   friend std::ostream& operator<<(std::ostream& os, SatPass& sp);

   // public member data -----------------------------------------------

   static const unsigned short BAD;

   static const unsigned short OK;

   static const unsigned short LL1;

   static const unsigned short LL2;

   static const unsigned short LL3;

   static double maxGap;

   static std::string outFormat;

protected:
   int countForTime(const DayTime& tt) const throw(Exception)
      { return int((tt-firstTime)/dt + 0.5); }

   // --------------- SatPassData data structure for internal use only ----------
   //
   struct SatPassData {

      // ---------------------- member data ----------------------------------

      unsigned short flag;
      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), 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) throw()
      {
         if(&right != this) {
            flag = right.flag;
            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;

   GSatID 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

   DayTime firstTime,lastTime;

   unsigned int ngood;

   std::vector<SatPassData> spdvector;

   // --------------- private member functions ------------------------

   void init(GSatID sat, double dt, std::vector<std::string> obstypes) throw();

   int push_back(const DayTime tt, SatPassData& spd) throw();

   struct SatPassData getData(unsigned int i) const throw(Exception);

   // --------------- friend functions --------------------------------

   friend void sort(std::vector<SatPass>& SPList) throw();

   friend int SatPassFromRinexFiles(std::vector<std::string>& filenames,
                                    std::vector<std::string>& obstypes,
                                    double dt,
                                    std::vector<SatPass>& SPList,
               gpstk::DayTime beginTime=gpstk::DayTime::BEGINNING_OF_TIME,
               gpstk::DayTime endTime=gpstk::DayTime::END_OF_TIME)
      throw(Exception);

   friend int SatPassToRinexFile(std::string filename,
                                 RinexObsHeader& header,
                                 std::vector<SatPass>& SPList)
      throw(Exception);

   friend class SatPassIterator;

}; // end class SatPass


class SatPassIterator {
public:
   explicit SatPassIterator(std::vector<SatPass>& splist) throw(Exception);

   int next(std::map<unsigned int, unsigned int>& indexMap) throw(Exception);

   int next(RinexObsData& robs) throw(Exception);

   void reset(void) throw();

   DayTime getFirstTime(void) throw() { return FirstTime; }

   DayTime getLastTime(void) throw() { return LastTime; }

   DayTime getFirstGoodTime(void) const throw() {
      DayTime ttag = LastTime;
      for(int i=0; i<SPList.size(); i++)
         if(SPList[i].getFirstGoodTime() < ttag)
            ttag = SPList[i].getFirstGoodTime();
      return ttag;
   }

   DayTime getLastGoodTime(void) const throw() {
      DayTime ttag = FirstTime;
      for(int i=0; i<SPList.size(); i++)
         if(SPList[i].getLastGoodTime() > ttag)
            ttag = SPList[i].getLastGoodTime();
      return ttag;
   }

   double getDT(void) throw() { return DT; }

   std::map<unsigned int,unsigned int> getIndexes(void) throw()
      { return nextIndexMap; }

private:
   SatPassIterator(const SatPassIterator&);              // DO NOT implement
   SatPassIterator& operator=(const SatPassIterator&);   // DO NOT implement

   int currentN;                    // current time = FirstTime + currentN*DT

   double DT;

   DayTime FirstTime,LastTime;

   std::map<GSatID,int> listIndex;

   std::map<GSatID,int> dataIndex;

   std::map<GSatID,int> countOffset;

   std::vector<int> indexStatus;

   std::vector<SatPass>& SPList;

   std::map<unsigned int,unsigned int> nextIndexMap;

}; // end class SatPassIterator

std::ostream& operator<<(std::ostream& os, gpstk::SatPass& sp);

}  // end namespace gpstk

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

---