PRSolution.hpp

Go to the documentation of this file.

#pragma ident "$Id: PRSolution.hpp 1180 2008-04-04 13:51:59Z btolman $"

#ifndef PRS_POSITION_SOLUTION_HPP
#define PRS_POSITION_SOLUTION_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
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

#include <vector>
#include <ostream>
#include "icd_200_constants.hpp"
#include "DayTime.hpp"
#include "SatID.hpp"
#include "Matrix.hpp"
#include "RinexObsHeader.hpp"
#include "XvtStore.hpp"
#include "TropModel.hpp"

namespace gpstk
{
 
   class PRSolution
   {
   public:
      PRSolution() throw() : RMSLimit(6.5), SlopeLimit(100.), 
         Algebraic(false), ResidualCriterion(true), ReturnAtOnce(false),
         NSatsReject(-1), Debug(false), pDebugStream(&std::cout),
         MaxNIterations(10),  ConvergenceLimit(3.e-7), Valid(false) {};

      int RAIMCompute(const DayTime& Tr,
                      std::vector<SatID>& Satellite,
                      const std::vector<double>& Pseudorange,
                      const XvtStore<SatID>& Eph,
                      TropModel *pTropModel)
         throw(Exception);

      bool isValid()
         const throw() { return Valid; }

      // input:

      double RMSLimit;

      double SlopeLimit;

      bool Algebraic;

      bool ResidualCriterion;

      bool ReturnAtOnce;

      int NSatsReject;

      bool Debug;

      std::ostream *pDebugStream;

      // TD optional: measurement covariance matrix

      int MaxNIterations;

      double ConvergenceLimit;

      // output:

      bool Valid;

      Vector<double> Solution;

      Matrix<double> Covariance;

      double RMSResidual;

      double MaxSlope;

      int NIterations;

      double Convergence;

      int Nsvs;

      static int PrepareAutonomousSolution(const DayTime& Tr,
                                           std::vector<SatID>& Sats,
                                           const std::vector<double>& Pseudorange,
                                           const XvtStore<SatID>& Eph,
                                           Matrix<double>& SVP,
                                           std::ostream *pDebug=NULL)
         throw();

      static int AutonomousPRSolution(const DayTime& Tr,
                                      const std::vector<bool>& Use,
                                      const Matrix<double> SVP,
                                      TropModel *pTropModel,
                                      const bool Algebraic,
                                      int& n_iterate,
                                      double& converge,
                                      Vector<double>& Sol,
                                      Matrix<double>& Cov,
                                      Vector<double>& Resid,
                                      Vector<double>& Slope,
                                      std::ostream *pDebug=NULL)
            throw(Exception);

   private:

      Matrix<double> SVP;

      Vector<double> APrioriSolution;

      static int AlgebraicSolution(Matrix<double>& A,
                                               Vector<double>& Q,
                                               Vector<double>& X,
                                               Vector<double>& R);

   }; // end class PRSolution


} // namespace gpstk

#endif

---