DataStructures.hpp

Go to the documentation of this file.

#pragma ident "$Id: DataStructures.hpp 2960 2011-11-02 05:01:16Z yanweignss $"

#ifndef GPSTK_DATASTRUCTURES_HPP
#define GPSTK_DATASTRUCTURES_HPP

//============================================================================
//
//  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
//
//  Dagoberto Salazar - gAGE ( http://www.gage.es ). 2007, 2008, 2009
//
//============================================================================


#include <utility>
#include <vector>
#include <set>
#include <map>
#include <string>

#include "DataHeaders.hpp"
#include "FFData.hpp"
#include "RinexObsStream.hpp"
#include "RinexObsData.hpp"
#include "StringUtils.hpp"
#include "Vector.hpp"
#include "Matrix.hpp"
#include "icd_200_constants.hpp"



namespace gpstk
{



      // First, we must declare some important exception objects


   NEW_EXCEPTION_CLASS(TypeIDNotFound, gpstk::Exception);


   NEW_EXCEPTION_CLASS(SatIDNotFound, gpstk::Exception);


   NEW_EXCEPTION_CLASS(SourceIDNotFound, gpstk::Exception);


   NEW_EXCEPTION_CLASS(DayTimeNotFound, gpstk::Exception);


   NEW_EXCEPTION_CLASS(ValueNotFound, gpstk::Exception);


   NEW_EXCEPTION_CLASS(NumberOfTypesMismatch, gpstk::Exception);


   NEW_EXCEPTION_CLASS(NumberOfSatsMismatch, gpstk::Exception);


      // Now, some useful type definitions

   typedef std::set<TypeID> TypeIDSet;

   typedef std::set<SatID> SatIDSet;

   typedef std::set<SourceID> SourceIDSet;


   struct typeValueMap : std::map<TypeID, double>
   {

      inline size_t numTypes() const
      { return (*this).size(); }


      TypeIDSet getTypeID() const;


      typeValueMap extractTypeID(const TypeID& type) const;


      typeValueMap extractTypeID(const TypeIDSet& typeSet) const;


      typeValueMap& keepOnlyTypeID(const TypeID& type);


      typeValueMap& keepOnlyTypeID(const TypeIDSet& typeSet);


      typeValueMap& removeTypeID(const TypeID& type)
      { (*this).erase(type); return (*this); }


      typeValueMap& removeTypeID(const TypeIDSet& typeSet);


      double getValue(const TypeID& type) const
         throw(TypeIDNotFound);


      double& operator()(const TypeID& type)
         throw(TypeIDNotFound);


      virtual ~typeValueMap() {};

    };  // End typeValueMap



   struct satValueMap : std::map<SatID, double>
   {

      size_t numSats() const
      { return (*this).size(); }


      SatIDSet getSatID() const;


      Vector<SatID> getVectorOfSatID() const;


      satValueMap extractSatID(const SatID& satellite) const;


      satValueMap extractSatID( const int& p,
                                const SatID::SatelliteSystem& s ) const;


      satValueMap extractSatID(const SatIDSet& satSet) const;


      satValueMap& keepOnlySatID(const SatID& satellite);


      satValueMap& keepOnlySatID( const int& p,
                                  const SatID::SatelliteSystem& s );


      satValueMap& keepOnlySatID(const SatIDSet& satSet);


      satValueMap& removeSatID(const SatID& satellite)
      { (*this).erase(satellite); return (*this); }


      satValueMap& removeSatID(const SatIDSet& satSet);


      double getValue(const SatID& satellite) const
         throw(SatIDNotFound);


      double& operator()(const SatID& satellite)
         throw(SatIDNotFound);


      virtual ~satValueMap() {};

   };  // End of 'satValueMap'



   struct satTypeValueMap : std::map<SatID, typeValueMap>
   {

      size_t numSats() const
      { return (*this).size(); }


      size_t numElements() const;


      SatIDSet getSatID() const;


      Vector<SatID> getVectorOfSatID() const;


