Changed simulator structure. Config file.

Author: Alex

config.m

@@ -1,25 +1,35 @@
 timestamp = [num2str(start_time(1),'%04d') '_' num2str(start_time(2),'%02d') '_' num2str(start_time(3),'%02d') '_' num2str(start_time(4),'%02d') '_' num2str(start_time(5),'%02d') '_' num2str(start_time(6),'%2.0f')];
 result_path = './results/';
 addpath('support');
-fast_run = 1;           %1:run of optimal-matlab code, 0:run of hardware-code (suboptimal f/g)
+%% Configure parameters
+%Polar-Code values
+capacity = 0.5; %I(W), Channel's W Capacity
+n_values = [4,5,6,7,8,9,10];     %value of N
+code_rate = 1/4;
+%EbNo
+EbNo_dB = 0:5; %AWGN -4:2 %Fading 0:2:10
+%Channel
 Fading_Channel = 0;     %0: AWGN, 1:Fading Channel
+%fading only parameters
 Fading_Independent = 0; %if Fading_Channel = 1
 quasi = 0;              % quasi channel
 fading_channel = 'TU120';   %custom matlab channel
+
 fix_seed = 1;           %1:fix data, 0:random data
-code_rate = 1/4;
 if fix_seed
     rng(sum(100*clock));
 else
     rand('seed',123456);
 end
 %Simulation values
-min_fer_errors = 100;
-min_codewords = 100;
-NbitsPerSymbol = 1;
-constDims = 1;
-%EbNo
-EbNo_dB = -2:4;
+fast_run = 1;           %1:run of optimal-matlab code, 0:run of hardware-code (suboptimal f/g)
+min_fer_errors = 100;   %minimum frame errors to count
+min_codewords = 100;    %minimum codewords to count
+NbitsPerSymbol = 1;     %modulation parameter
+constDims = 1;          %modulation parameter
 snrdb_values =EbNo_dB+10*log10(double(code_rate*NbitsPerSymbol*2/constDims));
-%Polar-Code values
-capacity = 0.5; %I(W), Channel's W Capacity
+%% Variable Initializations
+bit_error_rate = zeros(length(n_values),length(snrdb_values));
+fer_error_rate = zeros(length(n_values),length(snrdb_values));
+legends = strings(1,length(n_values));
+codewords = zeros(1,length(snrdb_values));

main.m

@@ -1,60 +1,57 @@
-clc;clear;
+clc;clear all;
 start_time = clock;
 config;
