Merge pull request #147 from gnss-sdr/revert-146-speed_up_observables

Revert "Modify observables history"

src/algorithms/libs/gnss_circular_deque.h

@@ -1,213 +0,0 @@
-/*!
- * \file gnss_circular_deque.h
- * \brief This class implements a circular deque for Gnss_Synchro
- *
- * \author Luis Esteve, 2018. antonio.ramos(at)cttc.es
- *
- * Detailed description of the file here if needed.
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2018  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#ifndef GNSS_SDR_CIRCULAR_DEQUE_H_
-#define GNSS_SDR_CIRCULAR_DEQUE_H_
-
-template <class T>
-class Gnss_circular_deque
-{
-public:
-    Gnss_circular_deque();
-    Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann);
-    ~Gnss_circular_deque();
-    unsigned int size(const unsigned int ch);
-    T& at(const unsigned int ch, const unsigned int pos);
-    T& front(const unsigned int ch);
-    T& back(const unsigned int ch);
-    void push_back(const unsigned int ch, const T& new_data);
-    T pop_front(const unsigned int ch);
-    void clear(const unsigned int ch);
-    T* get_vector(const unsigned int ch);
-
-private:
-    T** d_history;
-    T d_return_void;  // Void object for avoid compiler errors
-    unsigned int* d_index_pop;
-    unsigned int* d_index_push;
-    unsigned int* d_size;
-    unsigned int d_max_size;
-    unsigned int d_nchannels;
-};
-
-
-template <class T>
-Gnss_circular_deque<T>::Gnss_circular_deque()
-{
-    d_max_size = 0;
-    d_nchannels = 0;
-    d_size = nullptr;
-    d_index_pop = nullptr;
-    d_index_push = nullptr;
-    d_history = nullptr;
-}
-
-template <class T>
-Gnss_circular_deque<T>::Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann)
-{
-    d_max_size = max_size;
-    d_nchannels = nchann;
-    if (d_max_size > 0 and d_nchannels > 0)
-        {
-            d_size = new unsigned int[d_nchannels];
-            d_index_pop = new unsigned int[d_nchannels];
-            d_index_push = new unsigned int[d_nchannels];
-            d_history = new T*[d_nchannels];
-            for (unsigned int i = 0; i < d_nchannels; i++)
-                {
-                    d_size[i] = 0;
-                    d_index_pop[i] = 0;
-                    d_index_push[i] = 0;
-                    d_history[i] = new T[d_max_size];
-                }
-        }
-}
-
-template <class T>
-Gnss_circular_deque<T>::~Gnss_circular_deque()
-{
-    if (d_max_size > 0 and d_nchannels > 0)
-        {
-            delete[] d_size;
-            delete[] d_index_pop;
-            delete[] d_index_push;
-            for (unsigned int i = 0; i < d_nchannels; i++)
-                {
-                    delete[] d_history[i];
-                }
-            delete[] d_history;
-        }
-}
-
-template <class T>
-unsigned int Gnss_circular_deque<T>::size(const unsigned int ch)
-{
-    return d_size[ch];
-}
-
-template <class T>
-T& Gnss_circular_deque<T>::back(const unsigned int ch)
-{
-    if (d_size[ch] > 0)
-        {
-            unsigned int index = 0;
-            if (d_index_push[ch] > 0)
-                {
-                    index = d_index_push[ch] - 1;
-                }
-            else
-                {
-                    index = d_max_size;
-                }
-            return d_history[ch][index];
-        }
-    else
-        {
-            return d_return_void;
-        }
-}
-
-template <class T>
-T& Gnss_circular_deque<T>::front(const unsigned int ch)
-{
-    if (d_size[ch] > 0)
-        {
-            return d_history[ch][d_index_pop[ch]];
-        }
-    else
-        {
-            return d_return_void;
-        }
-}
-
-template <class T>
-T& Gnss_circular_deque<T>::at(const unsigned int ch, const unsigned int pos)
-{
-    if (d_size[ch] > 0 and pos < d_size[ch])
-        {
-            unsigned int index = (d_index_pop[ch] + pos) % d_max_size;
-            return d_history[ch][index];
-        }
-    else
-        {
-            return d_return_void;
-        }
-}
-
-template <class T>
-void Gnss_circular_deque<T>::clear(const unsigned int ch)
-{
-    d_size[ch] = 0;
-    d_index_pop[ch] = 0;
-    d_index_push[ch] = 0;
-}
-
-template <class T>
-T Gnss_circular_deque<T>::pop_front(const unsigned int ch)
-{
-    T result;
-    if (d_size[ch] > 0)
-        {
-            d_size[ch]--;
-            result = d_history[ch][d_index_pop[ch]];
-            d_index_pop[ch]++;
-            d_index_pop[ch] %= d_max_size;
-        }
-    return result;
-}
-
-template <class T>
-void Gnss_circular_deque<T>::push_back(const unsigned int ch, const T& new_data)
-{
-    d_history[ch][d_index_push[ch]] = new_data;
-    d_index_push[ch]++;
-    d_index_push[ch] %= d_max_size;
-    if (d_size[ch] < d_max_size)
-        {
-            d_size[ch]++;
-        }
-    else
-        {
-            d_index_pop[ch]++;
-            d_index_pop[ch] %= d_max_size;
-        }
-}
-
-template <class T>
-T* Gnss_circular_deque<T>::get_vector(const unsigned int ch)
-{
-    return d_history[ch];
-}
-
-
-#endif /* GNSS_SDR_CIRCULAR_DEQUE_H_ */