      TypeIDSet getTypeID() const;


      satTypeValueMap extractSatID(const SatID& satellite) const;


      satTypeValueMap extractSatID( const int& p,
                                    const SatID::SatelliteSystem& s) const;


      satTypeValueMap extractSatID(const SatIDSet& satSet) const;


      satTypeValueMap& keepOnlySatID(const SatID& satellite);


      satTypeValueMap& keepOnlySatID( const int& p,
                                      const SatID::SatelliteSystem& s );


      satTypeValueMap& keepOnlySatID(const SatIDSet& satSet);


      satTypeValueMap extractTypeID(const TypeID& type) const;


      satTypeValueMap extractTypeID(const TypeIDSet& typeSet) const;


      satTypeValueMap& keepOnlyTypeID(const TypeID& type);


      satTypeValueMap& keepOnlyTypeID(const TypeIDSet& typeSet);


      satTypeValueMap& removeSatID(const SatID& satellite)
      { (*this).erase(satellite); return (*this); }


      satTypeValueMap& removeSatID(const SatIDSet& satSet);


      satTypeValueMap& removeTypeID(const TypeID& type);


      satTypeValueMap& removeTypeID(const TypeIDSet& typeSet);


      Vector<double> getVectorOfTypeID(const TypeID& type) const;


      Matrix<double> getMatrixOfTypes(const TypeIDSet& typeSet) const;


      satTypeValueMap& insertTypeIDVector( const TypeID& type,
                                           const Vector<double> dataVector )
         throw(NumberOfSatsMismatch);


      satTypeValueMap& insertMatrix( const TypeIDSet& typeSet,
                                     const Matrix<double> dataMatrix )
         throw(NumberOfSatsMismatch, NumberOfTypesMismatch);


      double getValue( const SatID& satellite,
                       const TypeID& type ) const
         throw( SatIDNotFound, TypeIDNotFound );


      typeValueMap& operator()(const SatID& satellite)
         throw(SatIDNotFound);


      virtual std::ostream& dump( std::ostream& s,
                                  int mode = 0) const;


      virtual ~satTypeValueMap() {};

   };  // End of 'satTypeValueMap'



   std::ostream& operator<<( std::ostream& s,
                             const satTypeValueMap& stvMap);



   typedef std::map<DayTime, satTypeValueMap>  epochSatTypeValueMap;

   typedef std::map<DayTime, satValueMap>      epochSatValueMap;

   typedef std::map<DayTime, typeValueMap>     epochTypeValueMap;




   template <class HEADER_CLASS, class BODY_CLASS>
   struct gnssData
   {

      HEADER_CLASS header;


      BODY_CLASS   body;



      gnssData() {}


      gnssData( const HEADER_CLASS& h,
                const BODY_CLASS& b )
      {
         header = h;
         body = b;
      }


      template<class H, class B>
      gnssData(const gnssData<H,B>& g)
      {
         header = g.header;
         body = g.body;
      }


      virtual ~gnssData() {};

   };  // End of 'gnssData'




      // Further type definitions

   struct  gnssSatValue : gnssData<sourceEpochTypeHeader, satValueMap>
   {


      size_t numSats() const
      { return body.numSats(); };


      SatIDSet getSatID() const
      { return (*this).body.getSatID(); }


      Vector<SatID> getVectorOfSatID() const
      { return body.getVectorOfSatID(); }


      gnssSatValue extractSatID(const SatID& satellite) const;


      gnssSatValue extractSatID( const int& p,
                                 const SatID::SatelliteSystem& s ) const;


      gnssSatValue extractSatID(const SatIDSet& satSet) const;


      gnssSatValue& keepOnlySatID(const SatID& satellite);


      gnssSatValue& keepOnlySatID( const int& p,
                                   const SatID::SatelliteSystem& s );


      gnssSatValue& keepOnlySatID(const SatIDSet& satSet);


      gnssSatValue& removeSatID(const SatID& satellite)
      { (*this).body.erase(satellite); return (*this); }


