ExtractData.hpp

Go to the documentation of this file.

#pragma ident "$Id: ExtractData.hpp 1889 2009-05-11 15:47:23Z afarris $"

#ifndef ExtractData_GPSTK
#define ExtractData_GPSTK

//============================================================================
//
//  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. 2006
//
//============================================================================



#include "Exception.hpp"
#include "RinexObsHeader.hpp"
#include "RinexObsData.hpp"
#include "CheckPRData.hpp"
#include "Vector.hpp"


namespace gpstk
{
    NEW_EXCEPTION_CLASS(InvalidData, gpstk::Exception);




    class ExtractData
    {
    public:

        inline bool isValid(void)
            { return valid; }


        int numSV;


        Vector<SatID> availableSV;


        Vector<double> obsData;


        ExtractData() throw(InvalidData) : checkData(true), valid(false), minPRange(15000000.0), maxPRange(30000000.0) {};


        inline virtual int getData(const RinexObsData& rinexData, RinexObsHeader::RinexObsType typeObs) throw(InvalidData)
        {
        try {
            // Let's make sure each time we start with clean Vectors
            availableSV.resize(0);
            obsData.resize(0);

            // Create a CheckPRData object with the given limits
            CheckPRData checker(minPRange, maxPRange);

            // Let's define the "it" iterator to visit the observations PRN map
            // RinexSatMap is a map from SatID to RinexObsTypeMap: 
            //      std::map<SatID, RinexObsTypeMap>
            RinexObsData::RinexSatMap::const_iterator it;
            for (it = rinexData.obs.begin(); it!= rinexData.obs.end(); it++) 
            {
                // RinexObsTypeMap is a map from RinexObsType to RinexDatum:
                //   std::map<RinexObsHeader::RinexObsType, RinexDatum>
                RinexObsData::RinexObsTypeMap otmap;
                // Let's define a iterator to visit the observations type map
                RinexObsData::RinexObsTypeMap::const_iterator itObs1;
                // The "second" field of a RinexSatMap (it) is a RinexObsTypeMap (otmap)
                otmap = (*it).second;

                // Let's find the observation type inside the RinexObsTypeMap that is "otmap"
                itObs1 = otmap.find(typeObs);

                // Let's check if we found this type of observation and it is between the limits
                if ( (itObs1!=otmap.end()) && ( (checker.check((*itObs1).second.data)) || !(checkData) ) )
                {
                    // Store all relevant data of this epoch
                    availableSV = availableSV && (*it).first;
                    obsData = obsData && (*itObs1).second.data;
                }
            } // End of data extraction from this epoch
        }
        catch(...) {
            InvalidData e("Unable to get data from RinexObsData object");
            GPSTK_THROW(e);
        }

        // Let's record the number of SV with this type of data available
        numSV = (int)obsData.size();

        // If everything is fine so far, then the results should be valid
        valid = true;

        return numSV;

        };  // end ExtractData::getData()


        bool checkData;

        virtual void setMinPRange(const double minPR) { minPRange = minPR; };

        virtual double getMinPRange(void) { return minPRange; };

        virtual void setMaxPRange(const double maxPR) { maxPRange = maxPR; };

        virtual double getMaxPRange(void) { return maxPRange; };


        inline virtual ~ExtractData() {};


    protected:
        bool valid;

        double minPRange;

        double maxPRange;


   }; // end class ExtractData
   

   
}

#endif

---