SolverGeneral.hpp

Go to the documentation of this file.

#pragma ident "$Id: SolverGeneral.hpp 2648 2011-06-09 08:01:41Z yanweignss $"

#ifndef GPSTK_SOLVERGENERAL_HPP
#define GPSTK_SOLVERGENERAL_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 ). 2009
//
//============================================================================


#include "SolverBase.hpp"
#include "TypeID.hpp"
#include "ProcessingClass.hpp"
#include "EquationSystem.hpp"
#include "StochasticModel.hpp"
#include "SimpleKalmanFilter.hpp"


namespace gpstk
{



      class GeneralConstraint;


   class SolverGeneral : public SolverBase, public ProcessingClass
   {
   public:

      SolverGeneral( const Equation& equation ) : firstTime(true)
      { equSystem.addEquation(equation); };


      SolverGeneral( const std::list<Equation>& equationList );


      SolverGeneral( const EquationSystem& equationSys ) : firstTime(true)
      { equSystem = equationSys; };


      virtual EquationSystem getEquationSystem() const
      { return equSystem; };


      virtual SolverGeneral& setEquationSystem(
                                             const EquationSystem& equationSys )
      { equSystem = equationSys; return (*this); };


      virtual ConstraintSystem getEquationSystemConstraints() const
      { return equSystem.getConstraintSystem(); };


      virtual SolverGeneral& setEquationSystemConstraints(
                                         const ConstraintSystem& constraintSys )
      { equSystem.setConstraintSystem(constraintSys); return (*this); };


      virtual SolverGeneral& addEquation( const Equation& equation )
      { equSystem.addEquation(equation); return (*this); };


      virtual SolverGeneral& removeEquation( const Variable& indterm )
      { equSystem.removeEquation(indterm); return (*this); };


      virtual SolverGeneral& clearEquations()
      { equSystem.clearEquations(); return (*this); };


      virtual SolverGeneral& reset(void)
      { firstTime = true; return (*this); };


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


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


      virtual gnssDataMap& Process( gnssDataMap& gdsMap )
         throw(ProcessingException);


      virtual double getSolution( const Variable& variable ) const
         throw(InvalidRequest);


      virtual double getSolution( const TypeID& type ) const
         throw(InvalidRequest);


      virtual double getSolution( const TypeID& type,
                                  const SourceID& source ) const
         throw(InvalidRequest);

   
      virtual double getSolution( const TypeID& type,
                                  const SatID& sat ) const
         throw(InvalidRequest);


      virtual double getSolution( const TypeID& type,
                                  const SourceID& source,
                                  const SatID& sat ) const
         throw(InvalidRequest);


      virtual double getCovariance( const Variable& var1, 
                                    const Variable& var2 ) const 
         throw(InvalidRequest);


      virtual double getVariance( const Variable& variable ) const
         throw(InvalidRequest);


      virtual double getVariance( const TypeID& type ) const 
         throw(InvalidRequest);


      virtual double getVariance( const TypeID& type,
                                  const SourceID& source ) const 
         throw(InvalidRequest);


      virtual double getVariance( const TypeID& type,
                                  const SatID& sat ) const 
         throw(InvalidRequest);


      virtual double getVariance( const TypeID& type,
                                  const SourceID& source,
                                  const SatID& sat ) const 
         throw(InvalidRequest);



      virtual Matrix<double> getPhiMatrix(void) const
      { return phiMatrix; };


      virtual Matrix<double> getQMatrix(void) const
      { return qMatrix; };


      virtual int getIndex(void) const;


      virtual std::string getClassName(void) const;


      virtual ~SolverGeneral() {};


   protected:


      EquationSystem equSystem;


      virtual gnssDataMap& preCompute( gnssDataMap& gdsMap )
         throw(ProcessingException);


      virtual gnssDataMap& postCompute( gnssDataMap& gdsMap )
         throw(ProcessingException);


      virtual SolverGeneral& setSolution( const Variable& variable,
                                          const double& val )
         throw(InvalidRequest);


      virtual SolverGeneral& setCovariance( const Variable& var1, 
                                            const Variable& var2,
                                            const double& cov)
         throw(InvalidRequest);

   private:


      Matrix<double> phiMatrix;


      Matrix<double> qMatrix;


      Matrix<double> hMatrix;


      Matrix<double> rMatrix;


      Vector<double> measVector;


      VariableDataMap stateMap;


      std::map<Variable, VariableDataMap > covarianceMap;


      SimpleKalmanFilter kFilter;


      bool firstTime;


      static int classIndex;

      int index;

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


         // Do not allow the use of the default constructor.
      SolverGeneral();


      virtual int Compute( const Vector<double>& prefitResiduals,
                           const Matrix<double>& designMatrix,
                           const Matrix<double>& weightMatrix )
         throw(InvalidSolver);


      friend class GeneralConstraint;

   }; // End of class 'SolverGeneral'


}  // End of namespace gpstk
#endif   // GPSTK_SOLVERGENERAL_HPP

---