      gnssSatValue& removeSatID(const SatIDSet& satSet);


      double getValue(const SatID& satellite) const
         throw(SatIDNotFound)
      { return (*this).body.getValue(satellite); }


      double& operator()(const SatID& satellite)
         throw(SatIDNotFound)
      { return (*this).body(satellite); }


      virtual ~gnssSatValue() {};


   };  // End of 'gnssSatValue'




   struct  gnssTypeValue : gnssData<sourceEpochSatHeader, typeValueMap>
   {

      size_t numTypes() const
      { return body.numTypes(); };


      TypeIDSet getTypeID() const
      { return (*this).body.getTypeID(); }


      gnssTypeValue extractTypeID(const TypeID& type) const;


      gnssTypeValue extractTypeID(const TypeIDSet& typeSet) const;


      gnssTypeValue& keepOnlyTypeID(const TypeID& type);


      gnssTypeValue& keepOnlyTypeID(const TypeIDSet& typeSet);


      gnssTypeValue& removeTypeID(const TypeID& type)
      { (*this).body.erase(type); return (*this); }


      gnssTypeValue& removeTypeID(const TypeIDSet& typeSet);


      double getValue(const TypeID& type) const
         throw(TypeIDNotFound)
      { return (*this).body.getValue(type); }


      double& operator()(const TypeID& type)
         throw(TypeIDNotFound)
      { return (*this).body(type); }


      virtual ~gnssTypeValue() {};


   };  // End of 'gnssTypeValue'



   struct  gnssSatTypeValue : gnssData<sourceEpochHeader, satTypeValueMap>
   {

      size_t numSats() const
      { return body.numSats(); };


      TypeIDSet getTypeID() const
      { return (*this).body.getTypeID(); }


      SatIDSet getSatID() const
      { return (*this).body.getSatID(); }


      Vector<SatID> getVectorOfSatID() const
      { return (*this).body.getVectorOfSatID(); }


      size_t numElements() const
      { return body.numElements(); };


      gnssSatTypeValue extractSatID(const SatID& satellite) const;


      gnssSatTypeValue extractSatID( const int& p,
                                     const SatID::SatelliteSystem& s ) const;


      gnssSatTypeValue extractSatID(const SatIDSet& satSet) const;


      gnssSatTypeValue& keepOnlySatID(const SatID& satellite);


      gnssSatTypeValue& keepOnlySatID( const int& p,
                                       const SatID::SatelliteSystem& s );


      gnssSatTypeValue& keepOnlySatID(const SatIDSet& satSet);


      gnssSatTypeValue extractTypeID(const TypeID& type) const;


      gnssSatTypeValue extractTypeID(const TypeIDSet& typeSet) const;


      gnssSatTypeValue& keepOnlyTypeID(const TypeID& type);


      gnssSatTypeValue& keepOnlyTypeID(const TypeIDSet& typeSet);


      gnssSatTypeValue& removeSatID(const SatID& satellite)
      { (*this).body.erase(satellite); return (*this); }


      gnssSatTypeValue& removeSatID(const SatIDSet& satSet);


      gnssSatTypeValue& removeTypeID(const TypeID& type)
      { (*this).body.removeTypeID(type); return (*this); }


      gnssSatTypeValue& removeTypeID(const TypeIDSet& typeSet);


      Vector<double> getVectorOfTypeID(const TypeID& type) const
      { return ( (*this).body.getVectorOfTypeID(type) ); }


      gnssSatTypeValue& insertTypeIDVector( const TypeID& type,
                                            const Vector<double> dataVector )
         throw(NumberOfSatsMismatch)
      { (*this).body.insertTypeIDVector(type, dataVector); return (*this); }


      gnssSatTypeValue& insertMatrix( const TypeIDSet& typeSet,
                                      const Matrix<double> dataMatrix )
         throw(NumberOfSatsMismatch, NumberOfTypesMismatch)
      { (*this).body.insertMatrix(typeSet, dataMatrix); return (*this); }