-for n = [7,8,9,10] %N=2^n
-N = power(2,n);      %Code Length
-K = N* code_rate;      %Code keyword length
-mat_file = [result_path 'polar_N' num2str(N) '_K' num2str(K) '_' timestamp '.mat'];
-bit_error_rate = zeros(1,length(snrdb_values));
-fer_error_rate = zeros(1,length(snrdb_values));
-codewords = zeros(1,length(snrdb_values));
-%Polar-code initializations
-Fn = fkronecker(N);
-frozen_bits = initialize_frozen_bits(N,K,capacity); %0=frozen, 1=not_frozen
-partial_sum_adders = partial_sums_initialize(N);   %!!!!! NOT bit_reversed array -- %outputs(z,i,l) -- l stage ,bit Ui is added,z is the number of g adder
-[sc_functions,sc_2nd_indxs] = sc_array_initialize(N);
-for i_index = 1:length(snrdb_values) %[0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5]
-%Initialize temporary variables
-codewords_tmp = 0;
-fer_errors = 0;
-bit_errors = 0;
-snr = snrdb_values(i_index);
-while (fer_errors<min_fer_errors || codewords_tmp<min_codewords)
-codewords_tmp = codewords_tmp + 1;
-inputs = rand(1,K)>0.5;    %write random inputs
-%transform inputs
-inputs_to_encode = transform_inputs(inputs,frozen_bits,N);
-%encode
-encoded_inputs = encode(inputs_to_encode,Fn);      %Reversed Polar Encoding
-%modulate
-modulated_inputs = modulate(encoded_inputs);%encoded_inputs);        %BPSK = 1-2*encoded_inputs(i)
-%noise
-noised_inputs = add_noise(modulated_inputs,constDims,Fading_Channel,Fading_Independent,fading_channel,snrdb_values(i_index));
-%demodulate
-llr = (2 * power(10,snrdb_values(i_index)/10))*noised_inputs;       %CARE NEGATIVE SIGN.2*yi/(s^2) = ln(Li), s^2 = 1/ 10^ (SNRdb/10)
-%decode
-if(fast_run)
-    %optimal version (optimal-calculations of f/g)
-    outputs = decode2(llr,frozen_bits);
-else
-    %hardware-version (suboptimal-calculations of f/g)
-    outputs = decode(llr,frozen_bits,partial_sum_adders,sc_functions,sc_2nd_indxs);
+%% N LOOP
+for index_n = 1:length(n_values)                    %N=2^n
+    N = power(2,n_values(index_n));                 %Code Length
+    K = N* code_rate;                               %Code keyword length
+    mat_file = [result_path 'polar_N' num2str(N) '_K' num2str(K) '_' timestamp '.mat'];
+    %Polar-code initializations
+    [Fn,frozen_bits,partial_sum_adders, sc_functions, sc_2nd_indxs] = polar_initialization(N, K, capacity);
+    fprintf("Polar Code %d/%d running:\n",N,K);
+    %% SNR LOOP
+    for i_index = 1:length(snrdb_values)
+        %Initialize temporary variables
+        codewords_tmp = 0;fer_errors = 0;bit_errors = 0;
+        snr = snrdb_values(i_index);
+        while (fer_errors<min_fer_errors || codewords_tmp<min_codewords)
+            codewords_tmp = codewords_tmp + 1;
+            inputs = rand(1,K)>0.5;    %write random inputs
+            %transform inputs
+            inputs_to_encode = transform_inputs(inputs,frozen_bits,N);
+            %encode
+            encoded_inputs = encode(inputs_to_encode,Fn);      %Reversed Polar Encoding
+            %modulate
+            modulated_inputs = modulate(encoded_inputs);%encoded_inputs);        %BPSK = 1-2*encoded_inputs(i)
+            %noise
+            noised_inputs = add_noise(modulated_inputs,constDims,Fading_Channel,Fading_Independent,fading_channel,snrdb_values(i_index));
+            %demodulate
+            llr = (2 * power(10,snrdb_values(i_index)/10))*noised_inputs;       %CARE NEGATIVE SIGN.2*yi/(s^2) = ln(Li), s^2 = 1/ 10^ (SNRdb/10)
+            %decode
+            if(fast_run)
+                %optimal version (optimal-calculations of f/g)
+                outputs = decode2(llr,frozen_bits);
+            else
+                %hardware-version (suboptimal-calculations of f/g)
+                outputs = decode(llr,frozen_bits,partial_sum_adders,sc_functions,sc_2nd_indxs); %or decode2(llr,frozen_bits); for the other algorithm
+            end
+            %Calculate temporary bit/frame errors
+            final_outputs = transform_outputs(outputs,frozen_bits,N);
+            temp_bit_errors = size(find(final_outputs ~= inputs),2);
+            bit_errors = bit_errors + temp_bit_errors;
+            fer_errors = fer_errors + (temp_bit_errors>0);
+        end
+        %Calculate snr bit/frame errors
+        bit_error_rate(index_n,i_index) = bit_errors/(codewords_tmp*K);
+        fer_error_rate(index_n,i_index) = fer_errors/(codewords_tmp);
+        codewords(index_n,i_index) = codewords_tmp;
+        legends(index_n) = [num2str(N), '/', num2str(K)];
+        %Update plot figures
+        %Save results for particular n & snr
+        save(mat_file,'snrdb_values','EbNo_dB','bit_error_rate','fer_error_rate','codewords','N','K','Fading_Channel','Fading_Independent','fading_channel');
+        %Display
+        fprintf('EbNo = %.1f\tber=%0.5f,fer=%0.5f\n',EbNo_dB(i_index),bit_error_rate(index_n,i_index),fer_error_rate(index_n,i_index));
+    end
+    % file = fopen([result_path 'results_N=' num2str(N) '_SNR=' num2str(snrdb_values(1)) '-' num2str(snrdb_values(end)) '.txt'],'w');
 end
