mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-14 20:20:35 +00:00
Code Issues Releases Wiki Activity

Add work on Acq perfromance test

Browse Source
This commit is contained in:
Carles Fernandez 2018-06-29 13:33:53 +02:00
parent 65c62a614c
commit c4f3b6ec31
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
1 changed files with 85 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_acq_performance_test.cc
View File

@ -40,16 +40,17 @@
#include <glog/logging.h> #include <glog/logging.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
DEFINE_string(config_file_ptest, std::string(""), "File containing the configuration parameters for the position test."); DEFINE_string(config_file_ptest, std::string(""), "File containing alternative configuration parameters for the position test.");
DEFINE_double(acq_test_threshold, 0.001, "Acquisition threshold"); //DEFINE_double(acq_test_threshold, 0.001, "Acquisition threshold");
DEFINE_double(acq_test_pfa, -1.0, "Set threshold via probability of false alarm"); DEFINE_double(acq_test_pfa_init, 1e-5, "Set initial threshold via probability of false alarm");
DEFINE_int32(acq_test_coherent_time_ms, 10, "Acquisition coherent time, in ms"); DEFINE_int32(acq_test_coherent_time_ms, 1, "Acquisition coherent time, in ms");
DEFINE_int32(acq_test_PRN, 1, "PRN number"); DEFINE_int32(acq_test_PRN, 1, "PRN number of a present satellite");
DEFINE_int32(acq_test_fake_PRN, 33, "Fake PRN number"); DEFINE_int32(acq_test_fake_PRN, 33, "PRN number of a non-present satellite");
DEFINE_int32(acq_test_signal_duration_s, 2, "Generated signal duration"); DEFINE_int32(acq_test_signal_duration_s, 1, "Generated signal duration, in s");
DEFINE_bool(acq_test_bit_transition_flag, false, "Bit transition flag"); DEFINE_bool(acq_test_bit_transition_flag, false, "Bit transition flag");
DEFINE_int32(acq_test_iterations, 2, "Number of iterations"); DEFINE_int32(acq_test_iterations, 1, "Number of iterations (same signal, diferent noise realization)");
DEFINE_bool(plot_acq_test, false, "Plots results of AcquisitionPerformanceTest with gnuplot"); DEFINE_bool(plot_acq_test, false, "Plots results with gnuplot, if available");
DEFINE_bool(acq_test_use_CFAR_algorithm, true, "Use CFAR algorithm");
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class AcqPerfTest_msg_rx; class AcqPerfTest_msg_rx;
@ -120,25 +121,33 @@ protected:
doppler_max = 5000; doppler_max = 5000;
doppler_step = 125; doppler_step = 125;
stop = false; stop = false;
//acquisition_ = 0;
init(); init();
Pd.resize(cn0_.size()); pfa_vector.push_back(FLAGS_acq_test_pfa_init);
for (int i = 0; i < static_cast<int>(cn0_.size()); i++) Pd[i].reserve(num_thresholds); float aux = 1.0;
Pfa.resize(cn0_.size()); while ((FLAGS_acq_test_pfa_init * std::pow(10, aux)) < 1)
for (int i = 0; i < static_cast<int>(cn0_.size()); i++) Pfa[i].reserve(num_thresholds); {
Pd_correct.resize(cn0_.size()); pfa_vector.push_back(FLAGS_acq_test_pfa_init * std::pow(10, aux));
for (int i = 0; i < static_cast<int>(cn0_.size()); i++) Pd_correct[i].reserve(num_thresholds); aux = aux + 1.0;
}
pfa_vector.push_back(1.0);
num_thresholds = pfa_vector.size();
Pd.resize(cn0_vector.size());
for (int i = 0; i < static_cast<int>(cn0_vector.size()); i++) Pd[i].reserve(num_thresholds);
Pfa.resize(cn0_vector.size());
for (int i = 0; i < static_cast<int>(cn0_vector.size()); i++) Pfa[i].reserve(num_thresholds);
Pd_correct.resize(cn0_vector.size());
for (int i = 0; i < static_cast<int>(cn0_vector.size()); i++) Pd_correct[i].reserve(num_thresholds);
} }
~AcquisitionPerformanceTest() ~AcquisitionPerformanceTest()
{ {
} }
std::vector<double> cn0_ = {35.0, 38.0}; std::vector<double> cn0_vector = {35.0, 38.0};
std::vector<float> pfa_local = {0.001, 0.01, 1}; //{0.0001, 0.001, 0.01, 0.1, 1}; //{FLAGS_acq_test_pfa}; //{0.001, 0.01, 0.1, 1}; std::vector<float> pfa_vector;
int N_iterations = FLAGS_acq_test_iterations; int N_iterations = FLAGS_acq_test_iterations;
void init(); void init();
//void plot_grid();
int configure_generator(double cn0); int configure_generator(double cn0);
int generate_signal(); int generate_signal();
@ -174,25 +183,24 @@ protected:
const int coherent_integration_time_ms = FLAGS_acq_test_coherent_time_ms; const int coherent_integration_time_ms = FLAGS_acq_test_coherent_time_ms;
const int number_of_channels = 2; const int number_of_channels = 2;
const int in_acquisition = 1; const int in_acquisition = 1;
const float threshold = FLAGS_acq_test_threshold; const float threshold = 0.001; // FLAGS_acq_test_threshold;
const int max_dwells = 1; const int max_dwells = 1;
const int dump_channel = 0; const int dump_channel = 0;
int generated_signal_duration_s = FLAGS_acq_test_signal_duration_s; int generated_signal_duration_s = FLAGS_acq_test_signal_duration_s;
unsigned int num_of_realizations = (generated_signal_duration_s * 1000) / FLAGS_acq_test_coherent_time_ms; unsigned int num_of_realizations = ((generated_signal_duration_s * 1000 - FLAGS_acq_test_coherent_time_ms) / FLAGS_acq_test_coherent_time_ms);
unsigned int realization_counter; unsigned int realization_counter = 0;
unsigned int observed_satellite = FLAGS_acq_test_PRN; unsigned int observed_satellite = FLAGS_acq_test_PRN;
std::string path_str = "./acq-perf-test"; std::string path_str = "./acq-perf-test";
int num_thresholds = pfa_local.size(); int num_thresholds;
std::vector<std::vector<float>> Pd; std::vector<std::vector<float>> Pd;
std::vector<std::vector<float>> Pfa; std::vector<std::vector<float>> Pfa;
std::vector<std::vector<float>> Pd_correct; std::vector<std::vector<float>> Pd_correct;
private: private:
std::string generator_binary; std::string generator_binary;
std::string p1; std::string p1;
@ -202,15 +210,11 @@ private:
std::string p5; std::string p5;
std::string p6; std::string p6;
std::string filename_rinex_obs = FLAGS_filename_rinex_obs; std::string filename_rinex_obs = FLAGS_filename_rinex_obs;
std::string filename_raw_data = FLAGS_filename_raw_data; std::string filename_raw_data = FLAGS_filename_raw_data;
double compute_stdev_precision(const std::vector<double>& vec); double compute_stdev_precision(const std::vector<double>& vec);
double compute_stdev_accuracy(const std::vector<double>& vec, double ref); double compute_stdev_accuracy(const std::vector<double>& vec, double ref);
//std::string generated_kml_file;
}; };
@ -237,11 +241,7 @@ void AcquisitionPerformanceTest::wait_message()
{ {
while (!stop) while (!stop)
{ {
acquisition->reset();
acquisition->set_state(1);
channel_internal_queue.wait_and_pop(message); channel_internal_queue.wait_and_pop(message);
process_message(); process_message();
} }
} }
@ -252,7 +252,7 @@ void AcquisitionPerformanceTest::process_message()
realization_counter++; realization_counter++;
acquisition->reset(); acquisition->reset();
acquisition->set_state(1); acquisition->set_state(1);
std::cout << "Progress: " << round(static_cast<float>(realization_counter) / static_cast<float>(num_of_realizations) * 100.0) << "% \r" << std::flush;
if (realization_counter == num_of_realizations) if (realization_counter == num_of_realizations)
{ {
stop_queue(); stop_queue();
@ -328,9 +328,16 @@ int AcquisitionPerformanceTest::configure_receiver(double cn0, float pfa, unsign
config->set_property("Acquisition_1C.doppler_step", std::to_string(doppler_step)); config->set_property("Acquisition_1C.doppler_step", std::to_string(doppler_step));
config->set_property("Acquisition_1C.threshold", std::to_string(threshold)); config->set_property("Acquisition_1C.threshold", std::to_string(threshold));
//if (FLAGS_acq_test_pfa > 0.0) config->supersede_property("Acquisition_1C.pfa", std::to_string(pfa)); //if (FLAGS_acq_test_pfa_init > 0.0) config->supersede_property("Acquisition_1C.pfa", std::to_string(pfa));
config->supersede_property("Acquisition_1C.pfa", std::to_string(pfa)); config->supersede_property("Acquisition_1C.pfa", std::to_string(pfa));
config->set_property("Acquisition_1C.use_CFAR_algorithm", "true"); if (FLAGS_acq_test_use_CFAR_algorithm)
{
config->set_property("Acquisition_1C.use_CFAR_algorithm", "true");
}
else
{
config->set_property("Acquisition_1C.use_CFAR_algorithm", "false");
}
config->set_property("Acquisition_1C.coherent_integration_time_ms", std::to_string(coherent_integration_time_ms)); config->set_property("Acquisition_1C.coherent_integration_time_ms", std::to_string(coherent_integration_time_ms));
if (FLAGS_acq_test_bit_transition_flag) if (FLAGS_acq_test_bit_transition_flag)
@ -355,6 +362,7 @@ int AcquisitionPerformanceTest::configure_receiver(double cn0, float pfa, unsign
std::string dump_file = path_str + std::string("/acquisition_") + std::to_string(cn0) + "_" + std::to_string(iter) + "_" + std::to_string(pfa); std::string dump_file = path_str + std::string("/acquisition_") + std::to_string(cn0) + "_" + std::to_string(iter) + "_" + std::to_string(pfa);
config->set_property("Acquisition_1C.dump_filename", dump_file); config->set_property("Acquisition_1C.dump_filename", dump_file);
config->set_property("Acquisition_1C.dump_channel", std::to_string(dump_channel)); config->set_property("Acquisition_1C.dump_channel", std::to_string(dump_channel));
config->set_property("Acquisition_1C.blocking_on_standby", "true");
config_f = 0; config_f = 0;
} }
@ -420,7 +428,7 @@ int AcquisitionPerformanceTest::run_receiver()
int AcquisitionPerformanceTest::count_executions(const std::string& basename, unsigned int sat) int AcquisitionPerformanceTest::count_executions(const std::string& basename, unsigned int sat)
{ {
FILE* fp; FILE* fp;
std::string argum2 = std::string("/bin/ls ") + basename + "* | grep sat_" + std::to_string(sat) + " | wc -l"; std::string argum2 = std::string("/usr/bin/find ") + path_str + std::string(" -maxdepth 1 -name ") + basename.substr(path_str.length() + 1, basename.length() - path_str.length()) + std::string("* | grep sat_") + std::to_string(sat) + std::string(" | wc -l");
char buffer[1024]; char buffer[1024];
fp = popen(&argum2[0], "r"); fp = popen(&argum2[0], "r");
int num_executions = 1; int num_executions = 1;
@ -461,15 +469,16 @@ void AcquisitionPerformanceTest::plot_results()
Gnuplot::set_GNUPlotPath(gnuplot_path); Gnuplot::set_GNUPlotPath(gnuplot_path);
Gnuplot g1("linespoints"); Gnuplot g1("linespoints");
g1.set_title("Receiver Operating Characteristic for GPS L1 C/A acquisition"); g1.set_title("Receiver Operating Characteristic for GPS L1 C/A acquisition, coherent integration time: " + std::to_string(config->property("Acquisition_1C.coherent_integration_time_ms", 1)) + " ms.");
g1.cmd("set logscale x"); g1.cmd("set logscale x");
g1.cmd("set yrange [0:1]"); g1.cmd("set yrange [0:1]");
g1.cmd("set grid xtics 0.001 0.01 0.1 1");
g1.cmd("set grid ytics");
g1.set_grid();
g1.set_xlabel("Pfa"); g1.set_xlabel("Pfa");
g1.set_ylabel("Pd"); g1.set_ylabel("Pd");
for (int i = 0; i < static_cast<int>(cn0_.size()); i++) g1.cmd("set grid xtics");
g1.cmd("set grid mytics");
g1.set_grid();
g1.cmd("show grid");
for (int i = 0; i < static_cast<int>(cn0_vector.size()); i++)
{ {
std::vector<float> Pd_i; std::vector<float> Pd_i;
std::vector<float> Pfa_i; std::vector<float> Pfa_i;
@ -478,37 +487,38 @@ void AcquisitionPerformanceTest::plot_results()
Pd_i.push_back(Pd[i][k]); Pd_i.push_back(Pd[i][k]);
Pfa_i.push_back(Pd[i][k]); Pfa_i.push_back(Pd[i][k]);
} }
g1.plot_xy(Pfa_i, Pd_i, "CN0 = " + std::to_string(static_cast<int>(cn0_[i])) + " dBHz"); g1.plot_xy(Pfa_i, Pd_i, "CN0 = " + std::to_string(static_cast<int>(cn0_vector[i])) + " dBHz");
} }
g1.set_legend(); g1.set_legend();
g1.savetops("ROC"); g1.savetops("ROC");
g1.savetopdf("ROC", 18); g1.savetopdf("ROC", 18);
g1.showonscreen(); // window output g1.showonscreen(); // window output
if (Pd_correct[0].size() > 0) Gnuplot g2("linespoints");
g2.set_title("Receiver Operating Characteristic for GPS L1 C/A valid acquisition, coherent integration time: " + std::to_string(config->property("Acquisition_1C.coherent_integration_time_ms", 1)) + " ms.");
g2.cmd("set logscale x");
g2.cmd("set yrange [0:1]");
g1.cmd("set grid xtics");
g1.cmd("set grid mytics");
g2.set_xlabel("Pfa");
g2.set_ylabel("Valid Pd");
g2.set_grid();
g2.cmd("show grid");
for (int i = 0; i < static_cast<int>(cn0_vector.size()); i++)
{ {
Gnuplot g2("linespoints"); std::vector<float> Pd_i_correct;
g2.set_title("Receiver Operating Characteristic for GPS L1 C/A correct acquisition"); std::vector<float> Pfa_i;
g2.cmd("set logscale x"); for (int k = 0; k < num_thresholds; k++)
g2.set_xlabel("Pfa");
g2.set_xlabel("Pd");
g2.set_grid();
for (int i = 0; i < static_cast<int>(cn0_.size()); i++)
{ {
std::vector<float> Pd_i_correct; Pd_i_correct.push_back(Pd_correct[i][k]);
std::vector<float> Pfa_i; Pfa_i.push_back(Pd[i][k]);
for (int k = 0; k < num_thresholds; k++)
{
Pd_i_correct.push_back(Pd_correct[i][k]);
Pfa_i.push_back(Pd[i][k]);
}
g2.plot_xy(Pfa_i, Pd_i_correct, "CN0 = " + std::to_string(static_cast<int>(cn0_[i])) + " dBHz");
} }
g2.set_legend(); g2.plot_xy(Pfa_i, Pd_i_correct, "CN0 = " + std::to_string(static_cast<int>(cn0_vector[i])) + " dBHz");
g2.savetops("ROC-correct");
g2.savetopdf("ROC-correct", 18);
g2.showonscreen(); // window output
} }
g2.set_legend();
g2.savetops("ROC-valid-detection");
g2.savetopdf("ROC-valid-detection", 18);
g2.showonscreen(); // window output
} }
catch (const GnuplotException& ge) catch (const GnuplotException& ge)
{ {
@ -531,28 +541,25 @@ TEST_F(AcquisitionPerformanceTest, ROC)
ASSERT_TRUE(boost::filesystem::create_directory(path_str, ec)) << "Could not create the " << path_str << " folder."; ASSERT_TRUE(boost::filesystem::create_directory(path_str, ec)) << "Could not create the " << path_str << " folder.";
unsigned int cn0_index = 0; unsigned int cn0_index = 0;
for (std::vector<double>::const_iterator it = cn0_.cbegin(); it != cn0_.cend(); ++it) for (std::vector<double>::const_iterator it = cn0_vector.cbegin(); it != cn0_vector.cend(); ++it)
{ {
// Do N_iterations of the experiment
std::vector<double> meas_Pd_; std::vector<double> meas_Pd_;
std::vector<double> meas_Pd_correct_; std::vector<double> meas_Pd_correct_;
std::vector<double> meas_Pfa_; std::vector<double> meas_Pfa_;
// Set parameter to sweep
std::cout << "Execution for CN0 = " << *it << " dB-Hz" << std::endl; std::cout << "Execution for CN0 = " << *it << " dB-Hz" << std::endl;
for (int pfa_iter = 0; pfa_iter < static_cast<int>(pfa_local.size()); pfa_iter++)
// Do N_iterations of the experiment
for (int pfa_iter = 0; pfa_iter < static_cast<int>(pfa_vector.size()); pfa_iter++)
{ {
std::cout << "Setting threshold for Pfa = " << pfa_vector[pfa_iter] << std::endl;
// Configure the signal generator
configure_generator(*it);
for (int iter = 0; iter < N_iterations; iter++) for (int iter = 0; iter < N_iterations; iter++)
{ {
std::string basename = path_str + std::string("/acquisition_") + std::to_string(*it) + "_" + std::to_string(iter) + "_" + std::to_string(pfa_local[pfa_iter]) + "_" + gnss_synchro.System + "_1C";
// Configure the signal generator
configure_generator(*it);
// Generate signal raw signal samples and observations RINEX file // Generate signal raw signal samples and observations RINEX file
generate_signal(); generate_signal();
//std::cout << "Execution for CN0 = " << *it << " dB-Hz" << std::endl;
for (unsigned k = 0; k < 2; k++) for (unsigned k = 0; k < 2; k++)
{ {
if (k == 0) if (k == 0)
@ -566,12 +573,13 @@ TEST_F(AcquisitionPerformanceTest, ROC)
init(); init();
// Configure the receiver // Configure the receiver
configure_receiver(*it, pfa_local[pfa_iter], iter); configure_receiver(*it, pfa_vector[pfa_iter], iter);
// Run it // Run it
run_receiver(); run_receiver();
// count executions // count executions
std::string basename = path_str + std::string("/acquisition_") + std::to_string(*it) + "_" + std::to_string(iter) + "_" + std::to_string(pfa_vector[pfa_iter]) + "_" + gnss_synchro.System + "_1C";
int num_executions = count_executions(basename, observed_satellite); int num_executions = count_executions(basename, observed_satellite);
// Read measured data // Read measured data
@ -669,7 +677,7 @@ TEST_F(AcquisitionPerformanceTest, ROC)
} }
} }
std::cout << "Doppler estimation error [Hz]: "; /* std::cout << "Doppler estimation error [Hz]: ";
for (int i = 0; i < num_executions - 1; i++) for (int i = 0; i < num_executions - 1; i++)
{ {
std::cout << doppler_estimation_error(i) << " "; std::cout << doppler_estimation_error(i) << " ";
@ -680,8 +688,9 @@ TEST_F(AcquisitionPerformanceTest, ROC)
for (int i = 0; i < num_executions - 1; i++) for (int i = 0; i < num_executions - 1; i++)
{ {
std::cout << delay_estimation_error(i) << " "; std::cout << delay_estimation_error(i) << " ";
} }
std::cout << std::endl; std::cout << std::endl; */
} }
if (k == 0) if (k == 0)
{ {
@ -722,7 +731,6 @@ TEST_F(AcquisitionPerformanceTest, ROC)
{ {
double wrongly_detected = arma::accu(positive_acq); double wrongly_detected = arma::accu(positive_acq);
double computed_Pfa = wrongly_detected / static_cast<double>(num_executions); double computed_Pfa = wrongly_detected / static_cast<double>(num_executions);
std::cout << computed_Pfa << std::endl;
if (num_executions > 0) if (num_executions > 0)
{ {
meas_Pfa_.push_back(computed_Pfa); meas_Pfa_.push_back(computed_Pfa);
@ -783,7 +791,7 @@ TEST_F(AcquisitionPerformanceTest, ROC)
// Compute results // Compute results
unsigned int aux_index = 0; unsigned int aux_index = 0;
for (std::vector<double>::const_iterator it = cn0_.cbegin(); it != cn0_.cend(); ++it) for (std::vector<double>::const_iterator it = cn0_vector.cbegin(); it != cn0_vector.cend(); ++it)
{ {
std::cout << "Results for CN0 = " << *it << " dBHz:" << std::endl; std::cout << "Results for CN0 = " << *it << " dBHz:" << std::endl;
std::cout << "Pd = "; std::cout << "Pd = ";