src/algorithms/observables/adapters/CMakeLists.txt

@@ -26,7 +26,6 @@ include_directories(
      ${CMAKE_SOURCE_DIR}/src/core/interfaces
      ${CMAKE_SOURCE_DIR}/src/core/receiver
      ${CMAKE_SOURCE_DIR}/src/algorithms/observables/gnuradio_blocks
-     ${CMAKE_SOURCE_DIR}/src/algorithms/libs
      ${CMAKE_SOURCE_DIR}/src/algorithms/PVT/libs
      ${GLOG_INCLUDE_DIRS}
      ${GFlags_INCLUDE_DIRS}

src/algorithms/observables/gnuradio_blocks/CMakeLists.txt

@@ -39,8 +39,8 @@ list(SORT OBS_GR_BLOCKS_HEADERS)
 add_library(obs_gr_blocks ${OBS_GR_BLOCKS_SOURCES} ${OBS_GR_BLOCKS_HEADERS})
 source_group(Headers FILES ${OBS_GR_BLOCKS_HEADERS})
 if(MATIO_FOUND)
-    add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE})
+    add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE})
 else(MATIO_FOUND)
-    add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION})
+    add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION})
 endif(MATIO_FOUND)
-target_link_libraries(obs_gr_blocks gnss_sp_libs ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES})
+target_link_libraries(obs_gr_blocks ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES})

src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc

@@ -66,7 +66,11 @@ hybrid_observables_cc::hybrid_observables_cc(unsigned int nchannels_in,
     max_delta = 0.15;     // 150 ms
     valid_channels.resize(d_nchannels, false);
     d_num_valid_channels = 0;
-    d_gnss_synchro_history = Gnss_circular_deque<Gnss_Synchro>(200, d_nchannels);
+
+    for (unsigned int i = 0; i < d_nchannels; i++)
+        {
+            d_gnss_synchro_history.push_back(std::deque<Gnss_Synchro>());
+        }
 
     // ############# ENABLE DATA FILE LOG #################
     if (d_dump)
@@ -298,37 +302,15 @@ int hybrid_observables_cc::save_matfile()
 }
 
 
-bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, const unsigned int &ch, const double &ti)
+bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, std::deque<Gnss_Synchro> &data, const double &ti)
 {
-    if ((ti < d_gnss_synchro_history.front(ch).RX_time) or (ti > d_gnss_synchro_history.back(ch).RX_time))
+    if ((ti < data.front().RX_time) or (ti > data.back().RX_time))
         {
             return false;
         }
-    std::pair<unsigned int, unsigned int> ind = find_interp_elements(ch, ti);
+    std::deque<Gnss_Synchro>::iterator it;
 
-    double m = 0.0;
+    arma::vec t = arma::vec(data.size());
-    double c = 0.0;
-
-    // CARRIER PHASE INTERPOLATION
-
-    m = (d_gnss_synchro_history.at(ch, ind.first).Carrier_phase_rads - d_gnss_synchro_history.at(ch, ind.second).Carrier_phase_rads) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time);
-    c = d_gnss_synchro_history.at(ch, ind.first).Carrier_phase_rads - m * d_gnss_synchro_history.at(ch, ind.first).RX_time;
-    out.Carrier_phase_rads = m * ti + c;
-
-    // CARRIER DOPPLER INTERPOLATION
-    m = (d_gnss_synchro_history.at(ch, ind.first).Carrier_Doppler_hz - d_gnss_synchro_history.at(ch, ind.second).Carrier_Doppler_hz) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time);
-    c = d_gnss_synchro_history.at(ch, ind.first).Carrier_Doppler_hz - m * d_gnss_synchro_history.at(ch, ind.first).RX_time;
-    out.Carrier_Doppler_hz = m * ti + c;
-
-    // TOW INTERPOLATION
-    m = (d_gnss_synchro_history.at(ch, ind.first).TOW_at_current_symbol_s - d_gnss_synchro_history.at(ch, ind.second).TOW_at_current_symbol_s) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time);
-    c = d_gnss_synchro_history.at(ch, ind.first).TOW_at_current_symbol_s - m * d_gnss_synchro_history.at(ch, ind.first).RX_time;
-    out.TOW_at_current_symbol_s = m * ti + c;
-
-    return true;
-
-    /*
-    arma::vec t = arma::vec(d_gnss_synchro_history.size(ch));
     arma::vec dop = t;
     arma::vec cph = t;
     arma::vec tow = t;
@@ -354,7 +336,6 @@ bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, const unsigned i
     out.TOW_at_current_symbol_s = result(0);
 
     return result.is_finite();
-    */
 }
 
 
@@ -370,48 +351,6 @@ double hybrid_observables_cc::compute_T_rx_s(const Gnss_Synchro &a)
         }
 }
 
-std::pair<unsigned int, unsigned int> hybrid_observables_cc::find_interp_elements(const unsigned int &ch, const double &ti)
-{
-    unsigned int closest = 0;
-    double dif = std::numeric_limits<double>::max();
-    double dt = 0.0;
-    for (unsigned int i = 0; i < d_gnss_synchro_history.size(ch); i++)
-        {
-            dt = std::fabs(ti - d_gnss_synchro_history.at(ch, i).RX_time);
-            if (dt < dif)
-                {
-                    dif = dt;
-                    closest = i;
-                }
-        }
-    unsigned int index1;
-    unsigned int index2;
-    if (closest == 0)
-        {
-            index1 = 0;
-            index2 = 1;
-        }
-    else if (closest == (d_gnss_synchro_history.size(ch) - 1))
-        {
-            index1 = d_gnss_synchro_history.size(ch) - 2;
-            index2 = d_gnss_synchro_history.size(ch) - 1;
-        }
-    else
-        {
-            if (d_gnss_synchro_history.at(ch, closest).RX_time < ti)
-                {
-                    index1 = closest;
-                    index2 = closest + 1;
-                }
-            else
-                {
-                    index1 = closest - 1;
-                    index2 = closest;
-                }
-        }
-    return std::pair<unsigned int, unsigned int>(index1, index2);
-}
-
 
 void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)),
     gr_vector_int &ninput_items_required)
@@ -424,13 +363,13 @@ void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)),
 }
 
 
