gps_pvt 0.2.1 → 0.3.3

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

@@ -49,11 +49,7 @@ struct SBAS_SinglePositioning_Options : public GPS_Solver_GeneralOptions<FloatT>
 
   typename GPS_Solver_Base<FloatT>::options_t::template exclude_prn_t<120, 158> exclude_prn; // SBAS PRN ranges from 120 to 158
   SBAS_SinglePositioning_Options()
-      : super_t() {
-    // default: SBAS IGP, then broadcasted Klobuchar.
-    super_t::ionospheric_models[0] = super_t::IONOSPHERIC_SBAS;
-    super_t::ionospheric_models[1] = super_t::IONOSPHERIC_KLOBUCHAR;
-
+      : super_t(), exclude_prn() {
     exclude_prn.set(true); // SBAS ranging is default off.
   }
 };
@@ -86,6 +82,8 @@ class SBAS_SinglePositioning : public SolverBaseT {
 
     typedef typename base_t::measurement_t measurement_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);
 #undef inheritate_type
@@ -93,8 +91,6 @@ class SBAS_SinglePositioning : public SolverBaseT {
     typedef typename GPS_Solver_Base<float_t>::options_t::template merge_t<
         SBAS_SinglePositioning_Options<float_t>, base_t> options_t;
 
-    typedef GPS_SpaceNode<float_t> gps_space_node_t;
-    const gps_space_node_t *space_node_gps; ///< optional
   protected:
     const space_node_t &_space_node;
     SBAS_SinglePositioning_Options<float_t> _options;
@@ -102,40 +98,47 @@ class SBAS_SinglePositioning : public SolverBaseT {
   public:
     const space_node_t &space_node() const {return _space_node;}
 
-    /**
-     * Check availability of ionospheric models
-     * If a model is completely unavailable, it will be replaced to IONOSPHERIC_SKIP.
-     * It implies that when a model has conditional applicability (such as SBAS), it will be retained.
-     *
-     * @return (int) number of (possibly) available models
-     */
-    int filter_ionospheric_models(SBAS_SinglePositioning_Options<float_t> &opt) const {
-      int available_models(0);
-      for(std::size_t i(0); i < sizeof(opt.ionospheric_models) / sizeof(opt.ionospheric_models[0]); ++i){
-        bool usable(false);
-        switch(opt.ionospheric_models[i]){
-          case options_t::IONOSPHERIC_KLOBUCHAR:
-            // check whether Klobuchar parameters alpha and beta have been already received
-            if(space_node_gps && space_node_gps->is_valid_iono()){usable = true;}
-            break;
-          case options_t::IONOSPHERIC_SBAS:
-            usable = true;
-            break;
-          case options_t::IONOSPHERIC_NTCM_GL:
-            if(opt.f_10_7 >= 0){usable = true;}
-            // check F10.7 has been already configured
-            break;
-          default:
-            break;
-        }
-        if(usable){
-          available_models++;
-        }else{
-          opt.ionospheric_models[i] = options_t::IONOSPHERIC_SKIP;
+    struct ionospheric_sbas_t : public range_corrector_t {
+      const space_node_t &space_node;
+      ionospheric_sbas_t(const space_node_t &sn) : range_corrector_t(), space_node(sn) {}
+      bool is_available(const gps_time_t &t) const {
+        return true;
+      }
+      float_t *calculate(
+          const gps_time_t &t, const pos_t &usr_pos, const enu_t &sat_rel_pos,
+          float_t &buf) const {
+
+        // placeholder of checking availability and performing correction
+        typedef typename space_node_t::available_satellites_t sats_t;
+        sats_t sats(space_node.available_satellites(usr_pos.llh.longitude()));
+
+        typename space_node_t::IonosphericGridPoints::PointProperty prop;
+        for(typename sats_t::const_iterator it(sats.begin()); it != sats.end(); ++it){
+          prop = it->second
+              ->ionospheric_grid_points().iono_correction(sat_rel_pos, usr_pos.llh);
+          if(prop.is_available()){
+            return &(buf = prop.delay);
+          }
+          break; // TODO The nearest satellite is only checked
         }
+        return NULL;
       }
-      return available_models;
-    }
+    } ionospheric_sbas;
+
+    struct tropospheric_sbas_t : public range_corrector_t {
+      tropospheric_sbas_t() : range_corrector_t() {}
+      bool is_available(const gps_time_t &t) const {
+        return true;
+      }
+      float_t *calculate(
+          const gps_time_t &t, const pos_t &usr_pos, const enu_t &sat_rel_pos,
+          float_t &buf) const {
+        return &(buf = space_node_t::tropo_correction(
+            t.year(), sat_rel_pos, usr_pos.llh));
+      }
+    } tropospheric_sbas;
+
+    range_correction_t ionospheric_correction, tropospheric_correction;
 
     options_t available_options() const {
       return options_t(base_t::available_options(), _options);
@@ -143,19 +146,24 @@ class SBAS_SinglePositioning : public SolverBaseT {
 
     options_t available_options(const options_t &opt_wish) const {
       SBAS_SinglePositioning_Options<float_t> opt(opt_wish);
-      filter_ionospheric_models(opt);
       return options_t(base_t::available_options(opt_wish), opt);
     }
 
     options_t update_options(const options_t &opt_wish){
-      filter_ionospheric_models(_options = opt_wish);
+      _options = opt_wish;
       return options_t(base_t::update_options(opt_wish), _options);
     }
 
-    SBAS_SinglePositioning(const space_node_t &sn, const options_t &opt_wish = options_t())
-        : base_t(), 
-        _space_node(sn), space_node_gps(NULL),
-        _options(available_options(opt_wish)) {}
+    SBAS_SinglePositioning(const space_node_t &sn)
+        : base_t(), _space_node(sn), _options(available_options(options_t())),
+        ionospheric_sbas(sn), tropospheric_sbas() {
+
+      // default ionospheric correction: Broadcasted IGP.
+      ionospheric_correction.push_front(&ionospheric_sbas);
+
+      // default troposheric correction: SBAS
+      tropospheric_correction.push_front(&tropospheric_sbas);
+    }
 
     ~SBAS_SinglePositioning(){}
 
@@ -245,43 +253,12 @@ class SBAS_SinglePositioning : public SolverBaseT {
 
       // Tropospheric (2.1.4.10.3, A.4.2.4)
       res.range_residual += (range_error.unknown_flag & range_error_t::MASK_TROPOSPHERIC)
-          ? _space_node.tropo_correction(time_arrival.year(), relative_pos, usr_pos.llh)
+          ? tropospheric_correction(time_arrival, usr_pos, relative_pos)
           : range_error.value[range_error_t::TROPOSPHERIC];
 
       // Ionospheric (2.1.4.10.2, A.4.4.10.4)
       if(range_error.unknown_flag & range_error_t::MASK_IONOSPHERIC){
-        // Ionospheric model selection, the fall back is no correction
-        bool iono_model_hit(false);
-        for(std::size_t i(0); i < sizeof(_options.ionospheric_models) / sizeof(_options.ionospheric_models[0]); ++i){
-          switch(_options.ionospheric_models[i]){
-            case options_t::IONOSPHERIC_KLOBUCHAR: // 20.3.3.5.2.5
-              res.range_residual += space_node_gps->iono_correction(relative_pos, usr_pos.llh, time_arrival);
-              break;
-            case options_t::IONOSPHERIC_SBAS: { // 2.1.4.10.2, A.4.4.10.4
-              typename space_node_t::IonosphericGridPoints::PointProperty prop(
-                  sat->ionospheric_grid_points().iono_correction(relative_pos, usr_pos.llh));
-              if(!prop.is_available()){continue;}
-              res.range_residual += prop.delay;
-              break;
-            }
-            case options_t::IONOSPHERIC_NTCM_GL: {
-              // TODO f_10_7 setup, optimization (mag_model etc.)
-              typename gps_space_node_t::pierce_point_res_t pp(gps_space_node_t::pierce_point(relative_pos, usr_pos.llh));
-              res.range_residual -= gps_space_node_t::tec2delay(
-                  gps_space_node_t::slant_factor(relative_pos)
-                    * NTCM_GL_Generic<float_t>::tec_vert(
-                      pp.latitude, pp.longitude,
-                      time_arrival.year(), _options.f_10_7));
-              break;
-            }
-            case options_t::IONOSPHERIC_NONE:
-              break;
-            default:
-              continue;
-          }
-          iono_model_hit = true;
-          break;
-        }
+        res.range_residual += ionospheric_correction(time_arrival, usr_pos, relative_pos);
       }else{
         res.range_residual += range_error.value[range_error_t::IONOSPHERIC];
       }

data/ext/ninja-scan-light/tool/param/bit_array.h

@@ -60,6 +60,7 @@ struct const_div_t<denom, denom, log2, 0> {
 template <int MAX_SIZE, class ContainerT = unsigned char>
 struct BitArray {
   static const int bits_per_addr = (int)sizeof(ContainerT) * CHAR_BIT;
+  static const int max_size = MAX_SIZE;
   ContainerT buf[(MAX_SIZE + bits_per_addr - 1) / bits_per_addr];
   void set(const bool &new_bit = false) {
     std::memset(buf, (new_bit ? (~0) : 0), sizeof(buf));
@@ -128,14 +129,14 @@ struct BitArray {
     std::vector<int> res;
     int idx(0);
     static const const_div_t<bits_per_addr> qr(MAX_SIZE);
-    int rem(qr.rem);
-    for(int i(0); i < qr.quot; ++i, idx += bits_per_addr){
+    int rem(qr.rem), i(0);
+    for(; i < qr.quot; ++i, idx += bits_per_addr){
       int idx2(idx);
       for(ContainerT temp(buf[i]); temp > 0; temp >>= 1, ++idx2){
         if(temp & 0x1){res.push_back(idx2);}
       }
     }
-    for(ContainerT temp(buf[qr.quot + 1]); (temp > 0) && (rem > 0); --rem, ++idx, temp >>= 1){
+    for(ContainerT temp(buf[i]); (temp > 0) && (rem > 0); --rem, ++idx, temp >>= 1){
       if(temp & 0x1){res.push_back(idx);}
     }
     return res;

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

@@ -153,12 +153,26 @@ static std::string inspect_str(const VALUE &v){
     $1 = (TYPE($input) == T_ARRAY) ? 1 : 0;
   }
 #endif
+  %ignore canonicalize();
+  %ignore GPS_Time(const int &_week, const float_t &_seconds);
+  %typemap(in, numinputs=0) void *dummy "";
+  GPS_Time(const int &week_, const float_t &seconds_, void *dummy){
+    return &((new GPS_Time<FloatT>(week_, seconds_))->canonicalize());
+  }
   %apply int *OUTPUT { int *week };
   %apply FloatT *OUTPUT { FloatT *seconds };
   void to_a(int *week, FloatT *seconds) const {
     *week = self->week;
     *seconds = self->seconds;
   }
+#if defined(SWIG)  
+  int __cmp__(const GPS_Time<FloatT> &t) const {
+    return ((self->week < t.week) ? -1 
+        : ((self->week > t.week) ? 1 
+          : (self->seconds < t.seconds ? -1 
+            : (self->seconds > t.seconds ? 1 : 0))));
+  }
+#endif
 }
 
 %define MAKE_ACCESSOR(name, type)
@@ -413,8 +427,6 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
     %append_output(swig::from($1.latitude));
     %append_output(swig::from($1.longitude));
   }
-  %ignore iono_correction() const;
-  %ignore tropo_correction() const;
   int read(const char *fname) {
     std::fstream fin(fname, std::ios::in | std::ios::binary);
     typename RINEX_NAV_Reader<FloatT>::space_node_list_t space_nodes = {self};
@@ -800,6 +812,7 @@ struct GPS_Measurement {
     L1_RANGE_RATE_SIGMA,
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
+    L1_FREQUENCY,
     ITEMS_PREDEFINED,
   };
   void add(const int &prn, const int &key, const FloatT &value){
@@ -821,71 +834,15 @@ const type &get_ ## name () const {
 %enddef
   MAKE_ACCESSOR2(elevation_mask, FloatT);
   MAKE_ACCESSOR2(residual_mask, FloatT);
-  MAKE_ACCESSOR2(f_10_7, FloatT);
 #undef MAKE_ACCESSOR2
   MAKE_VECTOR2ARRAY(int);
   %ignore cast_base;
-#ifdef SWIGRUBY
-  %rename("ionospheric_models=") set_ionospheric_models;
-  %rename("ionospheric_models") get_ionospheric_models;
-#endif
-  %typemap(in) const std::vector<int> &models (std::vector<int> temp) {
-    $1 = &temp;
-#ifdef SWIGRUBY
-    if(RB_TYPE_P($input, T_ARRAY)){
-      for(int i(0), i_max(RARRAY_LEN($input)); i < i_max; ++i){
-        SWIG_Object obj(RARRAY_AREF($input, i));
-        int v;
-        if(SWIG_IsOK(SWIG_AsVal(int)(obj, &v))){
-          temp.push_back(v);
-        }else{
-          SWIG_exception(SWIG_TypeError, "$*1_ltype is expected");
-        }
-      }
-    }
-#endif
-  }
 }
 %inline %{
 template <class FloatT>
 struct GPS_SolverOptions_Common {
-  enum {
-    IONOSPHERIC_KLOBUCHAR,
-    IONOSPHERIC_SBAS,
-    IONOSPHERIC_NTCM_GL,
-    IONOSPHERIC_NONE, // which allows no correction
-    IONOSPHERIC_MODELS,
-    IONOSPHERIC_SKIP = IONOSPHERIC_MODELS, // which means delegating the next slot
-  };
   virtual GPS_Solver_GeneralOptions<FloatT> *cast_general() = 0;
   virtual const GPS_Solver_GeneralOptions<FloatT> *cast_general() const = 0;
-  std::vector<int> get_ionospheric_models() const {
-    typedef GPS_Solver_GeneralOptions<FloatT> general_t;
-    const general_t *general(this->cast_general());
-    std::vector<int> res;
-    for(int i(0); i < general_t::IONOSPHERIC_MODELS; ++i){
-      int v((int)(general->ionospheric_models[i]));
-      if(v == general_t::IONOSPHERIC_SKIP){break;}
-      res.push_back(v);
-    }
-    return res;
-  }
-  std::vector<int> set_ionospheric_models(const std::vector<int> &models){
-    typedef GPS_Solver_GeneralOptions<FloatT> general_t;
-    general_t *general(this->cast_general());
-    typedef typename general_t::ionospheric_model_t model_t;
-    for(int i(0), j(0), j_max(models.size()); i < general_t::IONOSPHERIC_MODELS; ++i){
-      model_t v(general_t::IONOSPHERIC_SKIP);
-      if(j < j_max){
-        if((models[j] >= 0) && (models[j] < general_t::IONOSPHERIC_SKIP)){
-          v = (model_t)models[j];
-        }
-        ++j;
-      }
-      general->ionospheric_models[i] = v;
-    }
-    return get_ionospheric_models();
-  }
 };
 %}
 
@@ -927,6 +884,27 @@ struct SBAS_SolverOptions
 };
 %}
 
+%header {
+template <class FloatT>
+struct GPS_RangeCorrector
+    : public GPS_Solver_Base<FloatT>::range_corrector_t {
+  SWIG_Object callback;
+  GPS_RangeCorrector(const SWIG_Object &callback_)
+      : GPS_Solver_Base<FloatT>::range_corrector_t(),
+      callback(callback_) {}
+  bool is_available(const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
+    return false;
+  }
+  FloatT *calculate(
+      const typename GPS_Solver_Base<FloatT>::gps_time_t &t, 
+      const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos, 
+      const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
+      FloatT &buf) const {
+    return NULL;
+  }
+};
+}
+
 %extend GPS_Solver {
   %ignore super_t;
   %ignore base_t;
@@ -938,6 +916,8 @@ struct SBAS_SolverOptions
   %ignore relative_property;
   %ignore satellite_position;
   %ignore update_position_solution;
+  %ignore user_correctors_t;
+  %ignore user_correctors;
   %immutable hooks;
   %ignore mark;
   %fragment("hook"{GPS_Solver<FloatT>}, "header",
@@ -1022,7 +1002,9 @@ struct SBAS_SolverOptions
             SWIG_NewPointerObj(&geomat_.W,
               $descriptor(Matrix<FloatT, Array2D_Dense<FloatT>, MatrixViewBase<> > *), 0),
             SWIG_NewPointerObj(&geomat_.delta_r,
-              $descriptor(Matrix<FloatT, Array2D_Dense<FloatT>, MatrixViewBase<> > *), 0)};
+              $descriptor(Matrix<FloatT, Array2D_Dense<FloatT>, MatrixViewBase<> > *), 0),
+            SWIG_NewPointerObj(&res,
+              $descriptor(GPS_User_PVT<FloatT> *), 0)};
         proc_call_throw_if_error(hook, sizeof(values) / sizeof(values[0]), values);
       }while(false);
 #endif
@@ -1075,6 +1057,152 @@ struct SBAS_SolverOptions
     }
   }
   %fragment("hook"{GPS_Solver<FloatT>});
+  %ignore update_correction;
+#ifdef SWIGRUBY
+  %fragment("correction"{GPS_Solver<FloatT>}, "header",
+      fragment=SWIG_From_frag(int),
+      fragment=SWIG_Traits_frag(FloatT)){
+    template <>
+    bool GPS_RangeCorrector<FloatT>::is_available(
+        const typename GPS_Solver_Base<FloatT>::gps_time_t &t) const {
+      VALUE values[] = {
+        SWIG_NewPointerObj(
+            %const_cast(&t, GPS_Time<FloatT> *), $descriptor(GPS_Time<FloatT> *), 0),
+      };
+      VALUE res(proc_call_throw_if_error(
+          callback, sizeof(values) / sizeof(values[0]), values));
+      return RTEST(res) ? true : false;
+    }
+    template <>
+    FloatT *GPS_RangeCorrector<FloatT>::calculate(
+        const typename GPS_Solver_Base<FloatT>::gps_time_t &t,
+        const typename GPS_Solver_Base<FloatT>::pos_t &usr_pos, 
+        const typename GPS_Solver_Base<FloatT>::enu_t &sat_rel_pos,
+        FloatT &buf) const {
+      VALUE values[] = {
+        SWIG_NewPointerObj(
+            %const_cast(&t, GPS_Time<FloatT> *),
+            $descriptor(GPS_Time<FloatT> *), 0),
+        SWIG_NewPointerObj(
+            (%const_cast(&usr_pos.xyz, System_XYZ<FloatT, WGS84> *)),
+            $descriptor(System_XYZ<FloatT, WGS84> *), 0),
+        SWIG_NewPointerObj(
+            (%const_cast(&sat_rel_pos, System_ENU<FloatT, WGS84> *)),
+            $descriptor(System_ENU<FloatT, WGS84> *), 0),
+      };
+      VALUE res(proc_call_throw_if_error(
+          callback, sizeof(values) / sizeof(values[0]), values));
+      return SWIG_IsOK(swig::asval(res, &buf)) ? &buf : NULL;
+    }
+    template<>
+    VALUE GPS_Solver<FloatT>::update_correction(
+        const bool &update, const VALUE &hash){
+      typedef range_correction_list_t list_t;
+      static const VALUE k_root[] = {
+        ID2SYM(rb_intern("gps_ionospheric")),
+        ID2SYM(rb_intern("gps_tropospheric")),
+        ID2SYM(rb_intern("sbas_ionospheric")),
+        ID2SYM(rb_intern("sbas_tropospheric")),
+      };
+      static const VALUE k_opt(ID2SYM(rb_intern("options")));
+      static const VALUE k_f_10_7(ID2SYM(rb_intern("f_10_7")));
+      static const VALUE k_known(ID2SYM(rb_intern("known")));
+      struct {
+        VALUE sym;
+        list_t::mapped_type::value_type obj;
+      } item[] = {
+        {ID2SYM(rb_intern("no_correction")), &base_t::no_correction},
+        {ID2SYM(rb_intern("klobuchar")), &this->gps.solver.ionospheric_klobuchar},
+        {ID2SYM(rb_intern("ntcm_gl")), &this->gps.solver.ionospheric_ntcm_gl},
+        {ID2SYM(rb_intern("hopfield")), &this->gps.solver.tropospheric_simplified},
+        {ID2SYM(rb_intern("sbas_igp")), &this->sbas.solver.ionospheric_sbas},
+        {ID2SYM(rb_intern("sbas_tropo")), &this->sbas.solver.tropospheric_sbas},
+      };
+      list_t input;
+      if(update){
+        if(!RB_TYPE_P(hash, T_HASH)){
+          throw std::runtime_error(
+              std::string("Hash is expected, however ").append(inspect_str(hash)));
+        }
+        for(std::size_t i(0); i < sizeof(k_root) / sizeof(k_root[0]); ++i){
+          VALUE ary = rb_hash_lookup(hash, k_root[i]);
+          if(NIL_P(ary)){continue;}
+          if(!RB_TYPE_P(ary, T_ARRAY)){
+            ary = rb_ary_new_from_values(1, &ary);
+          }
+          for(int j(0); j < RARRAY_LEN(ary); ++j){
+            std::size_t k(0);
+            VALUE v(rb_ary_entry(ary, j));
+            for(; k < sizeof(item) / sizeof(item[0]); ++k){
+              if(v == item[k].sym){break;}
+            }
+            if(k >= sizeof(item) / sizeof(item[0])){ // other than symbol
+              user_correctors.push_back(GPS_RangeCorrector<FloatT>(v));
+              input[i].push_back(&user_correctors.back());
+            }else{
+              input[i].push_back(item[k].obj);
+            }
+          }
+        }
+        VALUE opt(rb_hash_lookup(hash, k_opt));
+        if(RB_TYPE_P(opt, T_HASH)){
+          swig::asval(rb_hash_lookup(opt, k_f_10_7), // ntcm_gl
+              &this->gps.solver.ionospheric_ntcm_gl.f_10_7);
+        }
+      }
+      list_t output(update_correction(update, input));
+      VALUE res = rb_hash_new();
+      for(list_t::const_iterator it(output.begin()), it_end(output.end());
+          it != it_end; ++it){
+        VALUE k;
+        if((it->first < 0) || (it->first >= (int)(sizeof(k_root) / sizeof(k_root[0])))){
+          k = SWIG_From(int)(it->first);
+        }else{
+          k = k_root[it->first];
+        }
+        VALUE v = rb_ary_new();
+        for(list_t::mapped_type::const_iterator
+              it2(it->second.begin()), it2_end(it->second.end());
+            it2 != it2_end; ++it2){
+          std::size_t i(0);
+          for(; i < sizeof(item) / sizeof(item[0]); ++i){
+            if(*it2 == item[i].obj){break;}
+          }
+          if(i >= sizeof(item) / sizeof(item[0])){ // other than built-in corrector
+            rb_ary_push(v, 
+                reinterpret_cast<const GPS_RangeCorrector<FloatT> *>(*it2)->callback);
+          }else{
+            rb_ary_push(v, item[i].sym);
+          }
+        }
+        rb_hash_aset(res, k, v);
+      }
+      { // common options
+        VALUE opt = rb_hash_new();
+        rb_hash_aset(res, k_opt, opt);
+        rb_hash_aset(opt, k_f_10_7, // ntcm_gl 
+            swig::from(this->gps.solver.ionospheric_ntcm_gl.f_10_7));
+      }
+      { // known models
+        VALUE ary = rb_ary_new_capa((int)(sizeof(item) / sizeof(item[0])));
+        for(std::size_t i(0); i < sizeof(item) / sizeof(item[0]); ++i){
+          rb_ary_push(ary, item[i].sym);
+        }
+        rb_hash_aset(res, k_known, ary);
+      }
+      return res;
+    }
+  }
+  %fragment("correction"{GPS_Solver<FloatT>});
+  %rename("correction") get_correction;
+  %rename("correction=") set_correction;
+  VALUE get_correction() const {
+    return const_cast<GPS_Solver<FloatT> *>(self)->update_correction(false, Qnil);
+  }
+  VALUE set_correction(VALUE hash){
+    return self->update_correction(true, hash);
+  }
+#endif
 }
 %inline {
 template <class FloatT>
@@ -1097,19 +1225,36 @@ struct GPS_Solver
     sbas_t() : space_node(), options(), solver(space_node) {}
   } sbas;
   SWIG_Object hooks;
+  typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
+  user_correctors_t user_correctors;
 #ifdef SWIGRUBY
   static void mark(void *ptr){
     GPS_Solver<FloatT> *solver = (GPS_Solver<FloatT> *)ptr;
-    if(solver->hooks == Qnil){return;}
     rb_gc_mark(solver->hooks);
+    for(typename user_correctors_t::const_iterator 
+          it(solver->user_correctors.begin()), it_end(solver->user_correctors.end());
+        it != it_end; ++it){
+      rb_gc_mark(it->callback);
+    }
   }
 #endif
-  GPS_Solver() : super_t(), gps(), sbas(), hooks() {
-    gps.solver.space_node_sbas = &sbas.space_node;
-    sbas.solver.space_node_gps = &gps.space_node;
+  GPS_Solver() : super_t(),
+      gps(), sbas(),
+      hooks(), user_correctors() {
 #ifdef SWIGRUBY
     hooks = rb_hash_new();
 #endif
+    typename base_t::range_correction_t ionospheric, tropospheric;
+    ionospheric.push_back(&sbas.solver.ionospheric_sbas);
+    ionospheric.push_back(&gps.solver.ionospheric_klobuchar);
+    tropospheric.push_back(&sbas.solver.tropospheric_sbas);
+    tropospheric.push_back(&gps.solver.tropospheric_simplified);
+    gps.solver.ionospheric_correction
+        = sbas.solver.ionospheric_correction
+        = ionospheric;
+    gps.solver.tropospheric_correction
+        = sbas.solver.tropospheric_correction
+        = tropospheric;
   }
   GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
   GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
@@ -1149,6 +1294,53 @@ struct GPS_Solver
     const_cast<sbas_t &>(sbas).solver.update_options(sbas.options);
     return super_t::solve().user_pvt(measurement.items, receiver_time);
   }
+  typedef 
+      std::map<int, std::vector<const typename base_t::range_corrector_t *> >
+      range_correction_list_t;
+  range_correction_list_t update_correction(
+      const bool &update,
+      const range_correction_list_t &list = range_correction_list_t()){
+    range_correction_list_t res;
+    typename base_t::range_correction_t *root[] = {
+      &gps.solver.ionospheric_correction,
+      &gps.solver.tropospheric_correction,
+      &sbas.solver.ionospheric_correction,
+      &sbas.solver.tropospheric_correction,
+    };
+    for(std::size_t i(0); i < sizeof(root) / sizeof(root[0]); ++i){
+      do{
+        if(!update){break;}
+        typename range_correction_list_t::const_iterator it(list.find(i));
+        if(it == list.end()){break;}
+
+        // Remove user defined unused correctors
+        for(typename base_t::range_correction_t::const_iterator
+              it2(root[i]->begin()), it2_end(root[i]->end());
+            it2 != it2_end; ++it2){
+          for(typename user_correctors_t::const_iterator
+                it3(user_correctors.begin()), it3_end(user_correctors.end());
+              it3 != it3_end; ++it3){
+            if(*it2 != &(*it3)){continue;}
+            user_correctors.erase(it3);
+          }
+        }
+
+        root[i]->clear();
+        for(typename range_correction_list_t::mapped_type::const_iterator
+              it2(it->second.begin()), it2_end(it->second.end());
+            it2 != it2_end; ++it2){
+          root[i]->push_back(*it2);
+        }
+      }while(false);
+      for(typename base_t::range_correction_t::const_iterator
+            it(root[i]->begin()), it_end(root[i]->end());
+          it != it_end; ++it){
+        res[i].push_back(*it);
+      }
+    }
+    return res;
+  }
+  SWIG_Object update_correction(const bool &update, const SWIG_Object &hash);
 };
 }