SRI.hpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk 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 3.0 of the License, or
//  any later version.
//
//  The GNSSTk 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 GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
#ifndef CLASS_SQUAREROOTINFORMATION_INCLUDE
#define CLASS_SQUAREROOTINFORMATION_INCLUDE
 
//------------------------------------------------------------------------------------
// system includes
#include <string>
// GNSSTk
#include "Matrix.hpp"
#include "StringUtils.hpp"
// geomatics
#include "Namelist.hpp"
#include "SRIMatrix.hpp"
#include "SparseMatrix.hpp"
 
namespace gnsstk
{
 
   //---------------------------------------------------------------------------------
   extern const Matrix<double> SRINullMatrix;
 
   extern const SparseMatrix<double> SRINullSparseMatrix;
 
   //---------------------------------------------------------------------------------
   class SRI
   {
   public:
      SRI() {}
 
      SRI(const unsigned int N);
 
      SRI(const Namelist& NL);
 
      SRI(const Matrix<double>& R, const Vector<double>& Z, const Namelist& NL);
 
      void setFromCovState(const Matrix<double>& Cov,
                           const Vector<double>& State, const Namelist& NL);
 
      SRI(const SRI& s);
 
      SRI& operator=(const SRI& right);
 
      // modify SRIs
 
      void permute(const Namelist& NL);
 
      void split(const Namelist& NL, SRI& S);
 
      SRI& operator+=(const Namelist& NL);
 
      void reshape(const Namelist& NL);
 
      void merge(const SRI& S) { *this += S; }
 
      SRI& operator+=(const SRI& S);
 
      friend SRI operator+(const SRI& Sleft, const SRI& Sright);
 
      SRI& append(const SRI& S);
 
      void zeroOne(const unsigned int n);
 
      void zeroAll(const unsigned int n = 0);
 
      void zeroState() { Z = 0.0; }
 
      void shift(const Vector<double>& X0);
 
      void shiftZ(const Vector<double>& Z0);
 
      void retriangularize(const Matrix<double>& A);
 
      void retriangularize(Matrix<double> RR, Vector<double> ZZ);
 
      void transform(const Matrix<double>& invT, const Namelist& NL);
 
      void Qbump(const unsigned int in, double q = 0.0);
 
      void stateFix(const std::string& name, double value,
                    double sigma, bool restore);
 
      void stateFix(const unsigned int index, double value,
                    double sigma, bool restore);
 
      void stateFixAndRemove(const unsigned int index, double value);
 
      void stateFixAndRemove(const Namelist& drops,
                             const Vector<double>& values);
 
      void addAPriori(const Matrix<double>& Cov, const Vector<double>& X);
 
      void addAPrioriInformation(const Matrix<double>& ICov,
                                 const Vector<double>& X);
 
      void measurementUpdate(Matrix<double>& Partials, Vector<double>& Data)
      {
         try
         {
            SrifMU(R, Z, Partials, Data);
         }
         catch (Exception& me)
         {
            GNSSTK_RETHROW(me);
         }
      }
 
      void measurementUpdate(SparseMatrix<double>& Partials,
                             Vector<double>& Data)
      {
         try
         {
            SrifMU(R, Z, Partials, Data);
         }
         catch (MatrixException& me)
         {
            GNSSTK_RETHROW(me);
         }
      }
 
      void getConditionNumber(double& small, double& big) const;
 
      void getState(Vector<double>& X, int *ptrSingularIndex = NULL) const;
 
      void getStateAndCovariance(Vector<double>& X, Matrix<double>& C,
                                 double *ptrSmall = NULL,
                                 double *ptrBig   = NULL) const;
 
      // member access
      unsigned int size() const { return R.rows(); }
 
      Namelist getNames() const { return names; }
 
      std::string getName(const unsigned int in) const
      {
         return names.getName(in);
      }
 
      bool setName(const unsigned int in, const std::string& label)
      {
         return names.setName(in, label);
      }
 
      unsigned int index(std::string& name)
      {
         return names.index(name);
      }
 
      Matrix<double> getR() const { return R; }
 
      Vector<double> getZ() const { return Z; }
 
      friend std::ostream& operator<<(std::ostream& s, const SRI& );
 
   protected:
      // member data
      Matrix<double> R;
 
      Vector<double> Z;
 
      Namelist names;
 
   }; // end class SRI
 
} // end namespace gnsstk
 
//------------------------------------------------------------------------------------
#endif