-void hybrid_observables_cc::clean_history(Gnss_circular_deque<Gnss_Synchro> &data, unsigned int pos)
+void hybrid_observables_cc::clean_history(std::deque<Gnss_Synchro> &data)
 {
-    while (data.size(pos) > 0)
+    while (data.size() > 0)
         {
-            if ((T_rx_s - data.front(pos).RX_time) > max_delta)
+            if ((T_rx_s - data.front().RX_time) > max_delta)
                 {
-                    data.pop_front(pos);
+                    data.pop_front();
                 }
             else
                 {
@@ -515,9 +454,11 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
         }
     //////////////////////////////////////////////////////////////////////////
 
+    std::vector<std::deque<Gnss_Synchro>>::iterator it;
     if (total_input_items > 0)
         {
-            for (unsigned int i = 0; i < d_nchannels; i++)
+            i = 0;
+            for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++)
                 {
                     if (ninput_items[i] > 0)
                         {
@@ -526,25 +467,26 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
                                 {
                                     if (in[i][aux].Flag_valid_word)
                                         {
-                                            d_gnss_synchro_history.push_back(i, in[i][aux]);
+                                            it->push_back(in[i][aux]);
-                                            d_gnss_synchro_history.back(i).RX_time = compute_T_rx_s(in[i][aux]);
+                                            it->back().RX_time = compute_T_rx_s(in[i][aux]);
                                             // Check if the last Gnss_Synchro comes from the same satellite as the previous ones
-                                            if (d_gnss_synchro_history.size(i) > 1)
+                                            if (it->size() > 1)
                                                 {
-                                                    if (d_gnss_synchro_history.front(i).PRN != d_gnss_synchro_history.back(i).PRN)
+                                                    if (it->front().PRN != it->back().PRN)
                                                         {
-                                                            d_gnss_synchro_history.clear(i);
+                                                            it->clear();
                                                         }
                                                 }
                                         }
                                 }
                             consume(i, ninput_items[i]);
                         }
+                    i++;
                 }
         }
     for (i = 0; i < d_nchannels; i++)
         {
-            if (d_gnss_synchro_history.size(i) > 2)
+            if (d_gnss_synchro_history.at(i).size() > 2)
                 {
                     valid_channels[i] = true;
                 }
@@ -564,8 +506,8 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
         {
             if (valid_channels[i])
                 {
-                    clean_history(d_gnss_synchro_history, i);
+                    clean_history(d_gnss_synchro_history.at(i));
-                    if (d_gnss_synchro_history.size(i) < 2)
+                    if (d_gnss_synchro_history.at(i).size() < 2)
                         {
                             valid_channels[i] = false;
                         }
@@ -581,12 +523,13 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
         }
 
     std::vector<Gnss_Synchro> epoch_data;
-    for (unsigned int i = 0; i < d_nchannels; i++)
+    i = 0;
+    for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++)
         {
             if (valid_channels[i])
                 {
-                    Gnss_Synchro interpolated_gnss_synchro = d_gnss_synchro_history.back(i);
+                    Gnss_Synchro interpolated_gnss_synchro = it->back();
-                    if (interpolate_data(interpolated_gnss_synchro, i, T_rx_s_out))
+                    if (interpolate_data(interpolated_gnss_synchro, *it, T_rx_s_out))
                         {
                             epoch_data.push_back(interpolated_gnss_synchro);
                         }
@@ -595,6 +538,7 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
                             valid_channels[i] = false;
                         }
                 }
+            i++;
         }
     d_num_valid_channels = valid_channels.count();
     if (d_num_valid_channels == 0)
@@ -602,14 +546,14 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
             return 0;
         }
     correct_TOW_and_compute_prange(epoch_data);
-    std::vector<Gnss_Synchro>::iterator it = epoch_data.begin();
+    std::vector<Gnss_Synchro>::iterator it2 = epoch_data.begin();
     for (i = 0; i < d_nchannels; i++)
         {
             if (valid_channels[i])
                 {
-                    out[i][0] = (*it);
+                    out[i][0] = (*it2);
                     out[i][0].Flag_valid_pseudorange = true;
-                    it++;
+                    it2++;
                 }
             else
                 {

src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h

@@ -35,12 +35,12 @@
 #define GNSS_SDR_HYBRID_OBSERVABLES_CC_H
 
 #include "gnss_synchro.h"
-#include "gnss_circular_deque.h"
 #include <gnuradio/block.h>
 #include <boost/dynamic_bitset.hpp>
 #include <fstream>
 #include <string>
-#include <utility>
+#include <vector>
+#include <deque>
 
 
 class hybrid_observables_cc;
@@ -65,15 +65,14 @@ private:
     friend hybrid_observables_cc_sptr
     hybrid_make_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename);
     hybrid_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename);
-    void clean_history(Gnss_circular_deque<Gnss_Synchro>& data, unsigned int pos);
+    void clean_history(std::deque<Gnss_Synchro>& data);
     double compute_T_rx_s(const Gnss_Synchro& a);
-    bool interpolate_data(Gnss_Synchro& out, const unsigned int& ch, const double& ti);
+    bool interpolate_data(Gnss_Synchro& out, std::deque<Gnss_Synchro>& data, const double& ti);
-    std::pair<unsigned int, unsigned int> find_interp_elements(const unsigned int& ch, const double& ti);
     void correct_TOW_and_compute_prange(std::vector<Gnss_Synchro>& data);
     int save_matfile();
 
     //Tracking observable history
-    Gnss_circular_deque<Gnss_Synchro> d_gnss_synchro_history;
+    std::vector<std::deque<Gnss_Synchro>> d_gnss_synchro_history;
     boost::dynamic_bitset<> valid_channels;
     double T_rx_s;
     double T_rx_step_s;