gps_pvt 0.4.1 → 0.6.0

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

@@ -75,7 +75,6 @@ class GLONASS_SinglePositioning : public SolverBaseT {
 
     typedef GLONASS_SpaceNode<float_t> space_node_t;
     inheritate_type(gps_time_t);
-    typedef typename space_node_t::Satellite satellite_t;
 
     inheritate_type(xyz_t);
     inheritate_type(enu_t);
@@ -83,9 +82,10 @@ class GLONASS_SinglePositioning : public SolverBaseT {
     inheritate_type(pos_t);
 
     typedef typename base_t::measurement_t measurement_t;
-    inheritate_type(range_error_t);
-    inheritate_type(range_corrector_t);
-    inheritate_type(range_correction_t);
+    typedef typename base_t::satellite_t satellite_t;
+    typedef typename base_t::range_error_t range_error_t;
+    typedef typename base_t::range_corrector_t range_corrector_t;
+    typedef typename base_t::range_correction_t range_correction_t;
 
     inheritate_type(relative_property_t);
     typedef typename super_t::measurement_items_t measurement_items_t;
@@ -97,11 +97,51 @@ class GLONASS_SinglePositioning : public SolverBaseT {
         GLONASS_SinglePositioning_Options<float_t>, base_t> options_t;
 
   protected:
-    const space_node_t &_space_node;
     GLONASS_SinglePositioning_Options<float_t> _options;
 
   public:
-    const space_node_t &space_node() const {return _space_node;}
+    struct satellites_t {
+      const void *impl;
+      satellite_t (*impl_select)(const void *, const prn_t &, const gps_time_t &);
+      inline satellite_t select(const prn_t &prn, const gps_time_t &receiver_time) const {
+        return impl_select(impl, prn, receiver_time);
+      }
+      static satellite_t select_broadcast(
+          const void *ptr, const prn_t &prn, const gps_time_t &receiver_time){
+        const typename space_node_t::satellites_t &sats(
+            reinterpret_cast<const space_node_t *>(ptr)->satellites());
+        const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
+        if((it_sat == sats.end()) // has ephemeris?
+            || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
+          return satellite_t::unavailable();
+        }
+        struct impl_t {
+          static inline const typename space_node_t::Satellite &sat(const void *ptr) {
+            return *reinterpret_cast<const typename space_node_t::Satellite *>(ptr);
+          }
+          static xyz_t position(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).constellation(t, pseudo_range).position;
+          }
+          static xyz_t velocity(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).constellation(t, pseudo_range).velocity;
+          }
+          static float_t clock_error(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).clock_error(t, pseudo_range);
+          }
+          static float_t clock_error_dot(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            // Clock rate error is already taken into account in constellation()
+            return 0;
+          }
+        };
+        satellite_t res = {
+            &(it_sat->second),
+            impl_t::position, impl_t::velocity,
+            impl_t::clock_error, impl_t::clock_error_dot};
+        return res;
+      }
+      satellites_t(const space_node_t &sn)
+          : impl(&sn), impl_select(select_broadcast) {}
+    } satellites;
 
     range_correction_t ionospheric_correction, tropospheric_correction;
 
@@ -120,7 +160,8 @@ class GLONASS_SinglePositioning : public SolverBaseT {
     }
 
     GLONASS_SinglePositioning(const space_node_t &sn, const options_t &opt_wish = options_t())
