PCSmoother.hpp

Go to the documentation of this file.

#pragma ident "$Id: PCSmoother.hpp 1311 2008-07-23 19:32:36Z architest $"

#ifndef PCSMOOTHER_HPP
#define PCSMOOTHER_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 "CodeSmoother.hpp"


namespace gpstk
{



   class PCSmoother : public CodeSmoother
   {
   public:

      PCSmoother() : codeType(TypeID::PC), phaseType(TypeID::LC),
         resultType(TypeID::PC), maxWindowSize(100), csFlag1(TypeID::CSL1),
         csFlag2(TypeID::CSL2)
      { setIndex(); };


      PCSmoother( const int& mwSize,
                  const TypeID& resultT = TypeID::PC )
         : codeType(TypeID::PC), phaseType(TypeID::LC), resultType(resultT),
           maxWindowSize(mwSize), csFlag1(TypeID::CSL1), csFlag2(TypeID::CSL2)
      { setIndex(); };


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


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


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


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


      virtual PCSmoother& setMaxWindowSize(const int& maxSize);


      virtual TypeID getCSFlag1() const
      { return csFlag1; };


      virtual PCSmoother& setCSFlag1(const TypeID& csT)
      { csFlag1 = csT; return (*this); };


      virtual TypeID getCSFlag2() const
      { return csFlag2; };


      virtual PCSmoother& setCSFlag2(const TypeID& csT)
      { csFlag2 = csT; return (*this); };


      virtual int getIndex(void) const;


      virtual std::string getClassName(void) const;


      virtual ~PCSmoother() {};


    private:


      TypeID codeType;


      TypeID phaseType;


      TypeID resultType;


      int maxWindowSize;


      TypeID csFlag1;


      TypeID csFlag2;


      struct filterData
      {
            // Default constructor initializing the data in the structure
         filterData() : windowSize(1), previousCode(0.0), previousPhase(0.0) {};

         int windowSize;       
         double previousCode;  
         double previousPhase; 
      };


      std::map<SatID, filterData> SmoothingData;


      virtual double getSmoothing( const SatID& sat,
                                   const double& code,
                                   const double& phase,
                                   const double& flag1,
                                   const double& flag2 );


      virtual PCSmoother& setCodeType(const TypeID& dummy)
      { return (*this); };

      virtual PCSmoother& setPhaseType(const TypeID& dummy)
      { return (*this); };

      virtual PCSmoother& setCSFlag(const TypeID& dummy)
      { return (*this); };

      virtual TypeID getCSFlag() const
      { return TypeID::Unknown; };


      static int classIndex;


      int index;


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



   }; // End of class 'PCSmoother'


}
#endif   // PCSMOOTHER_HPP

---