gps_pvt 0.8.0 → 0.8.1

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

@@ -201,6 +201,11 @@ template <class InputT> \
 static u ## bits ## _t name(const InputT *buf){ \
   return parser_t::template bits2num<u ## bits ## _t, InputT>( \
       buf, offset_bits, length); \
+} \
+template <class BufferT> \
+static void name ## _set(BufferT *dest, const u ## bits ## _t &src){ \
+  parser_t::template num2bits<u ## bits ## _t, BufferT>( \
+      dest, src, offset_bits, length); \
 }
 #define convert_s(bits, offset_bits, length, name) \
 template <class InputT> \
@@ -208,12 +213,22 @@ static s ## bits ## _t name(const InputT *buf){ \
   return (s ## bits ## _t)parser_t::template bits2num<u ## bits ## _t, InputT>( \
         buf, offset_bits) \
       >> (bits - length); \
+} \
+template <class BufferT> \
+static void name ## _set(BufferT *dest, const s ## bits ## _t &src){ \
+  parser_t::template num2bits<u ## bits ## _t, BufferT>( \
+      dest, *(u ## bits ## _t *)(&src), offset_bits, length); \
 }
 #define convert_u_ch(bits, offset_bits, length, bits_per_ch, name) \
 template <class InputT> \
 static u ## bits ## _t name(const InputT *buf, const uint_t &ch){ \
   return parser_t::template bits2num<u ## bits ## _t>( \
       buf, offset_bits + (bits_per_ch * ch), length); \
+} \
+template <class BufferT> \
+static void name ## _set(BufferT *dest, const uint_t &ch, const u ## bits ## _t &src){ \
+  parser_t::template num2bits<u ## bits ## _t, BufferT>( \
+      dest, src, offset_bits + (bits_per_ch * ch), length); \
 }
 #define convert_s_ch(bits, offset_bits, length, bits_per_ch, name) \
 template <class InputT> \
@@ -221,6 +236,11 @@ static s ## bits ## _t name(const InputT *buf, const uint_t &ch){ \
   return (s ## bits ## _t)parser_t::template bits2num<u ## bits ## _t>( \
         buf, offset_bits + (bits_per_ch * ch)) \
       >> (bits - length); \