-%or decode(llr,frozen_bits); for the other algorithm
-%choose A set (not frozen bits)
-%Calculate bit/frame errors
-final_outputs = transform_outputs(outputs,frozen_bits,N);
-temp_bit_errors = size(find(final_outputs ~= inputs),2);
-bit_errors = bit_errors + temp_bit_errors;
-fer_errors = fer_errors + (temp_bit_errors>0);
-end
-bit_error_rate(i_index) = bit_errors/(codewords_tmp*K);
-fer_error_rate(i_index) = fer_errors/(codewords_tmp);
-codewords(i_index) = codewords_tmp;
-save(mat_file,'snrdb_values','bit_error_rate','fer_error_rate','codewords','N','K');
-fprintf('SNRdb = %.1f\tber=%0.2f,fer=%0.2f\n',snrdb_values(i_index),bit_error_rate(i_index),fer_error_rate(i_index));
-end
-% file = fopen([result_path 'results_N=' num2str(N) '_SNR=' num2str(snrdb_values(1)) '-' num2str(snrdb_values(end)) '.txt'],'w');
-% fprintf(file,'0]\n');
-end
-    
+plot_script;

support/plot_script.m

@@ -0,0 +1,30 @@
+% % draw the BER vs Eb/N0 plot
+if(Fading_Channel)
+    channel_str = 'Fading';
+else
+    channel_str = 'AWGN';
+end
+figure(1)
+semilogy(EbNo_dB(1:length(find(bit_error_rate(index_n,:) ~= 0))), bit_error_rate(:,1:length(find(bit_error_rate(index_n,:) ~= 0))),'LineWidth', 2, 'MarkerSize',10);
+% axis([EbNo_dB(1) EbNo_dB(length(find(BER_list_1 ~= 0))) min(min(BER_list_1((BER_list_1 ~= 0))),min(BER_list_2((BER_list_2 ~= 0)))) max(max(BER_list_2((BER_list_1 ~= 0))),max(BER_list_1((BER_list_2 ~= 0))))])
+hold on;
+xlabel('Eb/N0 [dB]');
+ylabel('BER');
+
+title(['Polar codes ,' channel_str]);
+if(index_n == length(legends))
+    legend(legends,'Location','SouthWest');
+end
+grid on;
+% % draw the FER vs Eb/N0 plot
+figure(2)
+semilogy(EbNo_dB(1:length(find(fer_error_rate(index_n,:) ~= 0))), fer_error_rate(:,1:length(find(fer_error_rate(index_n,:) ~= 0))),'LineWidth', 2, 'MarkerSize',10);
+% axis([EbNo_dB(1) EbNo_dB(length(find(FER_list_1 ~= 0))) min(min(FER_list_1((FER_list_1 ~= 0))),min(FER_list_2((FER_list_2 ~= 0)))) max(max(FER_list_2((FER_list_1 ~= 0))),max(FER_list_1((FER_list_2 ~= 0))))])
+hold on;
+xlabel('Eb/N0 [dB]');
+ylabel('FER');
+title(['Polar codes ,' channel_str]);
+if(index_n == length(legends))
+    legend(legends,'Location','SouthWest');
+end
+grid on;

support/polar_initialization.m

@@ -0,0 +1,9 @@
+function [ Fn,frozen_bits,partial_sum_adders, sc_functions, sc_2nd_indxs] = polar_initialization( N, K, capacity )
+%POLAR_INITIALIZATION Summary of this function goes here
+%   Detailed explanation goes here
+Fn = fkronecker(N);
+frozen_bits = initialize_frozen_bits(N,K,capacity); %0=frozen, 1=not_frozen
+partial_sum_adders = partial_sums_initialize(N);   %!!!!! NOT bit_reversed array -- %outputs(z,i,l) -- l stage ,bit Ui is added,z is the number of g adder
+[sc_functions,sc_2nd_indxs] = sc_array_initialize(N);
+end
+