gps_pvt 0.10.0 → 0.10.2

data/ext/ninja-scan-light/tool/navigation/GLONASS_Solver.h

@@ -134,7 +134,9 @@ class GLONASS_SinglePositioning : public SolverBaseT {
             return sat(ptr).clock_error_dot(t_tx);
           }
           static float_t range_sigma(const void *ptr, const gps_time_t &t_tx) {
-            return sat(ptr).ephemeris().F_T;
+            return std::sqrt(
+                std::pow(sat(ptr).ephemeris().F_T, 2)
+                + std::pow(4.5 / 1.96, 2)); // TODO change? (currently same as GPS)
           }
         };
         satellite_t res = {
@@ -229,7 +231,7 @@ class GLONASS_SinglePositioning : public SolverBaseT {
      * @param prn satellite number
      * @param measurement measurement (per satellite) containing pseudo range
      * @param receiver_error (temporal solution of) receiver clock error in meter
-     * @param time_arrival time when signal arrive at receiver
+     * @param time_arrival time when signal arrives at receiver
      * @param usr_pos (temporal solution of) user position
      * @param usr_vel (temporal solution of) user velocity
      * @return (relative_property_t) relative information
@@ -325,11 +327,17 @@ class GLONASS_SinglePositioning : public SolverBaseT {
       res.range_corrected = range;
 
       xyz_t rel_vel(sat.velocity(t_tx, dt_transit) - usr_vel); // Calculate velocity
-
       res.rate_relative_neg = res.los_neg[0] * rel_vel.x()
           + res.los_neg[1] * rel_vel.y()
           + res.los_neg[2] * rel_vel.z()
           + sat.clock_error_dot(t_tx) * c;
+      res.rate_sigma = sat.rate_sigma(time_arrival);
+
+      if(_options.use_external_sigma){
+        // Use standard deviation of pseudorange and/or its rate if they are provided by receiver
+        this->range_sigma(measurement, res.range_sigma);
+        this->rate_sigma(measurement, res.rate_sigma);
+      }
 
       return res;
     }

data/ext/ninja-scan-light/tool/navigation/GPS.h

@@ -1156,7 +1156,8 @@ static void name ## _set(InputT *dest, const s ## bits ## _t &src){ \
           
           // Subframe.1
           uint_t WN;          ///< Week number
-          float_t URA;          ///< User range accuracy (m)
+          float_t URA;        ///< User range accuracy (m) including all errors
+            ///< for which the Space and Control Segments are responsible. (ICD 6.2.1)
           uint_t SV_health;   ///< Health status
           int_t iodc;         ///< Issue of clock data
           float_t t_GD;       ///< Group delay (s)

data/ext/ninja-scan-light/tool/navigation/GPS_Solver.h

@@ -55,10 +55,12 @@ template <class FloatT>
 struct GPS_Solver_GeneralOptions {
   FloatT elevation_mask;
   FloatT residual_mask;
+  bool use_external_sigma;
 
   GPS_Solver_GeneralOptions()
       : elevation_mask(0), // elevation mask default is 0 [deg]
-      residual_mask(30) { // range residual mask is 30 [m]
+      residual_mask(1E3), // range residual mask is 1000 [m]
+      use_external_sigma(false) { // default is to ignore external sigma inputs
 
   }
 };
@@ -158,7 +160,9 @@ class GPS_SinglePositioning : public SolverBaseT {
             return sat(ptr).clock_error_dot(t_tx);
           }
           static float_t range_sigma(const void *ptr, const gps_time_t &t_tx) {
-            return sat(ptr).ephemeris().URA;
+            return std::sqrt(
+                std::pow(sat(ptr).ephemeris().URA, 2)
+                + std::pow(4.5 / 1.96, 2)); // UEE of modern receiver Table.B2-1 of April 2020 GPS SPS PS;
           }
         };
         satellite_t res = {
@@ -262,9 +266,9 @@ class GPS_SinglePositioning : public SolverBaseT {
      *
      * @param sat satellite
      * @param range "corrected" pseudo range subtracted by (temporal solution of) receiver clock error in meter
-     * @param time_arrival time when signal arrive at receiver
+     * @param time_arrival time when signal arrives at receiver
      * @param usr_pos (temporal solution of) user position
-     * @param residual calculated residual with line of site vector, and pseudorange standard deviation (sigma);
+     * @param residual calculated residual with line of sight vector, and pseudorange standard deviation (sigma);
      * When sigma is equal to or less than zero, the calculated results should not be used.
      * @param error Some correction can be overwritten. If its unknown_flag is zero,
      * corrections will be skipped as possible. @see range_errors_t
@@ -280,7 +284,7 @@ class GPS_SinglePositioning : public SolverBaseT {
 
       static const float_t &c(space_node_t::light_speed);
 
-      // Clock error correction
+      // Satellite clock error correction
       range += ((error.unknown_flag & range_error_t::SATELLITE_CLOCK)
           ? (sat.clock_error(time_arrival - range / c) * c)
           : error.value[range_error_t::SATELLITE_CLOCK]);
@@ -294,20 +298,21 @@ class GPS_SinglePositioning : public SolverBaseT {
       // Calculate residual
       residual.residual = range - geometric_range;
 
-      // Setup design matrix
+      // Setup design matrix (direction is negative; satellite -> user)
       residual.los_neg_x = -(sat_pos.x() - usr_pos.xyz.x()) / geometric_range;
       residual.los_neg_y = -(sat_pos.y() - usr_pos.xyz.y()) / geometric_range;
       residual.los_neg_z = -(sat_pos.z() - usr_pos.xyz.z()) / geometric_range;
 
       enu_t relative_pos(enu_t::relative(sat_pos, usr_pos.xyz));
 
+      // Ionospheric correction
       if(error.unknown_flag & range_error_t::MASK_IONOSPHERIC){
         residual.residual += ionospheric_correction(time_arrival, usr_pos, relative_pos);
       }else{
         residual.residual += error.value[range_error_t::IONOSPHERIC];
       }
 
-      // Tropospheric
+      // Tropospheric correction
       residual.residual += (error.unknown_flag & range_error_t::MASK_TROPOSPHERIC)
           ? tropospheric_correction(time_arrival, usr_pos, relative_pos)
           : error.value[range_error_t::TROPOSPHERIC];
@@ -347,9 +352,9 @@ class GPS_SinglePositioning : public SolverBaseT {
      * @param range "corrected" pseudo range subtracted by (temporal solution of) receiver clock error in meter
      * @param time_arrival time when signal arrive at receiver
      * @param usr_vel (temporal solution of) user velocity
-     * @param los_neg_x line of site X
-     * @param los_neg_y line of site Y
-     * @param los_neg_z line of site Z
+     * @param los_neg_x line of sight X
+     * @param los_neg_y line of sight Y
+     * @param los_neg_z line of sight Z
      * @return (float_t) relative rate.
      */
     float_t rate_relative_neg(
@@ -425,14 +430,13 @@ class GPS_SinglePositioning : public SolverBaseT {
           usr_pos, residual, range_error);
       res.rate_relative_neg = rate_relative_neg(sat, res.range_corrected, time_arrival, usr_vel,
           res.los_neg[0], res.los_neg[1], res.los_neg[2]);
+      res.rate_sigma = sat.rate_sigma(time_arrival);
 
-#if 0
-      // TODO consider case when standard deviation of pseudorange measurement is provided by receiver
-      if(!this->range_sigma(measurement, res.range_sigma)){
-        // If receiver's range variance is not provided
-        res.range_sigma = 1E0; // TODO range error variance [m]
+      if(_options.use_external_sigma){
+        // Use standard deviation of pseudorange and/or its rate if they are provided by receiver
+        this->range_sigma(measurement, res.range_sigma);
+        this->rate_sigma(measurement, res.rate_sigma);
       }
-#endif
 
       return res;
     }

data/ext/ninja-scan-light/tool/navigation/GPS_Solver_Base.h

@@ -148,7 +148,7 @@ struct GPS_Solver_Base {
    * of measurement_t::mapped_type
    * @param values key-value map
    * @param key key
-   * @param buf buffer into which found value is stored
+   * @param buf buffer for storing found value, and preserving original value if value is not found
    * @return (float_t *) When value is found, pointer of buf will be returned.
    * Otherwise, NULL is returned.
    */
@@ -209,8 +209,13 @@ struct GPS_Solver_Base {
     if((res = find_value(values, measurement_items_t::L1_RANGE_RATE, buf))){
 
     }else if((res = find_value(values, measurement_items_t::L1_DOPPLER, buf))){
-      // Fall back to doppler
-      buf *= -space_node_t::L1_WaveLength();
+      // Fall back to Doppler
+      float_t freq;
+      if(find_value(values, measurement_items_t::L1_FREQUENCY, freq)){
+        buf *= -(space_node_t::light_speed / freq);
+      }else{
+        buf *= -space_node_t::L1_WaveLength();
+      }
     }
     return res;
   }
@@ -221,8 +226,13 @@ struct GPS_Solver_Base {
     if((res = find_value(values, measurement_items_t::L1_RANGE_RATE_SIGMA, buf))){
 
     }else if((res = find_value(values, measurement_items_t::L1_DOPPLER_SIGMA, buf))){
-      // Fall back to doppler
-      buf *= space_node_t::L1_WaveLength();
+      // Fall back to Doppler
+      float_t freq;
+      if(find_value(values, measurement_items_t::L1_FREQUENCY, freq)){
+        buf *= (space_node_t::light_speed / freq);
+      }else{
+        buf *= space_node_t::L1_WaveLength();
+      }
     }
     return res;
   }
@@ -279,7 +289,8 @@ struct GPS_Solver_Base {
     inline float_t range_sigma(const gps_time_t &t_tx) const {
       return impl_range_sigma
           ? impl_range_sigma(impl_error, t_tx)
-          : 3.5; // 7.0 [m] of 95% (2-sigma) URE in Sec. 3.4.1 of April 2020 GPS SPS PS;
+          : (std::sqrt((9.7 * 9.7) + (4.5 * 4.5)) / 1.96); // 5.45 [m]
+          // UERE (User Equivalent Range Error) of modern receiver in Eq.(B-8) of April 2020 GPS SPS PS;
     }
     /**
      * Return expected user range rate accuracy (URRA) in standard deviation (1-sigma)
@@ -289,7 +300,12 @@ struct GPS_Solver_Base {
     inline float_t rate_sigma(const gps_time_t &t_tx) const {
       return impl_rate_sigma
           ? impl_rate_sigma(impl_error, t_tx)
-          : 0.003; // 0.006 [m/s] of 95% (2-sigma) URRE in Sec. 3.4.2 of April 2020 GPS SPS PS
+          : 5E-1; // (Empirical value)
+          // Alternatives (may occur failure);
+          // 1) (std::sqrt(((2.0 * 2.0) + (1.0 * 1.0)) * 2) / 1.96); // 1.61 [m/s]
+          // assume differential range with error consisting of "Receiver noise and resolution"
+          // and "Other user segment errors" in UEE Table B.2-1 of April 2020 GPS SPS PS
+          // 2) 0.006 m/s(95%) SPS SIS URRE in Table 3.4-2 is not considered.
     }
     static const satellite_t &unavailable() {
       struct impl_t {
@@ -388,8 +404,9 @@ struct GPS_Solver_Base {
     float_t range_sigma; ///< Standard deviation of pseudorange; If zero or negative, other values are invalid.
     float_t range_corrected; ///< corrected range just including delay, and excluding receiver/satellite error
     float_t range_residual; ///< residual range
-    float_t rate_relative_neg; /// relative rate
-    float_t los_neg[3]; ///< line of site vector from satellite to user
+    float_t rate_sigma; ///< Standard deviation of range rate;
+    float_t rate_relative_neg; /// relative rate (taking negative value if range is increasing)
+    float_t los_neg[3]; ///< line of sight vector from satellite to user in ECEF coordinate
   };
 
   /**
@@ -433,16 +450,16 @@ struct GPS_Solver_Base {
     float_t receiver_error;
     enu_t user_velocity_enu;
     float_t receiver_error_rate;
-    struct dop_t {
+    struct precision_t {
       float_t g, p, h, v, t;
-      dop_t() {}
-      dop_t(const matrix_t &C_enu)
-          : g(std::sqrt(C_enu.trace())),
-          p(std::sqrt(C_enu.partial(3, 3).trace())),
-          h(std::sqrt(C_enu.partial(2, 2).trace())),
-          v(std::sqrt(C_enu(2, 2))),
-          t(std::sqrt(C_enu(3, 3))) {}
-    } dop;
+      precision_t() {}
+      precision_t(const matrix_t &C_or_P_enu)
+          : g(std::sqrt(C_or_P_enu.trace())),
+          p(std::sqrt(C_or_P_enu.partial(3, 3).trace())),
+          h(std::sqrt(C_or_P_enu.partial(2, 2).trace())),
+          v(std::sqrt(C_or_P_enu(2, 2))),
+          t(std::sqrt(C_or_P_enu(3, 3))) {}
+    } dop, sigma_pos, sigma_vel;
     unsigned int used_satellites;
     typedef BitArray<0x400> satellite_mask_t;
     satellite_mask_t used_satellite_mask; ///< bit pattern(use=1, otherwise=0), PRN 1(LSB) to 32 for GPS
@@ -565,27 +582,48 @@ protected:
       return (G.transpose() * G).inverse();
     }
     /**
-     * Transform coordinate of matrix C
-     * C' = (G * R^t)^t * (G * R^t) = R * G^t * G * R^t = R * C * R^t,
+     * Calculate P matrix, where P = E[x^t x] = (G^t * W * G)^{-1} to be used for estimated accuracy calculation
+     * @return P matrix
+     */
+    matrix_t P() const {
+      return (G.transpose() * W * G).inverse();
+    }
+    /**
+     * Transform coordinate of matrix C/P
+     * C' = ((G * R^t)^t * (G * R^t))^-1 = (R * G^t * G * R^t)^-1
+     *    = (R^t)^-1 * (G^t * G)^-1 * R^-1  = R * C * R^t,
+     * P' = ((G * R^t)^t * W * (G * R^t))^-1 = R * P * R^t,
      * where R is a rotation matrix, for example, ECEF to ENU.
      *
      * @param rotation_matrix 3 by 3 rotation matrix
-     * @return transformed matrix C'
+     * @return transformed matrix C' or P'
      * @see rotate_G
      */
-    static matrix_t rotate_C(const matrix_t &C, const matrix_t &rotation_matrix){
-      unsigned int n(C.rows()); // Normally n=4
+    static matrix_t rotate_CP(const matrix_t &C_or_P, const matrix_t &rotation_matrix){
+      unsigned int n(C_or_P.rows()); // Normally n=4
       matrix_t res(n, n);
       res.partial(3, 3).replace( // upper left
-          rotation_matrix * C.partial(3, 3) * rotation_matrix.transpose());
+          rotation_matrix * C_or_P.partial(3, 3) * rotation_matrix.transpose());
       res.partial(3, n - 3, 0, 3).replace( // upper right
-          rotation_matrix * C.partial(3, n - 3, 0, 3));
+          rotation_matrix * C_or_P.partial(3, n - 3, 0, 3));
       res.partial(n - 3, 3, 3, 0).replace( // lower left
-          C.partial(n - 3, 3, 3, 0) * rotation_matrix.transpose());
+          C_or_P.partial(n - 3, 3, 3, 0) * rotation_matrix.transpose());
       res.partial(n - 3, n - 3, 3, 3).replace( // lower right
-          C.partial(n - 3, n - 3, 3, 3));
+          C_or_P.partial(n - 3, n - 3, 3, 3));
       return res;
     }
+    typename user_pvt_t::precision_t dop(){
+      return typename user_pvt_t::precision_t(C());
+    }
+    typename user_pvt_t::precision_t dop(const matrix_t &rotation_matrix){
+      return typename user_pvt_t::precision_t(rotate_CP(C(), rotation_matrix));
+    }
+    typename user_pvt_t::precision_t sigma(){
+      return typename user_pvt_t::precision_t(P());
+    }
+    typename user_pvt_t::precision_t sigma(const matrix_t &rotation_matrix){
+      return typename user_pvt_t::precision_t(rotate_CP(P(), rotation_matrix));
+    }
     /**
      * Solve x of linear equation (y = G x + v) to minimize sigma{v^t * v}
      * where v =~ N(0, sigma), and y and G are observation delta (=delta_r variable)
@@ -594,7 +632,7 @@ protected:
      *
      * 4 by row(y) S matrix (=(G^t * W * G)^{-1} * (G^t * W)) will be used to calculate protection level
      * to investigate relationship between bias on each satellite and solution.
-     * residual v = (I - P) = (I - G S), where P = G S, which is irrelevant to rotation,
+     * residual v = (I - G S) y, which is irrelevant to rotation,
      * because P = G R R^{t} S = G' S'.
      *
      * @param S (output) coefficient matrix to calculate solution, i.e., (G^t * W * G)^{-1} * (G^t * W)
@@ -701,14 +739,13 @@ protected:
           delta_r.circular(offset, 0, size, 1));
     }
     template <class MatrixT2>
-    void copy_G_W_row(const linear_solver_t<MatrixT2> &src,
+    void copy_G_rowwise(const linear_solver_t<MatrixT2> &src,
         const unsigned int &i_src, const unsigned int &i_dst){
       unsigned int c_dst(G.columns()), c_src(src.G.columns()),
           c(c_dst > c_src ? c_src : c_dst); // Normally c=4
       for(unsigned int j(0); j < c; ++j){
         G(i_dst, j) = src.G(i_src, j);
       }
-      W(i_dst, i_dst) = src.W(i_src, i_src);
     }
   };
 
@@ -806,15 +843,15 @@ protected:
     res.receiver_error = receiver_error_init;
 
     geometric_matrices_t geomat(measurement.size());
-    typedef std::vector<std::pair<unsigned int, float_t> > index_obs_t;
-    index_obs_t idx_rate_rel; // [(index of measurement, relative rate), ...]
-    idx_rate_rel.reserve(measurement.size());
+    typedef std::vector<std::pair<unsigned int, relative_property_t> > index_prop_t;
+    index_prop_t idx_prop; // [(index of measurement, relative property), ...]
+    idx_prop.reserve(measurement.size());
 
     // If initialization is not appropriate, more iteration will be performed.
     bool converged(false);
     for(int i_trial(-opt.warmup); i_trial < opt.max_trial; i_trial++){
 
-      idx_rate_rel.clear();
+      idx_prop.clear();
       unsigned int i_row(0), i_measurement(0);
       res.used_satellite_mask.clear();
 
@@ -841,7 +878,7 @@ protected:
         if(coarse_estimation){
           prop.range_sigma = 1;
         }else{
-          idx_rate_rel.push_back(std::make_pair(i_measurement, prop.rate_relative_neg));
+          idx_prop.push_back(std::make_pair(i_measurement, prop));
         }
 
         geomat.delta_r(i_row, 0) = prop.range_residual;
@@ -872,9 +909,11 @@ protected:
       return;
     }
 
+    matrix_t rot(res.user_position.ecef2enu());
     try{
-      res.dop = typename user_pvt_t::dop_t(geomat.rotate_C(
-          geomat.partial(res.used_satellites).C(), res.user_position.ecef2enu()));
+      typename geometric_matrices_t::partial_t geomat_used(geomat.partial(res.used_satellites));
+      res.dop = geomat_used.dop(rot);
+      res.sigma_pos = geomat_used.sigma(rot);
     }catch(const std::runtime_error &e){ // expect to detect matrix operation error
       res.error_code = user_pvt_t::ERROR_DOP;
       return;
@@ -892,7 +931,7 @@ protected:
     geometric_matrices_t geomat2(res.used_satellites);
     int i_range(0), i_rate(0);
 
-    for(typename index_obs_t::const_iterator it(idx_rate_rel.begin()), it_end(idx_rate_rel.end());
+    for(typename index_prop_t::const_iterator it(idx_prop.begin()), it_end(idx_prop.end());
         it != it_end;
         ++it, ++i_range){
 
@@ -901,9 +940,10 @@ protected:
           *(measurement[it->first].k_v_map), // const version of measurement[PRN]
           rate))){continue;}
 
-      // Copy design matrix and set rate
-      geomat2.copy_G_W_row(geomat, i_range, i_rate);
-      geomat2.delta_r(i_rate, 0) = rate + it->second;
+      // Copy design matrix and set rate and weight
+      geomat2.copy_G_rowwise(geomat, i_range, i_rate);
+      geomat2.delta_r(i_rate, 0) = rate + it->second.rate_relative_neg;
+      geomat2.W(i_rate, i_rate) = 1. / std::pow(it->second.rate_sigma, 2);
 
       ++i_rate;
     }
@@ -915,12 +955,14 @@ protected:
 
     try{
       // Least square
-      matrix_t sol(geomat2.partial(i_rate).least_square());
+      typename geometric_matrices_t::partial_t geomat2_used(geomat2.partial(i_rate));
+      matrix_t sol(geomat2_used.least_square());
 
       xyz_t vel_xyz(sol.partial(3, 1, 0, 0));
       res.user_velocity_enu = enu_t::relative_rel(
           vel_xyz, res.user_position.llh);
       res.receiver_error_rate = sol(3, 0);
+      res.sigma_vel = geomat2_used.sigma(rot);
     }catch(const std::runtime_error &e){ // expect to detect matrix operation error
       res.error_code = user_pvt_t::ERROR_VELOCITY_LS;
       return;
@@ -1145,10 +1187,6 @@ public:
   solver_interface_t<GPS_Solver_Base<FloatT> > solve() const {
     return solver_interface_t<GPS_Solver_Base<FloatT> >(*this);
   }
-
-  static typename user_pvt_t::dop_t dop(const matrix_t &C, const pos_t &user_position) {
-    return typename user_pvt_t::dop_t(geometric_matrices_t::rotate_C(C, user_position.ecef2enu()));
-  }
 };
 
 template <class FloatT>

data/ext/ninja-scan-light/tool/navigation/GPS_Solver_RAIM.h

@@ -56,7 +56,7 @@ struct GPS_PVT_RAIM_LSR : public PVT_BaseT {
     typename GPS_Solver_Base<FloatT>::prn_t excluded;
     typename GPS_Solver_Base<FloatT>::pos_t user_position;
     typename GPS_Solver_Base<FloatT>::float_t receiver_error;
-    typename GPS_Solver_Base<FloatT>::user_pvt_t::dop_t dop;
+    typename GPS_Solver_Base<FloatT>::user_pvt_t::precision_t dop, sigma_pos;
   } FDE_min, FDE_2nd; ///< Fault exclusion
 };
 
@@ -231,6 +231,7 @@ protected:
       target->user_position = pvt_FDE.user_position;
       target->receiver_error = pvt_FDE.receiver_error;
       target->dop = pvt_FDE.dop;
+      target->sigma_pos = pvt_FDE.sigma_pos;
     }
   }
 };

data/ext/ninja-scan-light/tool/navigation/SBAS_Solver.h

@@ -129,7 +129,9 @@ class SBAS_SinglePositioning : public SolverBaseT {
             return sat(ptr).ephemeris().clock_error_dot(t_tx);
           }
           static float_t range_sigma(const void *ptr, const gps_time_t &t_tx) {
-            return sat(ptr).ephemeris().URA;
+            return std::sqrt(
+                std::pow(sat(ptr).ephemeris().URA, 2)
+                + std::pow(4.5 / 1.96, 2)); // TODO change? (currently same as GPS)
           }
         };
         satellite_t res = {
@@ -330,11 +332,17 @@ class SBAS_SinglePositioning : public SolverBaseT {
       res.range_corrected = range;
 
       xyz_t rel_vel(sat.velocity(t_tx, dt_transit) - usr_vel); // Calculate velocity
-
       res.rate_relative_neg = res.los_neg[0] * rel_vel.x()
           + res.los_neg[1] * rel_vel.y()
           + res.los_neg[2] * rel_vel.z()
           + sat.clock_error_dot(t_tx) * c;
+      res.rate_sigma = sat.rate_sigma(time_arrival);
+
+      if(_options.use_external_sigma){
+        // Use standard deviation of pseudorange and/or its rate if they are provided by receiver
+        this->range_sigma(measurement, res.range_sigma);
+        this->rate_sigma(measurement, res.rate_sigma);
+      }
 
       return res;
     }

data/ext/ninja-scan-light/tool/swig/GPS.i

@@ -368,6 +368,22 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
     System_XYZ<FloatT, WGS84> position, velocity;
     FloatT clock_error, clock_error_dot;
   };
+  
+  int get_URA_index() const {
+    return GPS_Ephemeris<FloatT>::URA_index(this->URA);
+  }
+  int set_URA_index(const int &idx) {
+    this->URA = GPS_Ephemeris<FloatT>::URA_meter(idx);
+    return get_URA_index();
+  }
+  FloatT set_fit_interval(const bool &flag) {
+    // set svid/iodc before invocation of this function
+    if((this->svid >= 193) && (this->svid <= 202)){ // QZSS
+      return (this->fit_interval = (flag ? (std::numeric_limits<FloatT>::max)() : (2 * 60 * 60)));
+    }else{
+      return (this->fit_interval = GPS_Ephemeris<FloatT>::raw_t::fit_interval(flag, this->iodc));
+    }
+  }
 };
 %}
 %extend GPS_Ephemeris {
@@ -403,6 +419,9 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
   MAKE_ACCESSOR(dot_Omega0, FloatT);
   MAKE_ACCESSOR(dot_i0, FloatT);
   
+  %rename(%str(URA_index=)) set_URA_index;
+  %rename(%str(URA_index)) get_URA_index;
+  
   MAKE_ARRAY_INPUT(const unsigned int, buf, SWIG_AsVal(unsigned int));
   %apply int *OUTPUT { int *subframe_no, int *iodc_or_iode };
   void parse(const unsigned int buf[10], int *subframe_no, int *iodc_or_iode){
@@ -597,11 +616,18 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
     return SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
   }
   GPS_Time<FloatT> t_applicable() const {return GPS_Time<FloatT>(this->WN, this->t_0);}
+  int get_URA_index() const {
+    return SBAS_Ephemeris<FloatT>::URA_index(this->URA);
+  }
+  int set_URA_index(const int &idx) {
+    this->URA = SBAS_Ephemeris<FloatT>::URA_meter(idx);
+    return get_URA_index();
+  }
 };
 %}
 %extend SBAS_Ephemeris {
   MAKE_ACCESSOR(svid, unsigned int);
-          
+
   MAKE_ACCESSOR(WN, unsigned int);
   MAKE_ACCESSOR(t_0, FloatT);
   MAKE_ACCESSOR(URA, FloatT);
@@ -610,6 +636,9 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
   MAKE_ACCESSOR(ddx, FloatT); MAKE_ACCESSOR(ddy, FloatT); MAKE_ACCESSOR(ddz, FloatT);
   MAKE_ACCESSOR(a_Gf0, FloatT);
   MAKE_ACCESSOR(a_Gf1, FloatT);
+  %rename(%str(URA_index=)) set_URA_index;
+  %rename(%str(URA_index)) get_URA_index;
+
   /**
    * Return broadcasted raw data of SBAS ephemeris
    * @param buf_brdc pointer to store raw data of Type 9 message.
@@ -711,6 +740,21 @@ struct GLONASS_Ephemeris
           (typename GLONASS_SpaceNode<FloatT>::TimeProperties)(*this)),
         deltaT));
   }
+  
+  unsigned char get_F_T_index() const {
+    return GLONASS_Ephemeris<FloatT>::F_T_index();
+  }
+  unsigned char set_F_T_index(const unsigned char &idx) {
+    this->F_T = GLONASS_Ephemeris<FloatT>::raw_t::F_T_value(idx);
+    return get_F_T_index();
+  }
+  unsigned char get_P1_index() const {
+    return GLONASS_Ephemeris<FloatT>::P1_index();
+  }
+  unsigned char set_P1_index(const unsigned char &idx) {
+    this->P1 = GLONASS_Ephemeris<FloatT>::raw_t::P1_value(idx);
+    return get_P1_index();
+  }
 };
 %}
 %extend GLONASS_Ephemeris {
@@ -743,12 +787,27 @@ struct GLONASS_Ephemeris
   MAKE_ACCESSOR2(year, date.year, int);
   MAKE_ACCESSOR2(day_of_year, date.day_of_year, int);
   
+  %rename(%str(F_T_index=)) set_F_T_index;
+  %rename(%str(F_T_index)) get_F_T_index;
+  %rename(%str(P1_index=)) set_P1_index;
+  %rename(%str(P1_index)) get_P1_index;
+  
   void set_date(const unsigned int &N_4, const unsigned int &NA) {
     self->date = GLONASS_SpaceNode<FloatT>::TimeProperties::raw_t::raw2date(N_4, NA);
   }
   void set_date(const std::tm &t) {
     self->date = GLONASS_SpaceNode<FloatT>::TimeProperties::date_t::from_c_tm(t);
   }
+  unsigned char N_4() const {
+    unsigned char res;
+    GLONASS_Ephemeris<FloatT>::TimeProperties::raw_t::date2raw(self->date, &res, NULL);
+    return res;
+  }
+  unsigned short NA() const {
+    unsigned short res;
+    GLONASS_Ephemeris<FloatT>::TimeProperties::raw_t::date2raw(self->date, NULL, &res);
+    return res;
+  }
   
   FloatT frequency_L1() const {
     return self->L1_frequency();
@@ -939,6 +998,10 @@ struct GPS_User_PVT
   const FloatT &hdop() const {return base_t::dop.h;}
   const FloatT &vdop() const {return base_t::dop.v;}
   const FloatT &tdop() const {return base_t::dop.t;}
+  const FloatT &hsigma() const {return base_t::sigma_pos.h;}
+  const FloatT &vsigma() const {return base_t::sigma_pos.v;}
+  const FloatT &tsigma() const {return base_t::sigma_pos.t;}
+  const FloatT &vel_sigma() const {return base_t::sigma_vel.p;}
   const unsigned int &used_satellites() const {return base_t::used_satellites;}
   std::vector<int> used_satellite_list() const {return base_t::used_satellite_mask.indices_one();}
   bool position_solved() const {return base_t::position_solved();}
@@ -963,7 +1026,7 @@ struct GPS_User_PVT
     return linear_solver().C();
   }
   Matrix<FloatT, Array2D_Dense<FloatT> > C_enu() const {
-    return proxy_t::linear_solver_t::rotate_C(C(), base_t::user_position.ecef2enu());
+    return proxy_t::linear_solver_t::rotate_CP(C(), base_t::user_position.ecef2enu());
   }
   Matrix<FloatT, Array2D_Dense<FloatT> > S() const {
     Matrix<FloatT, Array2D_Dense<FloatT> > res;
@@ -1193,6 +1256,7 @@ struct GPS_Measurement {
 %extend GPS_SolverOptions_Common {
   MAKE_ACCESSOR2(elevation_mask, cast_general()->elevation_mask, FloatT);
   MAKE_ACCESSOR2(residual_mask, cast_general()->residual_mask, FloatT);
+  MAKE_ACCESSOR2(use_external_sigma, cast_general()->use_external_sigma, bool);
   MAKE_VECTOR2ARRAY(int);
   %ignore cast_general;
 }
@@ -1375,7 +1439,7 @@ struct HookableSolver : public BaseT {
           const GPS_Solver<FloatT>::base_t::relative_property_t &res_orig) const {
       union {
         base_t::relative_property_t prop;
-        FloatT values[7];
+        FloatT values[8];
       } res = {res_orig};
 #ifdef SWIGRUBY
       do{
@@ -1383,15 +1447,19 @@ struct HookableSolver : public BaseT {
         static const int prop_items(sizeof(res.values) / sizeof(res.values[0]));
         VALUE hook(rb_hash_lookup(hooks, key));
         if(NIL_P(hook)){break;}
-        FloatT weight((res.prop.range_sigma > 0) 
+        FloatT weight_range((res.prop.range_sigma > 0) 
             ? (1. / std::pow(res.prop.range_sigma, 2)) // weight=1/(sigma^2)
             : res.prop.range_sigma);
+        FloatT weight_rate((res.prop.rate_sigma > 0) 
+            ? (1. / std::pow(res.prop.rate_sigma, 2)) // weight=1/(sigma^2)
+            : res.prop.rate_sigma);
         VALUE values[] = {
             SWIG_From(int)(prn), // prn
             rb_ary_new_from_args(prop_items, // relative_property
-              swig::from(weight),
+              swig::from(weight_range),
               swig::from(res.prop.range_corrected),
               swig::from(res.prop.range_residual),
+              swig::from(weight_rate),
               swig::from(res.prop.rate_relative_neg),
               swig::from(res.prop.los_neg[0]),
               swig::from(res.prop.los_neg[1]),
@@ -1424,6 +1492,9 @@ struct HookableSolver : public BaseT {
         if(res.values[0] > 0){
           res.values[0] = std::pow(1. / res.values[0], 0.5); // sigma=(1/weight)^0.5
         }
+        if(res.values[3] > 0){
+          res.values[3] = std::pow(1. / res.values[3], 0.5); // sigma=(1/weight)^0.5
+        }
       }while(false);
 #endif
       return res.prop;