+} \
+template <class BufferT> \
+static void name ## _set(BufferT *dest, const uint_t &ch, const s ## bits ## _t &src){ \
+  parser_t::template num2bits<u ## bits ## _t, BufferT>( \
+      dest, *(u ## bits ## _t *)(&src), offset_bits + (bits_per_ch * ch), length); \
 }
 
       /**
@@ -254,8 +274,55 @@ static s ## bits ## _t name(const InputT *buf, const uint_t &ch){ \
       }
 
       convert_u(8, 0, 8, preamble);
+      template <class BufferT>
+      static void preamble_set2(BufferT *dest, const unsigned int &index = 0){
+        static const u8_t preamble_list[] = {0x53, 0x9A, 0xC6};
+        preamble_set(dest, preamble_list[index % 3]);
+      }
       convert_u(8, 8, 6, message_type);
 
+      convert_u(32, 226, 24, parity);
+      /**
+       * update parity bits based on current buffer
+       * @param buf buffer
+       * @see SBAS MOPS (DO-229) A.4.3.3
+       */
+      template <class BufferT>
+      static void parity_set(BufferT *dst){
+        // CRC-24Q
+        static const u32_t poly(0x1864CFBu);
+        static const struct tbl_t {
+          u32_t fw[0x100];
+          tbl_t() {
+            for(int i(0); i < 0x100; ++i){
+              fw[i] = i << 16;
+              for(int j(0); j < 8; ++j){
+                fw[i] <<= 1;
+                if(fw[i] & 0x1000000u){fw[i] ^= poly;}
+              }
+            }
+          }
+        } tbl;
+        u32_t crc(0);
+        u8_t buf;
+        int bit_idx(0);
+        for(int bytes(226 / 8); bytes > 0; bytes--, bit_idx += 8){
+          buf = parser_t::template bits2num<u8_t, BufferT>(dst, bit_idx, 8);
+          crc = (((crc << 8) & 0xFFFF00) | buf) ^ tbl.fw[(crc >> 16) & 0xFF];
+        }
+        buf = parser_t::template bits2num<u8_t, BufferT>(dst, bit_idx, 8);
+        for(unsigned char mask(0x80); bit_idx < 226; bit_idx++, mask >>= 1){
+          crc <<= 1;
+          if(buf & mask){crc |= 1;}
+          if(crc & 0x1000000u){crc ^= poly;}
+        }
+        for(int i(0); i < 3; i++){ // forward operation for padding
+          unsigned int cache(tbl.fw[(crc >> 16) & 0xFF]);
+          crc = (((crc << 8) ^ cache) & 0xFFFF00) | (cache & 0xFF);
+        }
+        parity_set(dst, crc);
+      }
+
       struct Type1 { ///< @see Fig. A-6 PRN_MASK
         struct mask_t {
           u8_t valid;
@@ -1838,6 +1905,18 @@ sf[SF_ ## TARGET] * msg_t::TARGET(buf)
               };
               return res;
             }
+            template <class BufferT>
+            void dump(BufferT *dst){
+              typedef typename DataBlock::Type9 msg_t;
+#define dump_item(name) msg_t:: name ## _set(dst, name)
+              DataBlock::message_type_set(dst, 9);
+              msg_t::t0_set(dst, t_0);  msg_t::ura_set(dst, URA);
+              dump_item(x);   dump_item(y);   dump_item(z);
+              dump_item(dx);  dump_item(dy);  dump_item(dz);
+              dump_item(ddx); dump_item(ddy); dump_item(ddz);
+              dump_item(a_Gf0); dump_item(a_Gf1);
+#undef dump_item
+            }
 
             enum {
               SF_t_0,
@@ -1873,13 +1952,13 @@ sf[SF_ ## TARGET] * msg_t::TARGET(buf)
 
             raw_t &operator=(const Ephemeris &eph){
 #define CONVERT3(TARGET_DST, TARGET_SRC, TARGET_SF) \
-{TARGET_DST = (s32_t)((TARGET_SRC + 0.5 * sf[SF_ ## TARGET_SF]) / sf[SF_ ## TARGET_SF]);}
-#define CONVERT2(TARGET, TARGET_SF) CONVERT3(eph.TARGET, eph.TARGET, TARGET_SF)
+{TARGET_DST = std::floor((TARGET_SRC / sf[SF_ ## TARGET_SF]) + 0.5);}
+#define CONVERT2(TARGET, TARGET_SF) CONVERT3(TARGET, eph.TARGET, TARGET_SF)
 #define CONVERT(TARGET) CONVERT2(TARGET, TARGET)
               svid = eph.svid;
 
               URA = URA_index(eph.URA);
-              CONVERT3(t_0, std::fmod(t_0, gps_time_t::seconds_day), t_0);
+              CONVERT3(t_0, std::fmod(eph.t_0, gps_time_t::seconds_day), t_0);
               CONVERT2(x, xy);      CONVERT2(y, xy);      CONVERT(z);
               CONVERT2(dx, dxy);    CONVERT2(dy, dxy);    CONVERT(dz);
               CONVERT2(ddx, ddxy);  CONVERT2(ddy, ddxy);  CONVERT(ddz);
@@ -1992,7 +2071,7 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET_SF]){break;}
           float_t dx, dy, dz; ///< ECEF velocity (m/s)
           float_t t_0;        ///< Time of applicability (s)
 
-          ///< Up-cast to ephemeris
+          ///< Upgrade to ephemeris
           operator Ephemeris() const {
             Ephemeris converted = {
               prn,        // Satellite number
@@ -2006,6 +2085,14 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET_SF]){break;}
             };
             return converted;
           }
+          ///< Downgrade from ephemeris
+          Almanac &operator=(const Ephemeris &eph) {
+            prn = eph.svid;
+            t_0 = eph.t_0;
+            x = eph.x; y = eph.y; z = eph.z;
+            dx = eph.dx; dy = eph.dy; dz = eph.dz;
+            return *this;
+          }
 
           struct raw_t {
             u8_t data_id;
@@ -2028,6 +2115,21 @@ if(std::abs(TARGET - eph.TARGET) > raw_t::sf[raw_t::SF_ ## TARGET_SF]){break;}
               };
               return res;
             }
+            template <class BufferT>
+            void dump(BufferT *dst, const uint_t &ch = 0){
+              typedef typename DataBlock::Type17 msg_t;
+#define dump_item(name) msg_t:: name ## _set(dst, ch, name)
+              if(ch == 0){
+                DataBlock::message_type_set(dst, 17);
+                msg_t::t0_set(dst, t_0);
+              }
+              msg_t::id_set(dst, ch, data_id);
+              dump_item(prn);
+              msg_t::health_status_set(dst, ch, SV_health);
+              dump_item(x);   dump_item(y);   dump_item(z);
+              dump_item(dx);  dump_item(dy);  dump_item(dz);
+#undef dump_item
+            }
 
             enum {
               SF_xy,  SF_z,

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

@@ -43,25 +43,31 @@
 
 #include <vector>
 
-template <int denom, int pow2 = 1, int log2 = 0, int rem2 = denom % pow2>
-struct const_div_t : public std::div_t {
-  const_div_t(const int &num) : std::div_t(std::div(num, denom)) {}
-};
-template <int denom, int pow2, int log2>
-struct const_div_t<denom, pow2, log2, 0> : public const_div_t<denom, (pow2 << 1), log2 + 1> {
-  const_div_t(const int &num) : const_div_t<denom, (pow2 << 1), log2 + 1>(num) {}
-};
-template <int denom, int log2>
-struct const_div_t<denom, denom, log2, 0> {
-  int quot, rem;
-  const_div_t(const int &num) : quot(num >> log2), rem(num & (denom - 1)) {}
-};
+#include "util/bit_counter.h"
 
 template <int MAX_SIZE, class ContainerT = unsigned char>
 struct BitArray {
+
+  template <int denom, int pow2 = 1, int log2 = 0, int rem2 = denom % pow2>
+  struct const_div_t : public std::div_t {
+    const_div_t(const int &num) : std::div_t(std::div(num, denom)) {}
+  };
+  template <int denom, int pow2, int log2>
+  struct const_div_t<denom, pow2, log2, 0> : public const_div_t<denom, (pow2 << 1), log2 + 1> {
+    const_div_t(const int &num) : const_div_t<denom, (pow2 << 1), log2 + 1>(num) {}
+  };
+  template <int denom, int log2>
+  struct const_div_t<denom, denom, log2, 0> {
+    int quot, rem;
+    const_div_t(const int &num) : quot(num >> log2), rem(num & (denom - 1)) {}
+  };
+
   static const int bits_per_addr = (int)sizeof(ContainerT) * CHAR_BIT;
   static const int max_size = MAX_SIZE;
+  static const const_div_t<bits_per_addr> prop;
   ContainerT buf[(MAX_SIZE + bits_per_addr - 1) / bits_per_addr];
+  static const ContainerT mask_rem;
+
   void set(const bool &new_bit = false) {
     std::memset(buf, (new_bit ? (~0) : 0), sizeof(buf));
   }
@@ -125,12 +131,35 @@ struct BitArray {
       return (unsigned int)res;
     }
   }
+  int ones() const {
+    int res(0);
+    for(int i(0); i < prop.quot; ++i){
+      res += BitCounter<ContainerT>::count(buf[i]);
+    }
+    if(prop.rem){
+      res += BitCounter<ContainerT>::count(
+          buf[(sizeof(buf) / sizeof(buf[0])) - 1] & mask_rem);
+    }
+    return res;
+  }
+  int least_index_one() const {
+    int res(0);
+    for(int i(0); prop.quot; ++i){
+      int ntz(BitCounter<ContainerT>::ntz(buf[i]));
+      res += ntz;
+      if(ntz < bits_per_addr){return res;}
+    }
+    if(prop.rem){
+      res += BitCounter<ContainerT>::ntz(
+          buf[(sizeof(buf) / sizeof(buf[0])) - 1] & mask_rem);
+    }
+    return res;
+  }
   std::vector<int> indices_one(const int &offset = 0) const {
     std::vector<int> res;
     int idx(offset);
-    static const const_div_t<bits_per_addr> qr(MAX_SIZE);
-    int rem(qr.rem), i(0);
-    for(; i < qr.quot; ++i, idx += bits_per_addr){
+    int rem(prop.rem), i(0);
+    for(; i < prop.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);}
@@ -143,4 +172,12 @@ struct BitArray {
   }
 };
 
+template <int MAX_SIZE, class ContainerT>
+const typename BitArray<MAX_SIZE, ContainerT>::template const_div_t<BitArray<MAX_SIZE, ContainerT>::bits_per_addr>
+    BitArray<MAX_SIZE, ContainerT>::prop
+      = typename BitArray<MAX_SIZE, ContainerT>::template const_div_t<BitArray<MAX_SIZE, ContainerT>::bits_per_addr>(MAX_SIZE);
+
+template <int MAX_SIZE, class ContainerT>
+const ContainerT BitArray<MAX_SIZE, ContainerT>::mask_rem = ((ContainerT)0x1 << prop.rem) - 1;
+
 #endif /* __BIT_ARRAY_H__ */

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

@@ -273,6 +273,25 @@ struct GPS_Ionospheric_UTC_Parameters : public GPS_SpaceNode<FloatT>::Ionospheri
     (typename GPS_SpaceNode<FloatT>::Ionospheric_UTC_Parameters &)res = raw;
     return res;
   }
+  %typemap(in,numinputs=0) unsigned int buf_brdc[ANY] (unsigned int temp[$1_dim0] = {0}) "$1 = temp;"
+  %typemap(argout) unsigned int buf_brdc[ANY] {
+    for(int i(0); i < $1_dim0; ++i){
+      %append_output(SWIG_From(unsigned int)(($1)[i]));
+    }
+  }
+  /**
+   * Return broadcasted raw data related to ionospheric and UTC parameters.
+   * @param buf_brdc pointer to store raw data of subframe 4 page 18.
+   * Each 30bit length word (MSB 2 bits are padding) is stored in each successive address of the pointer.
+   * @param t GPS time at broadcasting
+   */
+  void dump(unsigned int buf_brdc[10], const GPS_Time<FloatT> &t){
+    typedef typename GPS_SpaceNode<FloatT>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    dump_t::how_set(buf_brdc, t);
+    GPS_SpaceNode<FloatT>::Ionospheric_UTC_Parameters::raw_t raw;
+    (raw = *self).dump<2, 0>(buf_brdc);
+  }
 }
 
 %inline %{
@@ -287,6 +306,11 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
         || (this->iode != this->iode_subframe3)
         || ((this->iodc & 0xFF) != this->iode));
   }
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return is_consistent() && GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
+  }
+  GPS_Time<FloatT> t_clock() const {return GPS_Time<FloatT>(this->WN, this->t_oc);}
+  GPS_Time<FloatT> t_ephemeris() const {return GPS_Time<FloatT>(this->WN, this->t_oe);}
   GPS_Ephemeris() : GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {
     invalidate();
   }
@@ -303,7 +327,7 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
   MAKE_ACCESSOR(svid, unsigned int);
           
   MAKE_ACCESSOR(WN, unsigned int);
-  MAKE_ACCESSOR(URA, int);
+  MAKE_ACCESSOR(URA, FloatT);
   MAKE_ACCESSOR(SV_health, unsigned int);
   MAKE_ACCESSOR(iodc, int);
   MAKE_ACCESSOR(t_GD, FloatT);
@@ -384,6 +408,83 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
         break;
     }
   }
+  %apply unsigned int buf_brdc[ANY] {
+      unsigned int buf_sf1[10], unsigned int buf_sf2[10], unsigned int buf_sf3[10]};
+  /**
+   * Return broadcasted raw data of ephemeris data.
+   * @param buf_sf1 pointer to store raw data of subframe 1.
+   * Each 30bit length word (MSB 2 bits are padding) is stored in each successive address of the pointer.
+   * @param buf_sf2 pointer to store raw data of subframe 2. Its structue is same as sf1.
+   * @param buf_sf3 pointer to store raw data of subframe 3. Its structue is same as sf1.
+   * @param t GPS time at broadcasting
+   */
+  void dump(
+      unsigned int buf_sf1[10], unsigned int buf_sf2[10], unsigned int buf_sf3[10],
+      const GPS_Time<FloatT> &t){
+    typedef typename GPS_SpaceNode<FloatT>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::raw_t raw;
+    raw = *self;
+    unsigned int *buf[10] = {buf_sf1, buf_sf2, buf_sf3};
+    for(int i(0); i < 3; ++i){
+      dump_t::how_set(buf[i], t);
+      raw.dump<2, 0>(buf[i], i + 1);
+    }
+  }
+  int parse_almanac(const unsigned int buf[10]){
+    typedef GPS_SpaceNode<FloatT>::BroadcastedMessage<unsigned int, 30> parse_t;
+    switch(parse_t::subframe_id(buf)){
+      case 4:
+      case 5:
+        break;
+      default: return -1;
+    }
+    typedef GPS_SpaceNode<FloatT>::SatelliteProperties::Almanac almanac_t;
+    almanac_t::raw_t raw;
+    switch(parse_t::data_id(buf)){
+      case 1: // GPS
+        raw.update<2, 0>(buf);
+        if((raw.svid < 1) || (raw.svid > 32)){return -1;}
+        break;
+      case 3: // QZSS
+        reinterpret_cast<QZSS_SpaceNode<FloatT>::SatelliteProperties::Almanac::raw_t &>(raw)
+            .update<2, 0>(buf);
+        if((raw.svid < 193) || (raw.svid > 202)){return -1;}
+        break;
+      default:
+        return -1;
+    }
+    almanac_t almanac;
+    *self = (GPS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris)(almanac = raw);
+    return self->svid;
+  }
+  /**
+   * Return broadcasted raw data of almanac data.
+   * @param buf_brdc pointer to store raw data of subframe 4 or 5.
+   * Each 30bit (MSB 2 bits are padding) length word is stored in each successive address of the pointer.
+   * @param t GPS time at broadcasting
+   * @param qzss_subframe if 4 or 5, this ephemeris is treated as QZSS, otherwise GPS (default).
+   */
+  void dump_almanac(
+      unsigned int buf_brdc[10], const GPS_Time<FloatT> &t,
+      const unsigned int &qzss_subframe = 0){
+    typedef typename GPS_SpaceNode<FloatT>
+        ::BroadcastedMessage<unsigned int, 30> dump_t;
+    dump_t::how_set(buf_brdc, t);
+    typedef GPS_SpaceNode<FloatT>::SatelliteProperties::Almanac almanac_t;
+    almanac_t almanac;
+    almanac_t::raw_t raw;
+    raw = (almanac = *self);
+    switch(qzss_subframe){
+      case 4:
+      case 5:
+        reinterpret_cast<QZSS_SpaceNode<FloatT>::SatelliteProperties::Almanac::raw_t &>(raw)
+            .dump<2, 0>(buf_brdc, qzss_subframe);
+        break;
+      default:
+        raw.dump<2, 0>(buf_brdc);
+    }
+  }
   %typemap(out) constellation_res_t {
     %append_output(SWIG_NewPointerObj((new System_XYZ<FloatT, WGS84>($1.position)), 
         $descriptor(System_XYZ<FloatT, WGS84> *), SWIG_POINTER_OWN));
@@ -402,6 +503,7 @@ struct GPS_Ephemeris : public GPS_SpaceNode<FloatT>::SatelliteProperties::Epheme
   }
 #if defined(SWIGRUBY)
   %rename("consistent?") is_consistent;
+  %rename("valid?") is_valid;
 #endif
 }
 
@@ -444,6 +546,10 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
   SBAS_Ephemeris() : SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris() {}
   SBAS_Ephemeris(const typename SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris &eph) 
       : SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris(eph) {}
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::is_valid(t);
+  }
+  GPS_Time<FloatT> t_applicable() const {return GPS_Time<FloatT>(this->WN, this->t_0);}
 };
 %}
 %extend SBAS_Ephemeris {
@@ -457,6 +563,18 @@ 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);
+  /**
+   * Return broadcasted raw data of SBAS ephemeris
+   * @param buf_brdc pointer to store raw data of Type 9 message.
+   * 250 of 256 bits are effective, LSB 6 bits of last word are padding.
+   * @param preamble_idx index of preamble, 0(0x53), 1(0x9A), or 2(0xC6)
+   */
+  void dump(unsigned int buf_brdc[8], const unsigned int &preamble_idx = 0){
+    SBAS_SpaceNode<FloatT>::DataBlock::preamble_set2(buf_brdc, preamble_idx);
+    SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephemeris::raw_t raw;
+    (raw = *self).dump(buf_brdc);
+    SBAS_SpaceNode<FloatT>::DataBlock::parity_set(buf_brdc);
+  }
   typename GPS_Ephemeris<FloatT>::constellation_res_t constellation(
       const GPS_Time<FloatT> &t_tx, const FloatT &dt_transit = 0,
       const bool &with_velocity = true) const {
@@ -466,6 +584,9 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
         pv.position, pv.velocity, self->clock_error(t_tx), self->clock_error_dot(t_tx)};
     return res;
   }
