GLOCNavAlm.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 GNSSTK_GLOCNAVALM_HPP
#define GNSSTK_GLOCNAVALM_HPP
 
#include "GLOCNavData.hpp"
#include "PZ90Ellipsoid.hpp"
#include "GLOCSatType.hpp"
#include "GLOCOrbitType.hpp"
#include "gnsstk_export.h"
 
// test class forward declaration for a friend.
class GLOCNavAlm_T;
 
namespace gnsstk
{
 
 
   class GLOCNavAlm : public GLOCNavData
   {
   public:
      GNSSTK_EXPORT static const PZ90Ellipsoid ell;
      GNSSTK_EXPORT static const double GM;
      GNSSTK_EXPORT static const double ae;
      GNSSTK_EXPORT static constexpr double omegaE = 0.7292115e-4;
      GNSSTK_EXPORT static const double iav;
      GNSSTK_EXPORT static const double Tav;
      GNSSTK_EXPORT static const double J20;
 
      GLOCNavAlm();
      NavDataPtr clone() const override
      { return std::make_shared<GLOCNavAlm>(*this); }
 
      bool validate() const override;
 
      bool getXvt(const CommonTime& when, Xvt& xvt,
                  const ObsID& = ObsID()) override;
 
      CommonTime getUserTime() const override;
 
      void fixFit();
 
      void dump(std::ostream& s, DumpDetail dl) const override;
 
      void dumpTerse(std::ostream& s) const;
 
      CommonTime Toa;      
      GLOCOrbitType orbitType; 
      unsigned numSVs;     
      unsigned aoa;        
      unsigned NA;         
      unsigned statusReg;  
      GLOCSatType satType; 
      double tau;          
      double lambda;       
      double tLambda;      
      double deltai;       
      double ecc;          
      double omega;        
      double deltaT;       
      double deltaTdot;    
 
   private:
      class Perturbations
      {
      public:
         Perturbations();
         Perturbations operator-(const Perturbations& right) const;
 
         inline double geta() const { return a; }
         inline double geth() const { return h; }
         inline double getl() const { return l; }
         inline double getlambda() const { return lambda; }
         inline double getomega() const { return omega; }
         inline double geti() const { return i; }
         inline double getLk() const { return Lk; }
      protected:
         double a;      
         double h;      
         double l;      
         double lambda; 
         double omega;  
         double i;      
         double Lk;     
         friend class ::GLOCNavAlm_T;
      };
      class Uncorrected : public Perturbations
      {
      public:
         Uncorrected();
         inline void setData(const GLOCNavAlm& alm, double Tdr, double n,
                             double Deltatpr);
      private:
         double p; 
 
         inline void seti(double DeltaiA);
         inline void seta(double epsilonA, double omegaA, double Tdr);
         inline void setp(double epsilonA);
         inline void setlambda(double lambdaA, double n, double Deltatpr);
         inline void setomega(double omegaA, double n, double Deltatpr);
         inline void sethl(double epsilonA);
         friend class ::GLOCNavAlm_T;
      };
      class Deltas : public Perturbations
      {
      public:
         Deltas() {}
         inline void setData(double B, double Lk, const Uncorrected& uncor);
      private:
         inline void setdeltaa_a(double B, double Lk, const Uncorrected& uncor);
         inline void setdeltah(double B, double Lk, const Uncorrected& uncor);
         inline void setdeltal(double B, double Lk, const Uncorrected& uncor);
         inline void setdeltalambda(double B, double Lk,
                                    const Uncorrected& uncor);
         inline void setdeltai(double B, double Lk, const Uncorrected& uncor);
         inline void setdeltaLk(double B, double Lk, const Uncorrected& uncor);
         friend class ::GLOCNavAlm_T;
      };
      class Corrected : public Perturbations
      {
      public:
         Corrected();
         inline void setData(double L, const Uncorrected& uncor,
                             const Deltas& delta1, const Deltas& delta2);
         inline Xvt getXvt(const gnsstk::CommonTime& toi);
      private:
         double E;       
         double epsilon; 
         double nu;      
         double p;       
         double u;
         double r;       
         double vu;
         double vr;
         inline void setp();
         inline void setE(double L);
         inline void setnu();
         inline void setu();
         inline void setr();
         inline void setvrvu();
         friend class ::GLOCNavAlm_T;
      };
      class NumberCruncher
      {
      public:
         NumberCruncher();
         inline Xvt getXvt(const GLOCNavAlm& alm,
                           const gnsstk::CommonTime& toi);
      private:
         Deltas k1;              
         Deltas k2;              
         Uncorrected uncorrected;
         Corrected corrected;    
         double Deltatpr;        
         int W;                  
         double Tdr;             
         double n;               
         double E0;              
         double L1;              
         double L;               
         double B;               
 
         inline void setDeltatpr(const gnsstk::CommonTime& almTime,
                                 const gnsstk::CommonTime& ti);
         inline void setW(double DeltaTA);
         inline void setTdr(double DeltaTA, double DeltaTdotA);
         inline void setn();
         inline void setE0(double epsilonA);
         inline void setL1(double epsilonA);
         inline void setL(double DeltaTA, double DeltaTdotA);
         inline void setB();
 
         friend class ::GLOCNavAlm_T;
      };
 
      NumberCruncher math;
 
         // Need access to private data.
      friend class ::GLOCNavAlm_T;
   };
 
 
}
 
// inline method definitions, in separate files for cleanliness.
#include "GLOCNavAlmUncorrected.hpp"
#include "GLOCNavAlmCorrected.hpp"
#include "GLOCNavAlmDeltas.hpp"
#include "GLOCNavAlmNumberCruncher.hpp"
 
#endif // GNSSTK_GLOCNAVALM_HPP