Merge branch 'antonioramosdet-obs_sys_test' into next

src/algorithms/PVT/libs/rinex_printer.cc

@@ -409,8 +409,6 @@ std::string Rinex_Printer::getLocalTime()
 void Rinex_Printer::rinex_nav_header(std::fstream& out, const Galileo_Iono& iono, const Galileo_Utc_Model& utc_model, const Galileo_Almanac& galileo_almanac)
 {
     std::string line;
-    stringVersion = "3.02";
-    version = 3;
 
     // -------- Line 1
     line = std::string(5, ' ');
@@ -815,8 +813,6 @@ void Rinex_Printer::rinex_nav_header(std::fstream& out, const Gps_Iono& iono, co
 void Rinex_Printer::rinex_nav_header(std::fstream& out, const Gps_Iono& gps_iono, const Gps_Utc_Model& gps_utc_model, const Galileo_Iono& galileo_iono, const Galileo_Utc_Model& galileo_utc_model, const Galileo_Almanac& galileo_almanac)
 {
     std::string line;
-    stringVersion = "3.02";
-    version = 3;
 
     // -------- Line 1
     line = std::string(5, ' ');
@@ -2909,11 +2905,10 @@ void Rinex_Printer::rinex_obs_header(std::fstream & out, const Gps_Ephemeris & e
 void Rinex_Printer::rinex_obs_header(std::fstream& out, const Galileo_Ephemeris& eph, const double d_TOW_first_observation, const std::string bands)
 {
     std::string line;
-    version = 3;
 
     // -------- Line 1
     line = std::string(5, ' ');
-    line += "3.02";
+    line += stringVersion;
     line += std::string(11, ' ');
     line += Rinex_Printer::leftJustify("OBSERVATION DATA", 20);
     line += satelliteSystem["Galileo"];
@@ -3171,11 +3166,10 @@ void Rinex_Printer::rinex_obs_header(std::fstream& out, const Gps_Ephemeris& gps
 {
     if(galileo_eph.e_1){} // avoid warning, not needed
     std::string line;
-    version = 3;
 
     // -------- Line 1
     line = std::string(5, ' ');
-    line += "3.02";
+    line += stringVersion;
     line += std::string(11, ' ');
     line += Rinex_Printer::leftJustify("OBSERVATION DATA", 20);
     line += satelliteSystem["Mixed"];

src/algorithms/input_filter/adapters/freq_xlating_fir_filter.cc

@@ -412,8 +412,8 @@ void FreqXlatingFirFilter::init()
         {
     	    double default_bw = 2000000.0;
     	    double bw_ = config_->property(role_ + ".bw", default_bw);
-    	    double default_tw = bw_ / 20.0;
+    	    double default_tw = bw_ / 10.0;
     	    double tw_ = config_->property(role_ + ".tw", default_tw);
-    	    taps_ = gr::filter::firdes::low_pass(1.0, sampling_freq_, bw_ / 2.0, tw_);
+    	    taps_ = gr::filter::firdes::low_pass(1.0, sampling_freq_, bw_, tw_);
     	}
 }

src/algorithms/input_filter/adapters/pulse_blanking_filter.cc

@@ -44,6 +44,7 @@ PulseBlankingFilter::PulseBlankingFilter(ConfigurationInterface* configuration,
                         out_streams_(out_streams)
 {
     size_t item_size;
+    xlat_ = false;
     std::string default_input_item_type = "gr_complex";
     std::string default_output_item_type = "gr_complex";
     std::string default_dump_filename = "../data/input_filter.dat";
@@ -79,6 +80,7 @@ PulseBlankingFilter::PulseBlankingFilter(ConfigurationInterface* configuration,
     double if_ = config_->property(role_ + ".IF", if_aux);
     if (std::abs(if_) > 1.0)
         {
+            xlat_ = true;
             double default_sampling_freq = 4000000.0;
             double sampling_freq_ = config_->property(role_ + ".sampling_frequency", default_sampling_freq);
             double default_bw = 2000000.0;
@@ -111,7 +113,7 @@ void PulseBlankingFilter::connect(gr::top_block_sptr top_block)
                 {
                     top_block->connect(pulse_blanking_cc_, 0, file_sink_, 0);
                 }
-            if (std::abs(config_->property(role_ + ".if", 0.0)) > 1.0)
+            if (xlat_)
                 {
                     top_block->connect(freq_xlating_, 0, pulse_blanking_cc_, 0);
                 }
@@ -133,7 +135,7 @@ void PulseBlankingFilter::disconnect(gr::top_block_sptr top_block)
                 {
                     top_block->disconnect(pulse_blanking_cc_, 0, file_sink_, 0);
                 }
-            if (std::abs(config_->property(role_ + ".if", 0.0)) > 1.0)
+            if (xlat_)
                 {
                     top_block->disconnect(freq_xlating_, 0, pulse_blanking_cc_, 0);
                 }
@@ -149,7 +151,7 @@ gr::basic_block_sptr PulseBlankingFilter::get_left_block()
 {
     if (input_item_type_.compare("gr_complex") == 0)
         {
-            if (std::abs(config_->property(role_ + ".if", 0.0)) > 1.0)
+            if (xlat_)
                 {
                     return freq_xlating_;
                 }

src/algorithms/input_filter/adapters/pulse_blanking_filter.h

@@ -73,6 +73,7 @@ public:
 private:
     ConfigurationInterface* config_;
     bool dump_;
+    bool xlat_;
     std::string dump_filename_;
     std::string input_item_type_;
     size_t input_size_;

src/tests/CMakeLists.txt

@@ -412,7 +412,7 @@ if(ENABLE_SYSTEM_TESTING)
     add_definitions(-DHOST_SYSTEM="${HOST_SYSTEM}")
     set(TTFF_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/ttff_gps_l1.cc)
     
-    # Ensure that ttff is rebuild if was previously built and then removed
+    # Ensure that ttff is rebuilt if it was previously built and then removed
     if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/ttff)
         execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${TTFF_SOURCES})     
     endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/ttff)
@@ -452,7 +452,7 @@ if(ENABLE_SYSTEM_TESTING)
 
     if(ENABLE_SYSTEM_TESTING_EXTRA)
         set(POSITION_TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/position_test.cc)
-        # Ensure that position_test is rebuild if was previously built and then removed
+        # Ensure that position_test is rebuilt if it was previously built and then removed
         if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
             execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${POSITION_TEST_SOURCES})     
         endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
@@ -490,15 +490,25 @@ if(ENABLE_SYSTEM_TESTING)
 
         if(GPSTK_FOUND OR OWN_GPSTK)
             set(OBS_GPS_L1_TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/obs_gps_l1_system_test.cc)
-            # Ensure that obs_gps_l1_system_test is rebuild if was previously built and then removed
+            # Ensure that obs_gps_l1_system_test is rebuilt if it was previously built and then removed
             if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
                 execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${OBS_GPS_L1_TEST_SOURCES})     
             endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
             add_executable(obs_gps_l1_system_test ${OBS_GPS_L1_TEST_SOURCES})
+            
+            set(OBS_SYSTEM_TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/obs_system_test.cc)
+            # Ensure that obs_system_test is rebuilt if it was previously built and then removed
+            if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+                execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${OBS_SYSTEM_TEST_SOURCES})     
+            endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+            add_executable(obs_system_test ${OBS_SYSTEM_TEST_SOURCES})
+            
             if(NOT ${GTEST_DIR_LOCAL})
                 add_dependencies(obs_gps_l1_system_test gtest-${GNSSSDR_GTEST_LOCAL_VERSION} )
+                add_dependencies(obs_system_test gtest-${GNSSSDR_GTEST_LOCAL_VERSION} )
             else(NOT ${GTEST_DIR_LOCAL})
                 add_dependencies(obs_gps_l1_system_test gtest)
+                add_dependencies(obs_system_test gtest)
             endif(NOT ${GTEST_DIR_LOCAL})
             include_directories(${GPSTK_INCLUDE_DIRS} ${GPSTK_INCLUDE_DIRS}/gpstk)
             target_link_libraries(obs_gps_l1_system_test ${GFlags_LIBS}
@@ -507,16 +517,32 @@ if(ENABLE_SYSTEM_TESTING)
                                                          gnss_sp_libs
                                                          gnss_rx
                                                          ${gpstk_libs})
+                                                         
+            target_link_libraries(obs_system_test ${GFlags_LIBS}
+                                                  ${GLOG_LIBRARIES}
+                                                  ${GTEST_LIBRARIES}
+                                                  gnss_sp_libs
+                                                  gnss_rx
+                                                  ${gpstk_libs})
 
             if(ENABLE_INSTALL_TESTS)
                 if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
                     file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
                 endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
                 install(TARGETS obs_gps_l1_system_test RUNTIME DESTINATION bin COMPONENT "obs_gps_l1_system_test")
+                if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+                    file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+                endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+                install(TARGETS obs_gps_l1_system_test RUNTIME DESTINATION bin COMPONENT "obs_gps_l1_system_test")
+                install(TARGETS obs_system_test RUNTIME DESTINATION bin COMPONENT "obs_system_test")
             else(ENABLE_INSTALL_TESTS)
                 add_custom_command(TARGET obs_gps_l1_system_test POST_BUILD
                                    COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:obs_gps_l1_system_test>
                                    ${CMAKE_SOURCE_DIR}/install/$<TARGET_FILE_NAME:obs_gps_l1_system_test> )
+                add_custom_command(TARGET obs_system_test POST_BUILD
+                                   COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:obs_system_test>
+                                   ${CMAKE_SOURCE_DIR}/install/$<TARGET_FILE_NAME:obs_system_test> )
+
             endif(ENABLE_INSTALL_TESTS)
         endif(GPSTK_FOUND OR OWN_GPSTK)
     else(ENABLE_SYSTEM_TESTING_EXTRA)
@@ -526,7 +552,10 @@ if(ENABLE_SYSTEM_TESTING)
         endif(EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
         if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
            file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
-        endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)      
+        endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
+        if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+           file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+        endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
     endif(ENABLE_SYSTEM_TESTING_EXTRA)
 else(ENABLE_SYSTEM_TESTING)
     # Avoid working with old executables if they were switched ON and then OFF
@@ -538,7 +567,10 @@ else(ENABLE_SYSTEM_TESTING)
     endif(EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
     if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
        file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
-    endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)   
+    endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
+    if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+       file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_system_test)
+    endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)    
 endif(ENABLE_SYSTEM_TESTING)
 
 

src/tests/system-tests/obs_system_test.cc

@@ -0,0 +1,939 @@
+/*!
+ * \file obs_system_test.cc
+ * \brief  This class implements a test for the validation of generated observables.
+ * \author Carles Fernandez-Prades, 2016. cfernandez(at)cttc.es
+ *         Antonio Ramos, 2017. antonio.ramos(at)cttc.es
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2017  (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/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include <algorithm>
+#include <chrono>
+#include <boost/filesystem.hpp>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <numeric>
+#include <string>
+#include <thread>
+#include <unistd.h>
+#include <armadillo>
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+#include <gpstk/RinexUtilities.hpp>
+#include <gpstk/Rinex3ObsBase.hpp>
+#include <gpstk/Rinex3ObsData.hpp>
+#include <gpstk/Rinex3ObsHeader.hpp>
+#include <gpstk/Rinex3ObsStream.hpp>
+#include "gnuplot_i.h"
+#include "test_flags.h"
+#include "concurrent_map.h"
+#include "concurrent_queue.h"
+#include "control_thread.h"
+#include "file_configuration.h"
+
+// For GPS NAVIGATION (L1)
+concurrent_queue<Gps_Acq_Assist> global_gps_acq_assist_queue;
+concurrent_map<Gps_Acq_Assist> global_gps_acq_assist_map;
+
+DEFINE_string(configuration_file, "./default_configuration.conf", "Path of configuration file");
+DEFINE_string(filename_rinex_true, "./default_rinex.txt", "Path of RINEX true observations");
+DEFINE_string(filename_rinex_obs, "default_string", "Path of RINEX true observations");
+DEFINE_double(pr_error_mean_max, 25.0, "Maximum mean error in pseudorange");
+DEFINE_double(pr_error_std_max, 5.0, "Maximum standard deviation in pseudorange");
+DEFINE_double(cp_error_mean_max, 5.0, "Maximum mean error in carrier phase");
+DEFINE_double(cp_error_std_max, 2.5, "Maximum standard deviation in carrier phase");
+DEFINE_double(dp_error_mean_max, 75.0, "Maximum mean error in Doppler frequency");
+DEFINE_double(dp_error_std_max, 25.0, "Maximum standard deviation in Doppler frequency");
+DEFINE_bool(plot_obs_sys_test, false, "Plots results of ObsSystemTest with gnuplot");
+
+class ObsSystemTest: public ::testing::Test
+{
+public:
+    int configure_receiver();
+    int run_receiver();
+    void check_results();
+    bool check_valid_rinex_obs(std::string filename, int rinex_ver);  // return true if the file is a valid Rinex observation file.
+    void read_rinex_files(
+            std::vector<arma::mat>& pseudorange_ref,
+            std::vector<arma::mat>& carrierphase_ref,
+            std::vector<arma::mat>& doppler_ref,
+            std::vector<arma::mat>& pseudorange_meas,
+            std::vector<arma::mat>& carrierphase_meas,
+            std::vector<arma::mat>& doppler_meas,
+            arma::mat& sow_prn_ref,
+            int signal_type);
+    void time_alignment_diff(
+            std::vector<arma::mat>& ref,
+            std::vector<arma::mat>& meas,
+            std::vector<arma::vec>& diff);
+    void time_alignment_diff_cp(
+            std::vector<arma::mat>& ref,
+            std::vector<arma::mat>& meas,
+            std::vector<arma::vec>& diff);
+    void time_alignment_diff_pr(
+            std::vector<arma::mat>& ref,
+            std::vector<arma::mat>& meas,
+            std::vector<arma::vec>& diff,
+            arma::mat& sow_prn_ref);
+    void compute_pseudorange_error(std::vector<arma::vec>& diff,
+            double error_th_mean, double error_th_std,
+            std::string signal_name);
+    void compute_carrierphase_error(
+            std::vector<arma::vec>& diff,
+            double error_th_mean, double error_th_std,
+            std::string signal_name);
+    void compute_doppler_error(
+            std::vector<arma::vec>& diff,
+            double error_th_mean, double error_th_std,
+            std::string signal_name);
+    std::string filename_rinex_obs = FLAGS_filename_rinex_true;
+    std::string generated_rinex_obs = FLAGS_filename_rinex_obs;
+    std::string configuration_file_ = FLAGS_configuration_file;
+    std::shared_ptr<FileConfiguration> config;
+    bool gps_1C = false;
+    bool gps_L5 = false;
+    bool gal_1B = false;
+    bool gal_E5a = false;
+    bool internal_rinex_generation = false;
+
+    /****************/
+    const int num_prn_gps = 33;
+    const int num_prn_gal = 31;
+
+    double pseudorange_error_th_mean = FLAGS_pr_error_mean_max;
+    double pseudorange_error_th_std= FLAGS_pr_error_std_max;
+    double carrierphase_error_th_mean = FLAGS_cp_error_mean_max;
+    double carrierphase_error_th_std = FLAGS_cp_error_std_max;
+    double doppler_error_th_mean = FLAGS_dp_error_mean_max;
+    double doppler_error_th_std = FLAGS_dp_error_std_max;
+};
+
+
+bool ObsSystemTest::check_valid_rinex_obs(std::string filename, int rinex_ver)
+{
+    bool res = false;
+    if(rinex_ver == 2)
+        {
+            res = gpstk::isRinexObsFile(filename);
+        }
+    if(rinex_ver == 3)
+        {
+            res = gpstk::isRinex3ObsFile(filename);
+        }
+    return res;
+}
+
+
+void ObsSystemTest::read_rinex_files(
+        std::vector<arma::mat>& pseudorange_ref,
+        std::vector<arma::mat>& carrierphase_ref,
+        std::vector<arma::mat>& doppler_ref,
+        std::vector<arma::mat>& pseudorange_meas,
+        std::vector<arma::mat>& carrierphase_meas,
+        std::vector<arma::mat>& doppler_meas,
+        arma::mat& sow_prn_ref,
+        int signal_type)
+{
+    bool ref_exist = false;
+    bool meas_exist = false;
+    gpstk::SatID::SatelliteSystem sat_type = gpstk::SatID::systemUnknown;
+    int max_prn = 0;
+    std::string pr_string;
+    std::string cp_string;
+    std::string dp_string;
+    std::string signal_type_string;
+    sow_prn_ref.reset();
+
+    switch(signal_type)
+    {
+    case 0: //GPS L1
+
+        sat_type = gpstk::SatID::systemGPS;
+        max_prn = num_prn_gps;
+        pr_string = "C1C";
+        cp_string = "L1C";
+        dp_string = "D1C";
+        signal_type_string = "GPS L1 C/A";
+        break;
+
+    case 1: //Galileo E1B
+
+        sat_type = gpstk::SatID::systemGalileo;
+        max_prn = num_prn_gal;
+        pr_string = "C1B";
+        cp_string = "L1B";
+        dp_string = "D1B";
+        signal_type_string = "Galileo E1B";
+        break;
+
+    case 2: //GPS L5
+
+        sat_type = gpstk::SatID::systemGPS;
+        max_prn = num_prn_gps;
+        pr_string = "C5X";
+        cp_string = "L5X";
+        dp_string = "D5X";
+        signal_type_string = "GPS L5";
+        break;
+
+    case 3: //Galileo E5a
+
+        sat_type = gpstk::SatID::systemGalileo;
+        max_prn = num_prn_gal;
+        pr_string = "C5X";
+        cp_string = "L5X";
+        dp_string = "D5X";
+        signal_type_string = "Galileo E5a";
+        break;
+    }
+
+    // Open and read reference RINEX observables file
+    std::cout << "Read: RINEX " << signal_type_string << " True" << std::endl;
+    try
+    {
+            gpstk::Rinex3ObsStream r_ref(filename_rinex_obs);
+            r_ref.exceptions(std::ios::failbit);
+            gpstk::Rinex3ObsData r_ref_data;
+            gpstk::Rinex3ObsHeader r_ref_header;
+            gpstk::RinexDatum dataobj;
+            r_ref >> r_ref_header;
+
+            while (r_ref >> r_ref_data)
+                {
+                    for (int myprn = 1; myprn < max_prn; myprn++)
+                        {
+                            gpstk::SatID prn( myprn, sat_type);
+                            gpstk::CommonTime time = r_ref_data.time;
+                            double sow(static_cast<gpstk::GPSWeekSecond>(time).sow);
+                            gpstk::Rinex3ObsData::DataMap::iterator pointer = r_ref_data.obs.find(prn);
+                            if( pointer ==  r_ref_data.obs.end() )
+                                {
+                                    // PRN not present; do nothing
+                                }
+                            else
+                                {
+                                    dataobj = r_ref_data.getObs(prn, pr_string,  r_ref_header);
+                                    double P1 = dataobj.data;
+                                    pseudorange_ref.at(myprn).insert_rows(pseudorange_ref.at(myprn).n_rows, arma::rowvec({sow, P1}));
+
+                                    dataobj = r_ref_data.getObs(prn, cp_string,  r_ref_header);
+                                    double L1 = dataobj.data;
+                                    carrierphase_ref.at(myprn).insert_rows(carrierphase_ref.at(myprn).n_rows, arma::rowvec({sow, L1}));
+
+                                    dataobj = r_ref_data.getObs(prn, dp_string,  r_ref_header);
+                                    double D1 = dataobj.data;
+                                    doppler_ref.at(myprn).insert_rows(doppler_ref.at(myprn).n_rows, arma::rowvec({sow, D1}));
+
+                                    ref_exist = true;
+                                }  // End of 'if( pointer == roe.obs.end() )'
+                        } // end for
+                } // end while
+    } // End of 'try' block
+    catch(const gpstk::FFStreamError& e)
+    {
+            std::cout << e;
+            exit(1);
+    }
+    catch(const gpstk::Exception& e)
+    {
+            std::cout << e;
+            exit(1);
+    }
+    catch (...)
+    {
+            std::cout << "unknown error.  I don't feel so well..." << std::endl;
+            exit(1);
+    }
+
+    // Open and read measured RINEX observables file
+    std::cout << "Read: RINEX "<< signal_type_string << " measures" << std::endl;
+    try
+    {
+            std::string arg2_gen;
+            if(internal_rinex_generation)
+                {
+                    arg2_gen = std::string("./") + generated_rinex_obs;
+                }
+            else
+                {
+                    arg2_gen = generated_rinex_obs;
+                }
+            gpstk::Rinex3ObsStream r_meas(arg2_gen);
+            r_meas.exceptions(std::ios::failbit);
+            gpstk::Rinex3ObsData r_meas_data;
+            gpstk::Rinex3ObsHeader r_meas_header;
+            gpstk::RinexDatum dataobj;
+            r_meas >> r_meas_header;
+
+            while (r_meas >> r_meas_data)
+                {
+                    double pr_min = 0.0;
+                    double sow_insert = 0.0;
+                    double prn_min = 0.0;
+                    bool set_pr_min = true;
+                    for (int myprn = 1; myprn < max_prn; myprn++)
+                        {
+                            gpstk::SatID prn( myprn, sat_type);
+                            gpstk::CommonTime time = r_meas_data.time;
+                            double sow(static_cast<gpstk::GPSWeekSecond>(time).sow);
+                            gpstk::Rinex3ObsData::DataMap::iterator pointer = r_meas_data.obs.find(prn);
+                            if( pointer ==  r_meas_data.obs.end() )
+                                {
+                                    // PRN not present; do nothing
+                                }
+                            else
+                                {
+                                    dataobj = r_meas_data.getObs(prn, pr_string,  r_meas_header);
+                                    double P1 = dataobj.data;
+                                    pseudorange_meas.at(myprn).insert_rows(pseudorange_meas.at(myprn).n_rows, arma::rowvec({sow, P1}));
+                                    if(set_pr_min || (P1 < pr_min))
+                                        {
+                                            set_pr_min = false;
+                                            pr_min = P1;
+                                            sow_insert = sow;
+                                            prn_min = static_cast<double>(myprn);
+                                        }
+
+                                    dataobj = r_meas_data.getObs(prn, cp_string,  r_meas_header);
+                                    double L1 = dataobj.data;
+                                    carrierphase_meas.at(myprn).insert_rows(carrierphase_meas.at(myprn).n_rows, arma::rowvec({sow, L1}));
+
+                                    dataobj = r_meas_data.getObs(prn, dp_string,  r_meas_header);
+                                    double D1 = dataobj.data;
+                                    doppler_meas.at(myprn).insert_rows(doppler_meas.at(myprn).n_rows, arma::rowvec({sow, D1}));
+
+                                    meas_exist = true;
+                                }  // End of 'if( pointer == roe.obs.end() )'
+                        } // end for
+                    sow_prn_ref.insert_rows(sow_prn_ref.n_rows, arma::rowvec({sow_insert, pr_min, prn_min}));
+                } // end while
+    } // End of 'try' block
+    catch(const gpstk::FFStreamError& e)
+    {
+            std::cout << e;
+            exit(1);
+    }
+    catch(const gpstk::Exception& e)
+    {
+            std::cout << e;
+            exit(1);
+    }
+    catch (...)
+    {
+            std::cout << "unknown error.  I don't feel so well..." << std::endl;
+            exit(1);
+    }
+    EXPECT_TRUE(ref_exist) << "RINEX reference file does not contain " << signal_type_string << " information";
+    EXPECT_TRUE(meas_exist) << "RINEX generated file does not contain " << signal_type_string << " information";
+}
+
+
+void ObsSystemTest::time_alignment_diff(
+        std::vector<arma::mat>& ref,
+        std::vector<arma::mat>& meas,
+        std::vector<arma::vec>& diff)
+{
+    std::vector<arma::mat>::iterator iter_ref;
+    std::vector<arma::mat>::iterator iter_meas;
+    std::vector<arma::vec>::iterator iter_diff;
+    arma::mat mat_aux;
+
+    iter_ref = ref.begin();
+    iter_diff = diff.begin();
+    for(iter_meas = meas.begin(); iter_meas != meas.end(); iter_meas++)
+        {
+            if( !iter_meas->is_empty() && !iter_ref->is_empty() )
+                {
+                    arma::uvec index_ = arma::find(iter_meas->col(0) > iter_ref->at(0, 0));
+                    arma::uword index_min = arma::min(index_);
+                    index_ = arma::find(iter_meas->col(0) < iter_ref->at(iter_ref->n_rows - 1, 0));
+                    arma::uword index_max = arma::max(index_);
+                    mat_aux = iter_meas->rows(index_min, index_max);
+                    arma::vec ref_aligned;
+                    arma::interp1(iter_ref->col(0), iter_ref->col(1), mat_aux.col(0), ref_aligned);
+                    *iter_diff = ref_aligned - mat_aux.col(1);
+                }
+            iter_ref++;
+            iter_diff++;
+        }
+}
+
+
+void ObsSystemTest::time_alignment_diff_cp(
+        std::vector<arma::mat>& ref,
+        std::vector<arma::mat>& meas,
+        std::vector<arma::vec>& diff)
+{
+    std::vector<arma::mat>::iterator iter_ref;
+    std::vector<arma::mat>::iterator iter_meas;
+    std::vector<arma::vec>::iterator iter_diff;
+    arma::mat mat_aux;
+
+    iter_ref = ref.begin();
+    iter_diff = diff.begin();
+    for(iter_meas = meas.begin(); iter_meas != meas.end(); iter_meas++)
+        {
+            if( !iter_meas->is_empty() && !iter_ref->is_empty() )
+                {
+                    arma::uvec index_ = arma::find(iter_meas->col(0) > iter_ref->at(0, 0));
+                    arma::uword index_min = arma::min(index_);
+                    index_ = arma::find(iter_meas->col(0) < iter_ref->at(iter_ref->n_rows - 1, 0));
+                    arma::uword index_max = arma::max(index_);
+                    mat_aux = iter_meas->rows(index_min, index_max);
+                    mat_aux.col(1) -= arma::min(mat_aux.col(1));
+                    arma::vec ref_aligned;
+                    arma::interp1(iter_ref->col(0), iter_ref->col(1), mat_aux.col(0), ref_aligned);
+                    ref_aligned -= arma::min(ref_aligned);
+                    *iter_diff = ref_aligned - mat_aux.col(1);
+                }
+            iter_ref++;
+            iter_diff++;
+        }
+}
+
+
+void ObsSystemTest::time_alignment_diff_pr(
+        std::vector<arma::mat>& ref,
+        std::vector<arma::mat>& meas,
+        std::vector<arma::vec>& diff,
+        arma::mat& sow_prn_ref)
+{
+    std::vector<arma::mat>::iterator iter_ref;
+    std::vector<arma::mat>::iterator iter_meas;
+    std::vector<arma::vec>::iterator iter_diff;
+    arma::mat mat_aux;
+    arma::vec subtraction_meas;
+    arma::vec subtraction_ref;
+
+    arma::mat subtraction_pr_ref = sow_prn_ref;
+    arma::vec::iterator iter_vec0 = subtraction_pr_ref.begin_col(0);
+    arma::vec::iterator iter_vec1 = subtraction_pr_ref.begin_col(1);
+    arma::vec::iterator iter_vec2 = subtraction_pr_ref.begin_col(2);
+
+    for(iter_vec1 = subtraction_pr_ref.begin_col(1); iter_vec1 != subtraction_pr_ref.end_col(1); iter_vec1++)
+        {
+            arma::vec aux_pr; //vector with only 1 element
+            arma::vec aux_sow = {*iter_vec0}; //vector with only 1 element
+            arma::interp1(ref.at(static_cast<int>(*iter_vec2)).col(0),
+                    ref.at(static_cast<int>(*iter_vec2)).col(1),
+                    aux_sow,
+                    aux_pr);
+            *iter_vec1 = aux_pr(0);
+            iter_vec0++;
+            iter_vec2++;
+        }
+
+    iter_ref = ref.begin();
+    iter_diff = diff.begin();
+    for(iter_meas = meas.begin(); iter_meas != meas.end(); iter_meas++)
+        {
+            if( !iter_meas->is_empty() && !iter_ref->is_empty() )
+                {
+                    arma::uvec index_ = arma::find(iter_meas->col(0) > iter_ref->at(0, 0));
+                    arma::uword index_min = arma::min(index_);
+                    index_ = arma::find(iter_meas->col(0) < iter_ref->at(iter_ref->n_rows - 1, 0));
+                    arma::uword index_max = arma::max(index_);
+                    mat_aux = iter_meas->rows(index_min, index_max);
+                    arma::interp1(sow_prn_ref.col(0), sow_prn_ref.col(1), mat_aux.col(0), subtraction_meas);
+                    mat_aux.col(1) -= subtraction_meas;
+                    arma::vec ref_aligned;
+                    arma::interp1(iter_ref->col(0), iter_ref->col(1), mat_aux.col(0), ref_aligned);
+                    arma::interp1(subtraction_pr_ref.col(0), subtraction_pr_ref.col(1), mat_aux.col(0), subtraction_ref);
+                    ref_aligned -= subtraction_ref;
+                    *iter_diff = ref_aligned - mat_aux.col(1);
+                }
+            iter_ref++;
+            iter_diff++;
+        }
+}
+
+
+int ObsSystemTest::configure_receiver()
+{
+    config = std::make_shared<FileConfiguration>(configuration_file_);
+
+    if( config->property("Channels_1C.count", 0) > 0 )
+        {gps_1C = true;}
+    if( config->property("Channels_1B.count", 0) > 0 )
+        {gal_1B = true;}
+    if( config->property("Channels_5X.count", 0) > 0 )
+        {gal_E5a = true;}
+    if( config->property("Channels_7X.count", 0) > 0 ) //NOT DEFINITIVE!!!!!
+        {gps_L5 = true;}
+
+    return 0;
+}
+
+
+int ObsSystemTest::run_receiver()
+{
+    std::shared_ptr<ControlThread> control_thread;
+    control_thread = std::make_shared<ControlThread>(config);
+    // start receiver
+    try
+    {
+            control_thread->run();
+    }
+    catch(const boost::exception & e)
+    {
+            std::cout << "Boost exception: " << boost::diagnostic_information(e);
+    }
+    catch(const std::exception & ex)
+    {
+            std::cout  << "STD exception: " << ex.what();
+    }
+    // Get the name of the RINEX obs file generated by the receiver
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+    FILE *fp;
+    std::string argum2 = std::string("/bin/ls *O | grep GSDR | tail -1");
+    char buffer[1035];
+    fp = popen(&argum2[0], "r");
+    if (fp == NULL)
+        {
+            std::cout << "Failed to run command: " << argum2 << std::endl;
+            return -1;
+        }
+    while (fgets(buffer, sizeof(buffer), fp) != NULL)
+        {
+            std::string aux = std::string(buffer);
+            generated_rinex_obs = aux.erase(aux.length() - 1, 1);
+            internal_rinex_generation = true;
+        }
+    pclose(fp);
+    return 0;
+}
+
+
+void ObsSystemTest::compute_pseudorange_error(
+        std::vector<arma::vec>& diff,
+        double error_th_mean, double error_th_std,
+        std::string signal_name)
+{
+    int prn_id = 0;
+    std::vector<arma::vec>::iterator iter_diff;
+    std::vector<double> means;
+    std::vector<double> stddevs;
+    std::vector<double> prns;
+    for(iter_diff = diff.begin(); iter_diff != diff.end(); iter_diff++)
+        {
+            if(!iter_diff->is_empty())
+                {
+                    double d_mean = std::sqrt(arma::mean(arma::square(*iter_diff)));
+                    means.push_back(d_mean);
+                    double d_stddev = arma::stddev(*iter_diff);
+                    stddevs.push_back(d_stddev);
+                    prns.push_back(static_cast<double>(prn_id));
+                    std::cout << "-- RMS pseudorange difference for sat " << prn_id << ": " << d_mean;
+                    std::cout << " +/- " << d_stddev;
+                    std::cout << " [m]" << std::endl;
+                    EXPECT_LT(d_mean, error_th_mean);
+                    EXPECT_LT(d_stddev, error_th_std);
+                }
+            prn_id++;
+        }
+    if(FLAGS_plot_obs_sys_test == true)
+        {
+            const std::string gnuplot_executable(FLAGS_gnuplot_executable);
+            if(gnuplot_executable.empty())
+                {
+                    std::cout << "WARNING: Although the flag plot_obs_sys_test has been set to TRUE," << std::endl;
+                    std::cout << "gnuplot has not been found in your system." << std::endl;
+                    std::cout << "Test results will not be plotted." << std::endl;
+                }
+            else
+                {
+                    try
+                    {
+                            boost::filesystem::path p(gnuplot_executable);
+                            boost::filesystem::path dir = p.parent_path();
+                            std::string gnuplot_path = dir.native();
+                            Gnuplot::set_GNUPlotPath(gnuplot_path);
+
+                            Gnuplot g1("linespoints");
+                            g1.set_title(signal_name + " Pseudorange error");
+                            g1.set_grid();
+                            g1.set_xlabel("PRN");
+                            g1.set_ylabel("Pseudorange error [m]");
+                            g1.plot_xy(prns, means, "RMS error");
+                            g1.plot_xy(prns, stddevs, "Standard deviation");
+                            //g1.savetops("FFT_execution_times_extended");
+                            //g1.savetopdf("FFT_execution_times_extended", 18);
+                            g1.showonscreen(); // window output
+                    }
+                    catch (const GnuplotException & ge)
+                    {
+                            std::cout << ge.what() << std::endl;
+                    }
+                }
+        }
+}
+
+
+void ObsSystemTest::compute_carrierphase_error(
+        std::vector<arma::vec>& diff,
+        double error_th_mean, double error_th_std,
+        std::string signal_name)
+{
+    int prn_id = 0;
+    std::vector<double> means;
+    std::vector<double> stddevs;
+    std::vector<double> prns;
+    std::vector<arma::vec>::iterator iter_diff;
+    for(iter_diff = diff.begin(); iter_diff != diff.end(); iter_diff++)
+        {
+            if(!iter_diff->is_empty())
+                {
+                    double d_mean = std::sqrt(arma::mean(arma::square(*iter_diff)));
+                    means.push_back(d_mean);
+                    double d_stddev = arma::stddev(*iter_diff);
+                    stddevs.push_back(d_stddev);
+                    prns.push_back(static_cast<double>(prn_id));
+                    std::cout << "-- RMS carrier phase difference for sat " << prn_id << ": " << d_mean;
+                    std::cout << " +/- " << d_stddev;
+                    std::cout << " whole cycles" << std::endl;
+                    EXPECT_LT(d_mean, error_th_mean);
+                    EXPECT_LT(d_stddev, error_th_std);
+                }
+            prn_id++;
+        }
+    if(FLAGS_plot_obs_sys_test == true)
+        {
+            const std::string gnuplot_executable(FLAGS_gnuplot_executable);
+            if(gnuplot_executable.empty())
+                {
+                    std::cout << "WARNING: Although the flag plot_obs_sys_test has been set to TRUE," << std::endl;
+                    std::cout << "gnuplot has not been found in your system." << std::endl;
+                    std::cout << "Test results will not be plotted." << std::endl;
+                }
+            else
+                {
+                    try
+                    {
+                            boost::filesystem::path p(gnuplot_executable);
+                            boost::filesystem::path dir = p.parent_path();
+                            std::string gnuplot_path = dir.native();
+                            Gnuplot::set_GNUPlotPath(gnuplot_path);
+
+                            Gnuplot g1("linespoints");
+                            g1.set_title(signal_name + " Carrier phase error");
+                            g1.set_grid();
+                            g1.set_xlabel("PRN");
+                            g1.set_ylabel("Carrier phase error [whole cycles]");
+                            g1.plot_xy(prns, means, "RMS error");
+                            g1.plot_xy(prns, stddevs, "Standard deviation");
+                            //g1.savetops("FFT_execution_times_extended");
+                            //g1.savetopdf("FFT_execution_times_extended", 18);
+                            g1.showonscreen(); // window output
+                    }
+                    catch (const GnuplotException & ge)
+                    {
+                            std::cout << ge.what() << std::endl;
+                    }
+                }
+        }
+}
+
+
+void ObsSystemTest::compute_doppler_error(
+        std::vector<arma::vec>& diff,
+        double error_th_mean, double error_th_std,
+        std::string signal_name)
+{
+    int prn_id = 0;
+    std::vector<double> means;
+    std::vector<double> stddevs;
+    std::vector<double> prns;
+    std::vector<arma::vec>::iterator iter_diff;
+    for(iter_diff = diff.begin(); iter_diff != diff.end(); iter_diff++)
+        {
+            if(!iter_diff->is_empty())
+                {
+                    double d_mean = std::sqrt(arma::mean(arma::square(*iter_diff)));
+                    means.push_back(d_mean);
+                    double d_stddev = arma::stddev(*iter_diff);
+                    stddevs.push_back(d_stddev);
+                    prns.push_back(static_cast<double>(prn_id));
+                    std::cout << "-- RMS Doppler difference for sat " << prn_id << ": " << d_mean;
+                    std::cout << " +/- " << d_stddev;
+                    std::cout << " [Hz]" << std::endl;
+                    EXPECT_LT(d_mean, error_th_mean);
+                    EXPECT_LT(d_stddev, error_th_std);
+                }
+            prn_id++;
+        }
+    if(FLAGS_plot_obs_sys_test == true)
+        {
+            const std::string gnuplot_executable(FLAGS_gnuplot_executable);
+            if(gnuplot_executable.empty())
+                {
+                    std::cout << "WARNING: Although the flag plot_obs_sys_test has been set to TRUE," << std::endl;
+                    std::cout << "gnuplot has not been found in your system." << std::endl;
+                    std::cout << "Test results will not be plotted." << std::endl;
+                }
+            else
+                {
+                    try
+                    {
+                            boost::filesystem::path p(gnuplot_executable);
+                            boost::filesystem::path dir = p.parent_path();
+                            std::string gnuplot_path = dir.native();
+                            Gnuplot::set_GNUPlotPath(gnuplot_path);
+
+                            Gnuplot g1("linespoints");
+                            g1.set_title(signal_name + " Doppler error");
+                            g1.set_grid();
+                            g1.set_xlabel("PRN");
+                            g1.set_ylabel("Doppler error [Hz]");
+                            g1.plot_xy(prns, means, "RMS error");
+                            g1.plot_xy(prns, stddevs, "Standard deviation");
+                            //g1.savetops("FFT_execution_times_extended");
+                            //g1.savetopdf("FFT_execution_times_extended", 18);
+                            g1.showonscreen(); // window output
+                    }
+                    catch (const GnuplotException & ge)
+                    {
+                            std::cout << ge.what() << std::endl;
+                    }
+                }
+        }
+}
+
+
+void ObsSystemTest::check_results()
+{
+    arma::mat sow_prn_ref;
+    if(gps_1C)
+        {
+            std::vector<arma::mat> pseudorange_ref(num_prn_gps);
+            std::vector<arma::mat> carrierphase_ref(num_prn_gps);
+            std::vector<arma::mat> doppler_ref(num_prn_gps);
+
+            std::vector<arma::mat> pseudorange_meas(num_prn_gps);
+            std::vector<arma::mat> carrierphase_meas(num_prn_gps);
+            std::vector<arma::mat> doppler_meas(num_prn_gps);
+
+            read_rinex_files(pseudorange_ref, carrierphase_ref, doppler_ref, pseudorange_meas, carrierphase_meas, doppler_meas, sow_prn_ref, 0);
+
+            // Time alignment and difference computation
+
+            std::vector<arma::vec> pr_diff(num_prn_gps);
+            std::vector<arma::vec> cp_diff(num_prn_gps);
+            std::vector<arma::vec> dp_diff(num_prn_gps);
+            time_alignment_diff_pr(pseudorange_ref, pseudorange_meas, pr_diff, sow_prn_ref);
+            time_alignment_diff_cp(carrierphase_ref, carrierphase_meas, cp_diff);
+            time_alignment_diff(doppler_ref, doppler_meas, dp_diff);
+
+            // Results
+            std::cout << std::endl;
+            std::cout << std::endl;
+            std::cout << "GPS L1 C/A obs. results" << std::endl;
+
+            // Compute pseudorange error
+
+            compute_pseudorange_error(pr_diff, pseudorange_error_th_mean, pseudorange_error_th_std, "GPS L1 C/A");
+
+            // Compute carrier phase error
+
+            compute_carrierphase_error(cp_diff, carrierphase_error_th_mean, carrierphase_error_th_std, "GPS L1 C/A");
+
+            // Compute Doppler error
+
+            compute_doppler_error(dp_diff, doppler_error_th_mean, doppler_error_th_std, "GPS L1 C/A");
+        }
+    if(gps_L5)
+        {
+            std::vector<arma::mat> pseudorange_ref(num_prn_gps);
+            std::vector<arma::mat> carrierphase_ref(num_prn_gps);
+            std::vector<arma::mat> doppler_ref(num_prn_gps);
+
+            std::vector<arma::mat> pseudorange_meas(num_prn_gps);
+            std::vector<arma::mat> carrierphase_meas(num_prn_gps);
+            std::vector<arma::mat> doppler_meas(num_prn_gps);
+
+            read_rinex_files(pseudorange_ref, carrierphase_ref, doppler_ref, pseudorange_meas, carrierphase_meas, doppler_meas, sow_prn_ref, 2);
+
+            // Time alignment and difference computation
+
+            std::vector<arma::vec> pr_diff(num_prn_gps);
+            std::vector<arma::vec> cp_diff(num_prn_gps);
+            std::vector<arma::vec> dp_diff(num_prn_gps);
+            time_alignment_diff_pr(pseudorange_ref, pseudorange_meas, pr_diff, sow_prn_ref);
+            time_alignment_diff_cp(carrierphase_ref, carrierphase_meas, cp_diff);
+            time_alignment_diff(doppler_ref, doppler_meas, dp_diff);
+
+            // Results
+            std::cout << std::endl;
+            std::cout << std::endl;
+            std::cout << "GPS L5 obs. results" << std::endl;
+
+            // Compute pseudorange error
+
+            compute_pseudorange_error(pr_diff, pseudorange_error_th_mean, pseudorange_error_th_std, "GPS L5");
+
+            // Compute carrier phase error
+
+            compute_carrierphase_error(cp_diff, carrierphase_error_th_mean, carrierphase_error_th_std, "GPS L5");
+
+            // Compute Doppler error
+
+            compute_doppler_error(dp_diff, doppler_error_th_mean, doppler_error_th_std, "GPS L5");
+        }
+    if(gal_1B)
+        {
+            std::vector<arma::mat> pseudorange_ref(num_prn_gal);
+            std::vector<arma::mat> carrierphase_ref(num_prn_gal);
+            std::vector<arma::mat> doppler_ref(num_prn_gal);
+
+            std::vector<arma::mat> pseudorange_meas(num_prn_gal);
+            std::vector<arma::mat> carrierphase_meas(num_prn_gal);
+            std::vector<arma::mat> doppler_meas(num_prn_gal);
+
+            read_rinex_files(pseudorange_ref, carrierphase_ref, doppler_ref, pseudorange_meas, carrierphase_meas, doppler_meas, sow_prn_ref, 1);
+
+            // Time alignment and difference computation
+
+            std::vector<arma::vec> pr_diff(num_prn_gal);
+            std::vector<arma::vec> cp_diff(num_prn_gal);
+            std::vector<arma::vec> dp_diff(num_prn_gal);
+            time_alignment_diff_pr(pseudorange_ref, pseudorange_meas, pr_diff, sow_prn_ref);
+            time_alignment_diff_cp(carrierphase_ref, carrierphase_meas, cp_diff);
+            time_alignment_diff(doppler_ref, doppler_meas, dp_diff);
+
+            // Results
+            std::cout << std::endl;
+            std::cout << std::endl;
+            std::cout << "Galileo E1B obs. results" << std::endl;
+
+            // Compute pseudorange error
+
+            compute_pseudorange_error(pr_diff, pseudorange_error_th_mean, pseudorange_error_th_std, "Galileo E1B");
+
+            // Compute carrier phase error
+
+            compute_carrierphase_error(cp_diff, carrierphase_error_th_mean, carrierphase_error_th_std, "Galileo E1B");
+
+            // Compute Doppler error
+
+            compute_doppler_error(dp_diff, doppler_error_th_mean, doppler_error_th_std, "Galileo E1B");
+        }
+    if(gal_E5a)
+        {
+            std::vector<arma::mat> pseudorange_ref(num_prn_gal);
+            std::vector<arma::mat> carrierphase_ref(num_prn_gal);
+            std::vector<arma::mat> doppler_ref(num_prn_gal);
+
+            std::vector<arma::mat> pseudorange_meas(num_prn_gal);
+            std::vector<arma::mat> carrierphase_meas(num_prn_gal);
+            std::vector<arma::mat> doppler_meas(num_prn_gal);
+
+            read_rinex_files(pseudorange_ref, carrierphase_ref, doppler_ref, pseudorange_meas, carrierphase_meas, doppler_meas, sow_prn_ref, 3);
+
+            // Time alignment and difference computation
+
+            std::vector<arma::vec> pr_diff(num_prn_gal);
+            std::vector<arma::vec> cp_diff(num_prn_gal);
+            std::vector<arma::vec> dp_diff(num_prn_gal);
+            time_alignment_diff_pr(pseudorange_ref, pseudorange_meas, pr_diff, sow_prn_ref);
+            time_alignment_diff_cp(carrierphase_ref, carrierphase_meas, cp_diff);
+            time_alignment_diff(doppler_ref, doppler_meas, dp_diff);
+
+            // Results
+            std::cout << std::endl;
+            std::cout << std::endl;
+            std::cout << "Galileo E5a obs. results" << std::endl;
+
+            // Compute pseudorange error
+
+            compute_pseudorange_error(pr_diff, pseudorange_error_th_mean, pseudorange_error_th_std, "Galileo E5a");
+
+            // Compute carrier phase error
+
+            compute_carrierphase_error(cp_diff, carrierphase_error_th_mean, carrierphase_error_th_std, "Galileo E5a");
+
+            // Compute Doppler error
+
+            compute_doppler_error(dp_diff, doppler_error_th_mean, doppler_error_th_std, "Galileo E5a");
+        }
+}
+
+
+TEST_F(ObsSystemTest, Observables_system_test)
+{
+    std::cout << "Validating input RINEX obs (TRUE) file: " << filename_rinex_obs << " ..." << std::endl;
+    bool is_rinex_obs_valid = check_valid_rinex_obs(filename_rinex_obs, 3);
+    ASSERT_EQ(true, is_rinex_obs_valid) << "The RINEX observation file " << filename_rinex_obs << " is not well formed. Only RINEX v. 3.00 files are allowed";
+    std::cout << "The file is valid." << std::endl;
+    // Configure receiver
+    configure_receiver();
+    if(generated_rinex_obs.compare("default_string") == 0)
+        {
+            // Run the receiver
+            ASSERT_EQ( run_receiver(), 0) << "Problem executing the software-defined signal generator";
+        }
+    std::cout << "Validating RINEX obs file obtained by GNSS-SDR: " << generated_rinex_obs << " ..." << std::endl;
+    bool is_gen_rinex_obs_valid = false;
+    if(internal_rinex_generation)
+        {
+            is_gen_rinex_obs_valid = check_valid_rinex_obs( "./" + generated_rinex_obs, config->property("PVT.rinex_version", 3));
+        }
+    else
+        {
+            is_gen_rinex_obs_valid = check_valid_rinex_obs(generated_rinex_obs, config->property("PVT.rinex_version", 3));
+        }
+    ASSERT_EQ(true, is_gen_rinex_obs_valid) << "The RINEX observation file " << generated_rinex_obs << ", generated by GNSS-SDR, is not well formed.";
+    std::cout << "The file is valid." << std::endl;
+    // Check results
+    check_results();
+}
+
+
+int main(int argc, char **argv)
+{
+    std::cout << "Running GNSS-SDR in Space Observables validation test..." << std::endl;
+    int res = 0;
+    try
+    {
+            testing::InitGoogleTest(&argc, argv);
+    }
+    catch(...) {} // catch the "testing::internal::<unnamed>::ClassUniqueToAlwaysTrue" from gtest
+
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    google::InitGoogleLogging(argv[0]);
+
+    // Run the Tests
+    try
+    {
+            res = RUN_ALL_TESTS();
+    }
+    catch(...)
+    {
+            LOG(WARNING) << "Unexpected catch";
+    }
+    google::ShutDownCommandLineFlags();
+    return res;
+}