OneFreqCSDetector.hpp

Go to the documentation of this file.

#pragma ident "$Id: OneFreqCSDetector.hpp 1310 2008-07-23 15:53:02Z architest $"

#ifndef ONEFREQCSDETECTOR_HPP
#define ONEFREQCSDETECTOR_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
//
//============================================================================



#include <deque>
#include "ProcessingClass.hpp"



namespace gpstk
{



   class OneFreqCSDetector : public ProcessingClass
   {
      public:

      OneFreqCSDetector()
         : codeType(TypeID::C1), phaseType(TypeID::L1), lliType(TypeID::LLI1),
           resultType(TypeID::CSL1), deltaTMax(31.0), maxWindowSize(60),
           maxNumSigmas(4.5), defaultBiasSigma(4.0)
      { setIndex(); };


      OneFreqCSDetector( const TypeID& codeT,
                         const double& dtMax = 31.0,
                         const int& mwSize = 60,
                         const double& mnSigmas = 4.5,
                         const double& dbSigma = 4.0 );


      virtual satTypeValueMap& Process( const DayTime& epoch,
                                        satTypeValueMap& gData,
                                        const short& epochflag = 0 )
         throw(ProcessingException);


      virtual OneFreqCSDetector& setCodeType(const TypeID& codeT)
      { codeType = codeT; return (*this); };


      virtual TypeID getCodeType() const
      { return codeType; };


      virtual OneFreqCSDetector& setPhaseType(const TypeID& phaseT)
      { phaseType = phaseT; return (*this); };


      virtual TypeID getPhaseType() const
      { return phaseType; };


      virtual OneFreqCSDetector& setLLIType(const TypeID& lliT)
      { lliType = lliT; return (*this); };


      virtual TypeID getLLIType() const
      { return lliType; };


      virtual OneFreqCSDetector& setResultType(const TypeID& resultT)
      { resultType = resultT; return (*this); };


      virtual TypeID getResultType() const
      { return resultType; };


      virtual OneFreqCSDetector& setDeltaTMax(const double& maxDelta)
      { deltaTMax = maxDelta; return (*this); };


      virtual double getDeltaTMax() const
      { return deltaTMax; };


      virtual OneFreqCSDetector& setMaxWindowSize(const int& maxSize);


      virtual int getMaxWindowSize() const
      { return maxWindowSize; };


      virtual OneFreqCSDetector& setMaxNumSigmas(const double& maxNSigmas)
      { maxNumSigmas = maxNSigmas; return (*this); };


      virtual double getMaxNumSigmas() const
      { return maxNumSigmas; };


      virtual OneFreqCSDetector& setDefaultBiasSigma(const double& defSigma)
      { defaultBiasSigma = defSigma; return (*this); };


      virtual double getDefaultBiasSigma() const
      { return defaultBiasSigma; };


      virtual gnssSatTypeValue& Process(gnssSatTypeValue& gData)
         throw(ProcessingException)
      { Process(gData.header.epoch, gData.body); return gData; };


      virtual gnssRinex& Process(gnssRinex& gData)
         throw(ProcessingException);


      virtual int getIndex(void) const;


      virtual std::string getClassName(void) const;


      virtual ~OneFreqCSDetector() {};


   private:


      TypeID codeType;


      TypeID phaseType;


      TypeID lliType;


      TypeID resultType;


      double deltaTMax;


      int maxWindowSize;


      double maxNumSigmas;


      double defaultBiasSigma;


      struct filterData
      {
            // Default constructor initializing the data in the structure
         filterData() : previousEpoch(DayTime::BEGINNING_OF_TIME),
                        windowSize(0), meanBias(0.0), variance(0.0)
         {};

         DayTime previousEpoch;  
         int windowSize;         
         double meanBias;        
         double variance;        

         std::deque<double> biasBuffer;   
         std::deque<double> dif2Buffer;   
      };


      std::map<SatID, filterData> OneFreqData;


      virtual double getDetection( const DayTime& epoch,
                                   const SatID& sat,
                                   typeValueMap& tvMap,
                                   const short& epochflag,
                                   const double& code,
                                   const double& phase );


      static int classIndex;


      int index;


      void setIndex(void)
      { index = classIndex++; };


   }; // End of class 'OneFreqCSDetector'


}
#endif   // ONEFREQCSDETECTOR_HPP

---