      double getValue( const SatID& satellite,
                       const TypeID& type ) const
         throw( SatIDNotFound, TypeIDNotFound )
      { return (*this).body.getValue( satellite, type ); }


      typeValueMap& operator()(const SatID& satellite)
         throw(SatIDNotFound)
      { return (*this).body(satellite); }


      virtual ~gnssSatTypeValue() {};


   };  // End of 'gnssSatTypeValue'



   struct gnssRinex : gnssSatTypeValue
   {


      sourceEpochRinexHeader header;


      gnssRinex() {};


      gnssRinex(const gnssSatTypeValue& gds)
      { header = gds.header; body = gds.body; };


      gnssRinex extractSatID(const SatID& satellite) const;


      gnssRinex extractSatID( const int& p,
                              const SatID::SatelliteSystem& s ) const;


      gnssRinex extractSatID(const SatIDSet& satSet) const;


      gnssRinex& keepOnlySatID(const SatID& satellite);


      gnssRinex& keepOnlySatID( const int& p,
                                const SatID::SatelliteSystem& s );


      gnssRinex& keepOnlySatID(const SatIDSet& satSet);


      gnssRinex extractTypeID(const TypeID& type) const;


      gnssRinex extractTypeID(const TypeIDSet& typeSet) const;


      gnssRinex& keepOnlyTypeID(const TypeID& type);


      gnssRinex& keepOnlyTypeID(const TypeIDSet& typeSet);


      gnssRinex& keepOnlySatSystem(const SatID::SatelliteSystem satSys);



      virtual ~gnssRinex() {};


   };  // End of 'gnssRinex'





   struct sourceDataMap : std::map<SourceID, satTypeValueMap>
   {

      sourceDataMap() {};


      double getValue( const SourceID& source,
                       const SatID& satellite,
                       const TypeID& type ) const
         throw( SourceIDNotFound, SatIDNotFound, TypeIDNotFound );


      SourceIDSet getSourceIDSet( void ) const;


      SatIDSet getSatIDSet( void ) const;


      virtual ~sourceDataMap() {};


   };    // End of 'sourceDataMap'



   struct  gnssDataMap : std::multimap<DayTime, sourceDataMap>
   {

      gnssDataMap()
         : tolerance(0.1) {};


      gnssDataMap( double tol )
         : tolerance(tol) {};


      gnssDataMap& addGnssSatTypeValue( const gnssSatTypeValue& gds );


      gnssDataMap& addGnssRinex( const gnssRinex& gds );


      gnssRinex getGnssRinex( const SourceID& source ) const;


      gnssDataMap& addGnssDataMap( const gnssDataMap& gds );


      gnssDataMap front( void ) const;


      void pop_front( void );


      gnssDataMap frontEpoch( void ) const;


      void pop_front_epoch( void );


      gnssDataMap back( void ) const;


      void pop_back( void );


      gnssDataMap backEpoch( void ) const;


      void pop_back_epoch( void );


      gnssDataMap getDataFromEpoch( const DayTime& epoch ) const
         throw( DayTimeNotFound );


      double getValue( const DayTime& epoch,
                       const SourceID& source,
                       const SatID& satellite,
                       const TypeID& type ) const
         throw( DayTimeNotFound, ValueNotFound );


      double getValue( const SourceID& source,
                       const SatID& satellite,
                       const TypeID& type ) const
         throw( ValueNotFound );


      gnssDataMap& insertValue( const DayTime& epoch,
                                const SourceID& source,
                                const SatID& satellite,
                                const TypeID& type,
                                double value )
         throw( DayTimeNotFound, ValueNotFound );


      gnssDataMap& insertValue( const SourceID& source,
                                const SatID& satellite,
                                const TypeID& type,
                                double value )
         throw( ValueNotFound );


      SourceIDSet getSourceIDSet( void ) const;


      SatIDSet getSatIDSet( void ) const;


      double getTolerance( void ) const
      { return tolerance; };


      gnssDataMap& setTolerance( double tol )
      { tolerance = std::abs(tol); return (*this); };


