Merge pull request #311 from swift-nav/peregrine_updates

Peregrine updates

Author: cbeighley

python/requirements.txt

@@ -1,5 +1,5 @@
-cython>=0.17
-numpy>=1.9
+cython==0.23.4
+numpy==1.10.4
 flake8==2.3.0
 pep8==1.5.7
 pytest==2.6.4

python/swiftnav/nav_msg.pyx

@@ -31,6 +31,9 @@ cdef class NavMsg:
   def from_dict(self, d):
     self._thisptr = d
 
+  def __reduce__(self):
+    return (rebuild_NavMsg, tuple(self.to_dict().items()))
+
   def update(self, bit_val):
     return nav_msg_update(&self._thisptr, bit_val)
 
@@ -40,3 +43,59 @@ cdef class NavMsg:
   def process_subframe(self, e):
     cdef ephemeris_t tmp = e._thisptr
     return process_subframe(&self._thisptr, &tmp)
+
+  def __richcmp__(self, other, op):
+    """
+    Weird Cython comparison method. See
+    http://docs.cython.org/src/userguide/special_methods.html.
+    """
+    if op == 2:
+      return self._equal(other)
+    elif op == 3:
+      return not self._equal(other)
+    else:
+      raise NotImplementedError
+
+  def _equal(self, other):
+    """
+    Compare equality between self and another :class:`NavMsg` object.
+
+    Parameters
+    ----------
+    other : :class:`NavMsg` object
+      The :class:`NavMsg` to test equality against.
+
+    Return
+    ------
+    out : bool
+      True if the passed :class:`NavMsg` object is identical.
+
+    """
+    if self.to_dict().keys() != other.to_dict().keys():
+      return False
+
+    for k in self.to_dict().keys():
+      if self.to_dict()[k] != other.to_dict()[k]:
+        return False
+
+    return True
+
+
+def rebuild_NavMsg(reduced):
+  """
+  Rebuild NavMsg for unpickling.
+
+  Parameters
+  ----------
+  reduced: tuple
+    Tuple of dict of NavMsg nav_msg_t struct fields
+
+  Returns
+  -------
+  out: :class:`NavMsg` instance
+    Rebuilt :class:`NavMsg` instance
+  """
+  nm = NavMsg()
+  nm.from_dict(dict(reduced))
+  return nm
+

python/swiftnav/track.pyx

@@ -25,6 +25,7 @@ from libc.stdlib cimport malloc, free
 from libc.string cimport memset, memcpy
 from signal cimport GNSSSignal
 from signal import GNSSSignal
+from numpy import real, imag
 
 # Discriminators
 
@@ -236,19 +237,18 @@ cdef class AidedTrackingLoop:
   """
 
   def __cinit__(self, **kwargs):
-    self._thisptr = kwargs
     aided_tl_init(&self._thisptr,
-                  self._thisptr.loop_freq,
-                  self._thisptr.code_freq,
-                  self._thisptr.code_bw,
-                  self._thisptr.code_zeta,
-                  self._thisptr.code_k,
-                  self._thisptr.carr_to_code,
-                  self._thisptr.carr_freq,
-                  self._thisptr.carr_bw,
-                  self._thisptr.carr_zeta,
-                  self._thisptr.carr_k,
-                  self._thisptr.carr_freq_b1)
+                  kwargs['loop_freq'],
+                  kwargs['code_freq'],
+                  kwargs['code_bw'],
+                  kwargs['code_zeta'],
+                  kwargs['code_k'],
+                  kwargs['carr_to_code'],
+                  kwargs['carr_freq'],
+                  kwargs['carr_bw'],
+                  kwargs['carr_zeta'],
+                  kwargs['carr_k'],
+                  kwargs['carr_freq_b1'])
 
 
   def retune(self, code_params, carr_params, loop_freq, carr_freq_igain, carr_to_code):
@@ -277,16 +277,18 @@ cdef class AidedTrackingLoop:
                             self.carr_bw, self.carr_zeta, self.carr_k,
                             self.carr_freq_igain)
 
-  def update(self, cs):
+  def update(self, E, P, L):
     """
     Wraps the function :libswiftnav:`aided_tl_update`.
 
     Parameters
     ----------