+#if defined(SWIGRUBY)
+  %rename("valid?") is_valid;
+#endif
 }
 
 %extend SBAS_SpaceNode {
@@ -519,6 +640,9 @@ struct GLONASS_Ephemeris
   bool is_consistent() const {
     return has_string == 0x1F;
   }
+  bool is_valid(const GPS_Time<FloatT> &t) const {
+    return is_consistent() && eph_t::is_valid(t);
+  }
   GLONASS_Ephemeris() : eph_t() {
     invalidate();
   }
@@ -607,6 +731,31 @@ struct GLONASS_Ephemeris
     self->has_string = has_string;
     return updated;
   }
+  %apply unsigned int buf_brdc[ANY] {
+      unsigned int buf_str1[3], unsigned int buf_str2[3], unsigned int buf_str3[3],
+      unsigned int buf_str4[3], unsigned int buf_str5[3]};
+  /**
+   * Return broadcasted raw data of GLONASS ephemeris data.
+   * @param buf_str1 pointer to store raw data of string 1.
+   * 85bit length data (LSB 11 bits are padding) is stored in successive address of the pointer.
+   * @param buf_str2 pointer to store raw data of string 2. Its structue is same as str1.
+   * @param buf_str3 pointer to store raw data of string 3. Its structue is same as str1.
+   * @param buf_str4 pointer to store raw data of string 4. Its structue is same as str1.
+   * @param buf_str5 pointer to store raw data of string 5. Its structue is same as str1.
+   * @param t GPS time at broadcasting
+   */
+  void dump(
+      unsigned int buf_str1[3], unsigned int buf_str2[3], unsigned int buf_str3[3],
+      unsigned int buf_str4[3], unsigned int buf_str5[3],
+      const GPS_Time<FloatT> &t){
+    typename GLONASS_Ephemeris<FloatT>::eph_t::raw_t raw;
+    raw = *self;
+    unsigned int *buf[4] = {buf_str1, buf_str2, buf_str3, buf_str4};
+    for(int i(0); i < 4; ++i){
+      raw.GLONASS_Ephemeris<FloatT>::Ephemeris::raw_t::dump<0, 0>(buf[i], i + 1);
+    }
+    raw.GLONASS_Ephemeris<FloatT>::TimeProperties::raw_t::dump<0, 0>(buf_str5);
+  }
   typename GPS_Ephemeris<FloatT>::constellation_res_t constellation(
       const GPS_Time<FloatT> &t_tx, const FloatT &dt_transit = 0) const {
     typename GPS_SpaceNode<FloatT>::SatelliteProperties::constellation_t pv(
@@ -617,6 +766,7 @@ struct GLONASS_Ephemeris
   }
 #if defined(SWIGRUBY)
   %rename("consistent?") is_consistent;
+  %rename("valid?") is_valid;
   %rename("in_range?") is_in_range;
 #endif
   bool is_in_range(const GPS_Time<FloatT> &t) const {
@@ -1081,6 +1231,43 @@ struct GPS_RangeCorrector
 };
 }
 