-        : base_t(), _space_node(sn), _options(available_options(opt_wish)),
+        : base_t(), _options(available_options(opt_wish)),
+        satellites(sn),
         ionospheric_correction(), tropospheric_correction() {
 
       // default ionospheric correction: no correction
@@ -163,25 +204,18 @@ class GLONASS_SinglePositioning : public SolverBaseT {
     }
 
     /**
-     * Check availability of a satellite with which observation is associated
+     * Select satellite by using PRN and time
      *
      * @param prn satellite number
      * @param receiver_time receiver time
-     * @return (const satellite_t *) If available, const pointer to satellite is returned,
-     * otherwise NULL.
+     * @return (satellite_t) If available, satellite.is_available() returning true is returned.
      */
-    const satellite_t *is_available(
-        const typename space_node_t::satellites_t::key_type &prn,
+    satellite_t select_satellite(
+        const prn_t &prn,
         const gps_time_t &receiver_time) const {
-
-      const typename space_node_t::satellites_t &sats(_space_node.satellites());
-      const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn & 0xFF));
-      if((it_sat == sats.end()) // has ephemeris?
-          || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
-        return NULL;
-      }
-
-      return &(it_sat->second);
+      prn_t prn_(prn & 0xFF);
+      if(_options.exclude_prn[prn_]){return satellite_t::unavailable();}
+      return satellites.select(prn_, receiver_time);
     }
 
     /**
@@ -205,32 +239,27 @@ class GLONASS_SinglePositioning : public SolverBaseT {
 
       relative_property_t res = {0};
 
-      if(_options.exclude_prn[prn & 0xFF]){return res;}
-
       float_t range;
       range_error_t range_error;
       if(!this->range(measurement, range, &range_error)){
         return res; // If no range entry, return with weight = 0
       }
 
-      const satellite_t *sat(is_available(prn, time_arrival));
-      if(!sat){return res;} // If satellite is unavailable, return with weight = 0
+      satellite_t sat(select_satellite(prn, time_arrival));
+      if(!sat.is_available()){return res;} // If satellite is unavailable, return with weight = 0
 
       range -= receiver_error;
 
       // Clock correction, which will be considered in the next constellation()
       // as extra transmission time by using extra psuedo range.
       if(range_error.unknown_flag & range_error_t::SATELLITE_CLOCK){
-        range += (sat->clock_error(time_arrival, range) * space_node_t::light_speed);
+        range += (sat.clock_error(time_arrival, range) * space_node_t::light_speed);
       }else{
         range += range_error.value[range_error_t::SATELLITE_CLOCK];
       }
 
-      // Calculate satellite position and velocity
-      typename GPS_SpaceNode<float_t>::SatelliteProperties::constellation_t sat_pos_vel(
-          sat->constellation(time_arrival, range));
-
-      const xyz_t &sat_pos(sat_pos_vel.position);
+      // Calculate satellite position
+      xyz_t sat_pos(sat.position(time_arrival, range));
       float_t geometric_range(usr_pos.xyz.dist(sat_pos));
 
       // Calculate residual
@@ -278,24 +307,15 @@ class GLONASS_SinglePositioning : public SolverBaseT {
 
       res.range_corrected = range;
 
-      xyz_t rel_vel(sat_pos_vel.velocity - usr_vel); // Calculate velocity
+      xyz_t rel_vel(sat.velocity(time_arrival, range) - usr_vel); // Calculate velocity
 
-      // Note: clock rate error is already accounted for in constellation()
       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();
+          + res.los_neg[2] * rel_vel.z()
+          + sat.clock_error_dot(time_arrival, range) * space_node_t::light_speed;
 
       return res;
     }
-
-    xyz_t *satellite_position(
-        const prn_t &prn,
-        const gps_time_t &time,
-        xyz_t &res) const {
-
-      const satellite_t *sat(is_available(prn, time));
-      return sat ? &(res = sat->position(time)) : NULL;
-    }
 };
 
 template <class FloatT, class SolverBaseT>

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

@@ -452,7 +452,7 @@ struct GPS_Time {
     struct {
       int week;
       float_t seconds;
-    } uncorrected; // to work around of "incomplete type" error within g++
+    } uncorrected, corrected; // to work around of "incomplete type" error within g++
     leap_second_event_t(
         const int &year, const int &month, const int &day,
         const int &leap)
@@ -462,9 +462,11 @@ struct GPS_Time {
       t.tm_year = tm_year;
       t.tm_mon = tm_mon;
       t.tm_mday = tm_mday;
-      GPS_Time t_gps(t);
-      uncorrected.week = t_gps.week;
-      uncorrected.seconds = t_gps.seconds;
+      GPS_Time t_gps_uc(t), t_gps(t_gps_uc + leap);
+      uncorrected.week = t_gps_uc.week;
+      uncorrected.seconds = t_gps_uc.seconds;
+      corrected.week = t_gps.week;
+      corrected.seconds = t_gps.seconds;
     }
   };
   static const leap_second_event_t leap_second_events[];
@@ -484,6 +486,92 @@ struct GPS_Time {
     }
     return 0;
   }
+
+  int leap_seconds() const {
+    // Treat *this as (normal) GPS time, to which leap seconds are added when it is converted from std::tm
+    for(const leap_second_event_t *i(&leap_second_events[0]); i->leap_seconds > 0; ++i){
+      if(*this >= GPS_Time(i->corrected.week, i->corrected.seconds)){return i->leap_seconds;}
+    }
+    return 0;
+  }
+  float_t julian_date() const {
+    struct conv_t {
+      static int ymd2jd(const int &year, const int &month, const int &day){
+        // @see https://en.wikipedia.org/wiki/Julian_day#Converting_Gregorian_calendar_date_to_Julian_Day_Number
+        return std::div(1461 * (year + 4800 + std::div(month - 14, 12).quot), 4).quot
+            + std::div(367 * (month - 2 - 12 * std::div((month - 14), 12).quot), 12).quot
+            - std::div(3 * std::div((year + 4900 + std::div(month - 14, 12).quot), 100).quot, 4).quot
+            + day - 32075;
+      }
+    };
+    // origin of Julian day is "noon (not midnight)" BC4713/1/1
+    static const float_t t0(conv_t::ymd2jd(1980, 1, 6) - 0.5);
+    // GPS Time is advanced by leap seconds compared with UTC.
+    // The following calculation is incorrect for a day in which a leap second is inserted or truncated.
+    // @see https://en.wikipedia.org/wiki/Julian_day#Julian_date_calculation
+    return t0 + week * 7 + (seconds - leap_seconds()) / seconds_day;
+  }
+  float_t julian_date_2000() const {
+    static const std::tm tm_2000 = {0, 0, 12, 1, 0, 2000 - 1900};
+    static const float_t jd2000(GPS_Time(tm_2000, 13).julian_date());
+    return julian_date() - jd2000;
+  }
+  std::tm utc() const {return c_tm(leap_seconds());}
+
+  float_t greenwich_mean_sidereal_time_sec_ires1996(const float_t &delta_ut1 = float_t(0)) const {
+    float_t jd2000(julian_date_2000() + delta_ut1 / seconds_day);
+    float_t jd2000_day(float_t(0.5) + std::floor(jd2000 - 0.5)); // +/-0.5, +/-1.5, ...
+
+    // @see Chapter 2 of Orbits(978-3540785217) by Xu Guochang
+    // @see Chapter 5 of IERS Conventions (1996) https://www.iers.org/IERS/EN/Publications/TechnicalNotes/tn21.html
+    float_t jc(jd2000_day / 36525), // Julian century
+        jc2(std::pow(jc, 2)), jc3(std::pow(jc, 3));
+    float_t gmst0(24110.54841 // = 6h 41m 50.54841s
+        + jc * 8640184.812866
+        + jc2 * 0.093104
+        - jc3 * 6.2E-6);
+    // ratio of universal to sidereal time as given by Aoki et al. (1982)
+    float_t r(1.002737909350795 // 7.2921158553E-5 = 1.002737909350795 / 86400 * 2pi
+        + jc * 5.9006E-11 // 4.3E-15 = 5.9E-11 / 86400 * 2pi
+        - jc2 * 5.9E-15); // in seconds
+    return gmst0 + r * (jd2000 - jd2000_day) * seconds_day;
+  }
+
+  /**
+   * ERA (Earth rotation rate) defined in Sec. 5.5.3 in IERS 2010(Technical Note No.36)
+   */
+  float_t earth_rotation_angle(const float_t &delta_ut1 = float_t(0),
+      const float_t &scale_factor = float_t(M_PI * 2)) const {
+    float_t jd2000(julian_date_2000() + delta_ut1 / seconds_day);
+    return (jd2000 * 1.00273781191135448 + 0.7790572732640) * scale_factor; // Eq.(5.14)
+  }
+
+  float_t greenwich_mean_sidereal_time_sec_ires2010(const float_t &delta_ut1 = float_t(0)) const {
+    float_t era(earth_rotation_angle(delta_ut1, seconds_day));
+
+    float_t t(julian_date_2000() / 36525);
+    // @see Eq.(5.32) Chapter 5 of IERS Conventions (2010)
+#define AS2SEC(as) (((float_t)seconds_day / (360 * 3600)) * (as))
+    return era
+        + AS2SEC(0.014506)
+        + t * AS2SEC(4612.156534)
+        + std::pow(t, 2) * AS2SEC(1.3915817)
+        - std::pow(t, 3) * AS2SEC(0.00000044)
+        - std::pow(t, 4) * AS2SEC(0.000029956)
+        - std::pow(t, 5) * AS2SEC(0.0000000368);
+#undef AS2SEC
+  }
+
+  /**
+   * Calculate Greenwich mean sidereal time (GMST) in seconds
+   * Internally, greenwich_mean_sidereal_time_sec_ired2010() is called.
+   * @param delta_ut1 time difference of UTC and UT1; UT1 = UTC + delta_UT1,
+   * @return GMST in seconds. 86400 seconds correspond to one rotation
+   * @see greenwich_mean_sidereal_time_sec_ires2010()
+   */
+  float_t greenwich_mean_sidereal_time_sec(const float_t &delta_ut1 = float_t(0)) const {
+    return greenwich_mean_sidereal_time_sec_ires2010(delta_ut1);
+  }
 };
 
 template <class FloatT>

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