      virtual std::ostream& dump( std::ostream& s,
                                  int mode = 0) const;

         
      gnssDataMap extractSourceID(const SourceID& source);
         

      gnssDataMap extractSourceID(const SourceIDSet& sourceSet);


      gnssDataMap& keepOnlySourceID(const SourceID& source);


      gnssDataMap& keepOnlySourceID(const SourceIDSet& sourceSet);


      gnssDataMap& removeSourceID(const SourceID& source);


      gnssDataMap& removeSourceID(const SourceIDSet& sourceSet);


      gnssDataMap extractSatID(const SatID& sat);


      gnssDataMap extractSatID(const SatIDSet& satSet);


      gnssDataMap& keepOnlySatID(const SatID& sat);


      gnssDataMap& keepOnlySatID(const SatIDSet& satSet);


      gnssDataMap& removeSatID(const SatID& sat);


      gnssDataMap& removeSatID(const SatIDSet& satSet);


      gnssDataMap extractTypeID(const TypeID& type);


      gnssDataMap extractTypeID(const TypeIDSet& typeSet);


      gnssDataMap& keepOnlyTypeID(const TypeID& type);


      gnssDataMap& keepOnlyTypeID(const TypeIDSet& typeSet);


      gnssDataMap& removeTypeID(const TypeID& type);


      gnssDataMap& removeTypeID(const TypeIDSet& typeSet);


      virtual gnssDataMap& edit(DayTime tmin, 
                                DayTime tmax = DayTime(DayTime::END_OF_TIME));

      void loadObsFile(std::string obsFile);


      double tolerance;


      virtual ~gnssDataMap() {};


   };    // End of 'gnssDataMap'



   std::ostream& operator<<( std::ostream& s,
                             const gnssDataMap& gdsMap);



   struct  gnssEquationDefinition : gnssData<TypeID, TypeIDSet>
   {

      gnssEquationDefinition() {};


      gnssEquationDefinition( const TypeID& h,
                              const TypeIDSet& b )
      {
         header = h;
         body   = b;
      }


      virtual ~gnssEquationDefinition() {};


   };  // End of 'gnssEquationDefinition'



   struct  gnssLinearCombination : gnssData<TypeID, typeValueMap>
   {

      gnssLinearCombination() {};


      gnssLinearCombination( const TypeID& h,
                             const typeValueMap& b )
      {
         header = h;
         body   = b;
      }


      virtual ~gnssLinearCombination() {};


   };  // End of 'gnssLinearCombination'


   typedef std::list<gnssLinearCombination> LinearCombList;



   std::istream& operator>>( std::istream& i,
                             gnssSatTypeValue& f )
      throw(FFStreamError, gpstk::StringUtils::StringException);


   gnssSatTypeValue& operator>>( const RinexObsHeader& roh,
                                 gnssSatTypeValue& f );


   gnssSatTypeValue& operator>>( const RinexObsData& rod,
                                 gnssSatTypeValue& f );


   gnssRinex& operator>>( const RinexObsHeader& roh,
                          gnssRinex& f );


   gnssRinex& operator>>( const RinexObsData& rod,
                          gnssRinex& f );


   SourceID::SourceType SatIDsystem2SourceIDtype(const SatID& sid);


   typeValueMap FilltypeValueMapwithRinexObsTypeMap(
                                 const RinexObsData::RinexObsTypeMap& otmap );


   satTypeValueMap FillsatTypeValueMapwithRinexObsData(
                                                   const RinexObsData& rod );


   std::istream& operator>>( std::istream& i,
                             gnssRinex& f )
      throw(FFStreamError, gpstk::StringUtils::StringException);


   std::ostream& operator<<( std::ostream& s,
                             gnssRinex& f )
      throw(FFStreamError, gpstk::StringUtils::StringException);


   DayTime parseTime( const std::string& line,
                      const RinexObsHeader& hdr )
      throw(FFStreamError);



}  // End of namespace gpstk

#endif // GPSTK_DATASTRUCTURES_HPP

---