-    cs : [complex], :math:`I_E + Q_E j`
-      The early correlation. The real component contains the in-phase
-      correlation and the imaginary component contains the quadrature
-      correlation. The prompt correlation. The late correlation.
+    E : [complex], :math:`I_E + Q_E j`
+      Complex Early Correlation
+    P : [complex], :math:`I_P + Q_P j`
+      Complex Prompt Correlation
+    L : [complex], :math:`I_L + Q_L j`
+      Complex Late Correlation
 
     Returns
     -------
@@ -295,11 +297,17 @@ cdef class AidedTrackingLoop:
 
     """
     cdef correlation_t cs_[3]
-    cs_[0] = cs[0]._thisptr
-    cs_[1] = cs[1]._thisptr
-    cs_[2] = cs[2]._thisptr
+    cs_[0].I = real(E)
+    cs_[0].Q = imag(E)
+    cs_[1].I = real(P)
+    cs_[1].Q = imag(P)
+    cs_[2].I = real(L)
+    cs_[2].Q = imag(L)
     aided_tl_update(&self._thisptr, cs_)
-    return (self.code_freq, self.carr_freq)
+    return (self._thisptr.code_freq, self._thisptr.carr_freq)
+
+  def to_dict(self):
+    return self._thisptr
 
 cdef class CompTrackingLoop:
   """
@@ -396,10 +404,10 @@ cdef class CN0Estimator:
 
   def __cinit__(self, **kwargs):
     cn0_est_init(&self._thisptr,
-                 self._thisptr.bw,
-                 self._thisptr.cn0_0,
-                 self._thisptr.cutoff_freq,
-                 self._thisptr.loop_freq)
+                 kwargs['bw'],
+                 kwargs['cn0_0'],
+                 kwargs['cutoff_freq'],
+                 kwargs['loop_freq'])
 
   def update(self, I, Q):
     """

python/tests/test_nav_msg.py

@@ -15,4 +15,63 @@ def test_imports():
   """Verify that distributed packages survive setuptools installation.
 
   """
-  assert True
+  assert True
+
+def build_nav_msg():
+  """ Instantiate NavMsg with known attribute values. """
+  nm = swiftnav.nav_msg.NavMsg()
+  nm.from_dict(
+    {
+      'bit_polarity': -1,
+      'frame_words': [[0, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0, 0, 0, 0]],
+      'next_subframe_id': 1,
+      'overrun': False,
+      'subframe_bit_index': 0,
+      'subframe_bits': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      'subframe_start_index': 0
+    }
+  )
+  return nm
+
+def test_instantiate():
+  nm = swiftnav.nav_msg.NavMsg()
+
+def test_build_nav_msg():
+  build_nav_msg()
+
+def test_equal():
+  nm_a = build_nav_msg()
+  nm_b = build_nav_msg()
+
+  # Change nm_b's fields slightly.
+  nm_b_dict = nm_b.to_dict()
+  nm_b_dict['bit_polarity'] = 1
+  nm_b.from_dict(nm_b_dict)
+
+  assert nm_a._equal(nm_a)
+  assert nm_b._equal(nm_b)
+  assert not nm_a._equal(nm_b)
+  assert not nm_b._equal(nm_a)
+
+def test_richcmp():
+  nm_a = build_nav_msg()
+  nm_b = build_nav_msg()
+
+  # Change nm_b's fields slightly.
+  nm_b_dict = nm_b.to_dict()
+  nm_b_dict['bit_polarity'] = 1
+  nm_b.from_dict(nm_b_dict)
+
+  assert nm_a == nm_a
+  assert not(nm_a != nm_a)
+  assert nm_a != nm_b
+  assert not(nm_a == nm_b)
+
+def test_rebuild():
+  nm = build_nav_msg()
+
+  rebuild, args = nm.__reduce__()
+
+  assert rebuild(args) == nm