@@ -95,7 +95,6 @@ class GPS_SinglePositioning : public SolverBaseT {
 
     typedef typename base_t::space_node_t space_node_t;
     inheritate_type(gps_time_t);
-    typedef typename space_node_t::Satellite satellite_t;
 
     inheritate_type(xyz_t);
     inheritate_type(llh_t);
@@ -106,6 +105,7 @@ class GPS_SinglePositioning : public SolverBaseT {
     inheritate_type(prn_obs_t);
     typedef typename base_t::measurement_t measurement_t;
     inheritate_type(measurement_items_t);
+    typedef typename base_t::satellite_t satellite_t;
     typedef typename base_t::range_error_t range_error_t;
     typedef typename base_t::range_corrector_t range_corrector_t;
     typedef typename base_t::range_correction_t range_correction_t;
@@ -119,11 +119,52 @@ class GPS_SinglePositioning : public SolverBaseT {
         GPS_SinglePositioning_Options<float_t>, base_t> options_t;
 
   protected:
-    const space_node_t &_space_node;
     GPS_SinglePositioning_Options<float_t> _options;
 
   public:
-    const space_node_t &space_node() const {return _space_node;}
+    struct satellites_t {
+      const void *impl;
+      satellite_t (*impl_select)(const void *, const prn_t &, const gps_time_t &);
+      inline satellite_t select(const prn_t &prn, const gps_time_t &receiver_time) const {
+        return impl_select(impl, prn, receiver_time);
+      }
+      static satellite_t select_broadcast(
+          const void *ptr, const prn_t &prn, const gps_time_t &receiver_time){
+        // If this static function is defined in inner struct,
+        // C2440 error raises with VC2010
+        const typename space_node_t::satellites_t &sats(
+            reinterpret_cast<const space_node_t *>(ptr)->satellites());
+        const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
+        if((it_sat == sats.end()) // has ephemeris?
+            || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
+          return satellite_t::unavailable();
+        }
+        struct impl_t {
+          static inline const typename space_node_t::Satellite &sat(const void *ptr) {
+            return *reinterpret_cast<const typename space_node_t::Satellite *>(ptr);
+          }
+          static xyz_t position(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).position(t, pseudo_range);
+          }
+          static xyz_t velocity(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).velocity(t, pseudo_range);
+          }
+          static float_t clock_error(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).clock_error(t, pseudo_range);
+          }
+          static float_t clock_error_dot(const void *ptr, const gps_time_t &t, const float_t &pseudo_range) {
+            return sat(ptr).clock_error_dot(t, pseudo_range);
+          }
+        };
+        satellite_t res = {
+            &(it_sat->second),
+            impl_t::position, impl_t::velocity,
+            impl_t::clock_error, impl_t::clock_error_dot};
+        return res;
+      }
+      satellites_t(const space_node_t &sn)
+          : impl(&sn), impl_select(select_broadcast) {}
+    } satellites;
 
     struct klobuchar_t : public range_corrector_t {
       const space_node_t &space_node;
@@ -134,6 +175,7 @@ class GPS_SinglePositioning : public SolverBaseT {
       float_t *calculate(
           const gps_time_t &t, const pos_t &usr_pos, const enu_t &sat_rel_pos,
           float_t &buf) const {
+        if(!is_available(t)){return NULL;}
         return &(buf = space_node.iono_correction(sat_rel_pos, usr_pos.llh, t));
       }
     } ionospheric_klobuchar;
@@ -185,7 +227,8 @@ class GPS_SinglePositioning : public SolverBaseT {
     }
 
     GPS_SinglePositioning(const space_node_t &sn)
-        : base_t(), _space_node(sn), _options(available_options(options_t())),
+        : base_t(), _options(available_options(options_t())),
+        satellites(sn),
         ionospheric_klobuchar(sn), ionospheric_ntcm_gl(),
         tropospheric_simplified(),
         ionospheric_correction(), tropospheric_correction() {
@@ -309,27 +352,17 @@ class GPS_SinglePositioning : public SolverBaseT {
     }
 
     /**
-     * Check availability of a satellite with which observation is associated
+     * Select satellite by using PRN and time
      *
      * @param prn satellite number
      * @param receiver_time receiver time
-     * @return (const satellite_t *) If available, const pointer to satellite is returned,
-     * otherwise NULL.
+     * @return (satellite_t) If available, satellite.is_available() returning true is returned.
      */
-    const satellite_t *is_available(
-        const typename space_node_t::satellites_t::key_type &prn,
+    satellite_t select_satellite(
+        const prn_t &prn,
         const gps_time_t &receiver_time) const {
-
-      if(_options.exclude_prn[prn]){return NULL;}
-
-      const typename space_node_t::satellites_t &sats(_space_node.satellites());
-      const typename space_node_t::satellites_t::const_iterator it_sat(sats.find(prn));
-      if((it_sat == sats.end()) // has ephemeris?
-          || (!it_sat->second.ephemeris().is_valid(receiver_time))){ // valid ephemeris?
-        return NULL;
-      }
-
-      return &(it_sat->second);
+      if(_options.exclude_prn[prn]){return satellite_t::unavailable();}
+      return satellites.select(prn, receiver_time);
     }
 
     /**
@@ -359,8 +392,8 @@ class GPS_SinglePositioning : public SolverBaseT {
         return res; // If no range entry, return with weight = 0
       }
 
-      const satellite_t *sat(is_available(prn, time_arrival));
-      if(!sat){return res;} // If satellite is unavailable, return with weight = 0
+      satellite_t sat(select_satellite(prn, time_arrival));
+      if(!sat.is_available()){return res;} // If satellite is unavailable, return with weight = 0
 
       residual_t residual = {
         res.range_residual,
@@ -369,9 +402,9 @@ class GPS_SinglePositioning : public SolverBaseT {
       };
 
       res.range_corrected = range_corrected(
-          *sat, range - receiver_error, time_arrival,
+          sat, range - receiver_error, time_arrival,
           usr_pos, residual, range_error);
-      res.rate_relative_neg = rate_relative_neg(*sat, res.range_corrected, time_arrival, usr_vel,
+      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]);
 
       return res;
@@ -415,7 +448,7 @@ class GPS_SinglePositioning : public SolverBaseT {
         float_t range;
         if(!this->range(it->second, range)){continue;} // No range entry
 
-        if(!is_available(it->first, receiver_time)){continue;} // No satellite
+        if(!(select_satellite(it->first, receiver_time).is_available())){continue;} // No satellite
 
         typename base_t::measurement2_t::value_type v = {
             it->first, &(it->second), this}; // prn, measurement, solver
@@ -426,15 +459,6 @@ class GPS_SinglePositioning : public SolverBaseT {
           measurement2, receiver_time, user_position_init, receiver_error_init,
           typename base_t::user_pvt_opt_t(good_init, with_velocity));
     }
-
-    xyz_t *satellite_position(
-        const prn_t &prn,
-        const gps_time_t &time,
-        xyz_t &res) const {
-
-      const satellite_t *sat(is_available(prn, time));
-      return sat ? &(res = sat->position(time)) : NULL;
-    }
 };
 
 #endif /* __GPS_SOLVER_H__ */

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

@@ -226,6 +226,55 @@ struct GPS_Solver_Base {
     return res;
   }
 
+  struct satellite_t {
+    const void *impl;
+    xyz_t (*impl_position)(const void *, const gps_time_t &, const float_t &);
+    xyz_t (*impl_velocity)(const void *, const gps_time_t &, const float_t &);
+    float_t (*impl_clock_error)(const void *, const gps_time_t &, const float_t &);
+    float_t (*impl_clock_error_dot)(const void *, const gps_time_t &, const float_t &);
+    inline bool is_available() const {
+      return impl != NULL;
+    }
+    inline xyz_t position(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_position(impl, t, pseudo_range);
+    }
+    inline xyz_t velocity(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_velocity(impl, t, pseudo_range);
+    }
+    inline float_t clock_error(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_clock_error(impl, t, pseudo_range);
+    }
+    inline float_t clock_error_dot(const gps_time_t &t, const float_t &pseudo_range = 0) const {
+      return impl_clock_error_dot(impl, t, pseudo_range);
+    }
+    static const satellite_t &unavailable() {
+      struct impl_t {
+        static xyz_t v3(const void *, const gps_time_t &, const float_t &){
+          return xyz_t(0, 0, 0);
+        }
+        static float_t v(const void *, const gps_time_t &, const float_t &){
+          return float_t(0);
+        }
+      };
+      static const satellite_t res = {NULL, impl_t::v3, impl_t::v3, impl_t::v, impl_t::v};
+      return res;
+    }
+  };
+
+  /**
+   * Select satellite by using PRN and time
+   * This function should be overridden.
+   *
+   * @param prn satellite number
+   * @param receiver_time receiver time
+   * @return (satellite_t) If available, satellite.is_available() returning true is returned.
+   */
+  virtual satellite_t select_satellite(
+      const prn_t &prn,
+      const gps_time_t &receiver_time) const {
+    return satellite_t::unavailable();
+  }
+
   struct range_corrector_t {
     virtual ~range_corrector_t() {}
     virtual bool is_available(const gps_time_t &t) const {
@@ -838,21 +887,6 @@ protected:
   }
 
 public:
-  /**
-   * Calculate satellite position
-   *
-   * @param prn satellite number
-   * @param time GPS time
-   * @param res object to which results are stored
-   * @return If position is available, &res will be returned, otherwise NULL.
-   */
-  virtual xyz_t *satellite_position(
-      const prn_t &prn,
-      const gps_time_t &time,
-      xyz_t &res) const {
-    return NULL;
-  }
-
   /**
    * Calculate User position/velocity with hint
    * This is multi-constellation version,
@@ -882,8 +916,7 @@ public:
         it != it_end; ++it){
       typename measurement2_t::value_type v = {
           it->first, &(it->second), &select(it->first)}; // prn, measurement, solver
-      xyz_t sat;
-      if(!v.solver->satellite_position(v.prn, receiver_time, sat)){
+      if(!v.solver->select_satellite(v.prn, receiver_time).is_available()){
         // pre-check satellite availability; remove it when its position is unknown
         continue;
       }