+%{
+template <class BaseT, class HookT>
+struct HookableSolver : public BaseT {
+  typedef BaseT base_t;
+  HookT *hook;
+  HookableSolver(const BaseT &base) : BaseT(base), hook(NULL) {}
+  virtual typename base_t::relative_property_t relative_property(
+      const typename base_t::prn_t &prn,
+      const typename base_t::measurement_t::mapped_type &measurement,
+      const typename base_t::float_t &receiver_error,
+      const typename base_t::gps_time_t &time_arrival,
+      const typename base_t::pos_t &usr_pos,
+      const typename base_t::xyz_t &usr_vel) const {
+    typename base_t::relative_property_t res(
+        base_t::relative_property(
+          prn, measurement, receiver_error, time_arrival,
+          usr_pos, usr_vel));
+    if(hook){
+      res = hook->relative_property(
+          prn, measurement, receiver_error, time_arrival,
+          usr_pos, usr_vel,
+          res);
+    }
+    return res;
+  }
+  virtual typename base_t::satellite_t select_satellite(
+      const typename base_t::prn_t &prn,
+      const typename base_t::gps_time_t &time) const {
+    typename base_t::satellite_t res(base_t::select_satellite(prn, time));
+    if(hook){
+      res = hook->select_satellite(prn, time, res);
+    }
+    return res;
+  }
+};
+%}
+
 %extend GPS_Solver {
   %ignore super_t;
   %ignore base_t;
@@ -1090,7 +1277,7 @@ struct GPS_RangeCorrector
   %ignore sbas;
   %ignore glonass_t;
   %ignore glonass;
-  %ignore select_solver;
+  %ignore select;
   %ignore relative_property;
   %ignore select_satellite;
   %ignore update_position_solution;
@@ -1110,14 +1297,12 @@ struct GPS_RangeCorrector
           const GPS_Solver<FloatT>::base_t::float_t &receiver_error,
           const GPS_Solver<FloatT>::base_t::gps_time_t &time_arrival,
           const GPS_Solver<FloatT>::base_t::pos_t &usr_pos,
-          const GPS_Solver<FloatT>::base_t::xyz_t &usr_vel) const {
+          const GPS_Solver<FloatT>::base_t::xyz_t &usr_vel,
+          const GPS_Solver<FloatT>::base_t::relative_property_t &res_orig) const {
       union {
         base_t::relative_property_t prop;
         FloatT values[7];
-      } res = {
-          select_solver(prn).relative_property(
-            prn, measurement, receiver_error, time_arrival,
-            usr_pos, usr_vel)};
+      } res = {res_orig};
 #ifdef SWIGRUBY
       do{
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
@@ -1197,9 +1382,9 @@ struct GPS_RangeCorrector
     template <>
     GPS_Solver<FloatT>::base_t::satellite_t GPS_Solver<FloatT>::select_satellite(
         const GPS_Solver<FloatT>::base_t::prn_t &prn,
-        const GPS_Solver<FloatT>::base_t::gps_time_t &time) const {
-      GPS_Solver<FloatT>::base_t::satellite_t res(
-          select_solver(prn).select_satellite(prn, time));
+        const GPS_Solver<FloatT>::base_t::gps_time_t &time,
+        const GPS_Solver<FloatT>::base_t::satellite_t &res_orig) const {
+      GPS_Solver<FloatT>::base_t::satellite_t res(res_orig);
 #ifdef SWIGRUBY
       if(!res.is_available()){
         static const VALUE key(ID2SYM(rb_intern("relative_property")));
@@ -1396,7 +1581,7 @@ struct GPS_Solver
   struct gps_t {
     GPS_SpaceNode<FloatT> space_node;
     GPS_SolverOptions<FloatT> options;
-    GPS_SinglePositioning<FloatT> solver;
+    HookableSolver<GPS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
     struct ephemeris_proxy_t {
       struct item_t {
         const void *impl;
@@ -1418,19 +1603,19 @@ struct GPS_Solver
         solver.satellites.impl_select = forward;
       }
     } ephemeris_proxy;
-    gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {}
+    gps_t() : space_node(), options(), solver(GPS_SinglePositioning<FloatT>(space_node)), ephemeris_proxy(solver) {}
   } gps;
   struct sbas_t {
     SBAS_SpaceNode<FloatT> space_node;
     SBAS_SolverOptions<FloatT> options;
-    SBAS_SinglePositioning<FloatT> solver;
-    sbas_t() : space_node(), options(), solver(space_node) {}
+    HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
+    sbas_t() : space_node(), options(), solver(SBAS_SinglePositioning<FloatT>(space_node)) {}
   } sbas;
   struct glonass_t {
     GLONASS_SpaceNode<FloatT> space_node;
     GLONASS_SolverOptions<FloatT> options;
-    GLONASS_SinglePositioning<FloatT> solver;
-    glonass_t() : space_node(), options(), solver(space_node) {}
+    HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
+    glonass_t() : space_node(), options(), solver(GLONASS_SinglePositioning<FloatT>(space_node)) {}
   } glonass;
   SWIG_Object hooks;
   typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
@@ -1465,6 +1650,9 @@ struct GPS_Solver
         = sbas.solver.tropospheric_correction
         = glonass.solver.tropospheric_correction
         = tropospheric;
+    gps.solver.hook = this;
+    sbas.solver.hook = this;
+    glonass.solver.hook = this;
   }
   GPS_SpaceNode<FloatT> &gps_space_node() {return gps.space_node;}
   GPS_SolverOptions<FloatT> &gps_options() {return gps.options;}
@@ -1472,28 +1660,44 @@ struct GPS_Solver
   SBAS_SolverOptions<FloatT> &sbas_options() {return sbas.options;}
   GLONASS_SpaceNode<FloatT> &glonass_space_node() {return glonass.space_node;}
   GLONASS_SolverOptions<FloatT> &glonass_options() {return glonass.options;}
-  const base_t &select_solver(
+  const base_t &select(
       const typename base_t::prn_t &prn) const {
     if(prn > 0 && prn <= 32){return gps.solver;}
     if(prn >= 120 && prn <= 158){return sbas.solver;}
     if(prn > 192 && prn <= 202){return gps.solver;}
     if(prn > 0x100 && prn <= (0x100 + 24)){return glonass.solver;}
-    // call order: base_t::solve => this returned by select() 
-    //     => relative_property() => select_solver()
-    // For not supported satellite, call loop prevention is required.
-    static const base_t dummy; 
-    return dummy;
+    return *this;
   }
+  // proxy of virtual functions
+  typename base_t::relative_property_t relative_property(
+      const typename base_t::prn_t &prn,
+      const typename base_t::measurement_t::mapped_type &measurement,
+      const typename base_t::float_t &receiver_error,
+      const typename base_t::gps_time_t &time_arrival,
+      const typename base_t::pos_t &usr_pos,
+      const typename base_t::xyz_t &usr_vel,
+      const typename base_t::relative_property_t &orig) const;
   virtual typename base_t::relative_property_t relative_property(
       const typename base_t::prn_t &prn,
       const typename base_t::measurement_t::mapped_type &measurement,
       const typename base_t::float_t &receiver_error,
       const typename base_t::gps_time_t &time_arrival,
       const typename base_t::pos_t &usr_pos,
-      const typename base_t::xyz_t &usr_vel) const;
+      const typename base_t::xyz_t &usr_vel) const {
+    return relative_property(
+        prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel,
+        super_t::relative_property(
+          prn, measurement, receiver_error, time_arrival, usr_pos, usr_vel));
+  }
+  typename base_t::satellite_t select_satellite(
+      const typename base_t::prn_t &prn,
+      const typename base_t::gps_time_t &time,
+      const typename base_t::satellite_t &orig) const;
   virtual typename base_t::satellite_t select_satellite(
       const typename base_t::prn_t &prn,
-      const typename base_t::gps_time_t &time) const;
+      const typename base_t::gps_time_t &time) const {
+    return select_satellite(prn, time, super_t::select_satellite(prn, time));
+  }
   virtual bool update_position_solution(
       const typename base_t::geometric_matrices_t &geomat,
       typename base_t::user_pvt_t &res) const;