bvec decode(Convolutional_Code& nsc, int constraint_length, const bvec& decoder_input, int blockSize, bool verbose) { BPSK mod; vec decoder_input_mod = mod.modulate_bits(decoder_input); int codedLen = 2 * (blockSize + (constraint_length - 1)); int nBlock_rcvd = decoder_input_mod.length() / codedLen; if (verbose) {cout << "rcvd number of blocks : " << nBlock_rcvd << endl;} vec codedBlock(codedLen); bvec bit_rcvd_tmp(blockSize); bvec bit_decoded; for (int j = 0; j < nBlock_rcvd; j++) { for (int k = 0; k < codedLen; k++) { codedBlock[k] = decoder_input_mod[k + j*codedLen]; } //cout << codedBlock << endl; bit_rcvd_tmp = nsc.decode_tail(codedBlock); bit_decoded = concat(bit_decoded, bit_rcvd_tmp); } // Deal with residual sources if remainder exsists vec residual_bits = decoder_input_mod.get(nBlock_rcvd*codedLen, decoder_input_mod.length()-1); nsc.decode_tail( residual_bits, bit_rcvd_tmp); bit_decoded = concat(bit_decoded, bit_rcvd_tmp); if (verbose) {cout << "decode output : " << bit_decoded << endl;} return bit_decoded; }
bvec encode(Convolutional_Code& nsc, int constraint_length, const bvec& encoder_input, int blockSize, bool verbose) { if (verbose) {cout << "input : " << encoder_input << endl;} int codedLen = 2 * (blockSize + (constraint_length - 1)); int nBlocks = encoder_input.length() / blockSize; ivec window(blockSize); for (int j = 0; j < blockSize; j++) { window[j] = j; } bvec nsc_coded_bits(codedLen); bvec tr_coded_bits; for (int j = 0; j < nBlocks; j++) { nsc.encode_tail(encoder_input(window), nsc_coded_bits); window = window + blockSize; tr_coded_bits = concat(tr_coded_bits, nsc_coded_bits); } // Deal with residual sources if remainder exsists if (nBlocks*blockSize != encoder_input.length()) { bvec residual_bits = encoder_input.get(nBlocks*blockSize, encoder_input.length()-1); nsc.encode_tail(residual_bits, nsc_coded_bits); tr_coded_bits = concat(tr_coded_bits, nsc_coded_bits); } if (verbose) {cout << "encoder output: " << tr_coded_bits << endl;} return tr_coded_bits; }
// Note that this function assumes that d_est is ln(P(d_est==0|r)/P(d_est==1|r)) // This is different from the matlab function which assumes d_est // is simply P(d_est==0|r). bvec lte_conv_decode( const mat & d_est ) { Convolutional_Code coder; ivec generator(3); generator(0)=0133; generator(1)=0171; generator(2)=0165; coder.set_generator_polynomials(generator,7); vec d_est_v=cvectorize(d_est); bvec c_est=coder.decode_tailbite(d_est_v); return c_est; }
bmat lte_conv_encode( const bvec & c ) { Convolutional_Code coder; ivec generator(3); generator(0)=0133; generator(1)=0171; generator(2)=0165; coder.set_generator_polynomials(generator,7); bvec d_vec=coder.encode_tailbite(c); bmat d=reshape(d_vec,3,length(c)); return d; }
int main(int argc, char **argv) { // -- modulation and channel parameters (taken from command line input) -- int nC; // type of constellation (1=QPSK, 2=16-QAM, 3=64-QAM) int nRx; // number of receive antennas int nTx; // number of transmit antennas int Tc; // coherence time (number of channel vectors with same H) if (argc != 5) { cout << "Usage: cm nTx nRx nC Tc" << endl << "Example: cm 2 2 1 100000 (2x2 QPSK MIMO on slow fading channel)" << endl; exit(1); } else { sscanf(argv[1], "%i", &nTx); sscanf(argv[2], "%i", &nRx); sscanf(argv[3], "%i", &nC); sscanf(argv[4], "%i", &Tc); } cout << "Initializing.. " << nTx << " TX antennas, " << nRx << " RX antennas, " << (1 << nC) << "-PAM per dimension, coherence time " << Tc << endl; // -- simulation control parameters -- const vec EbN0db = "-5:0.5:50"; // SNR range const int Nmethods = 2; // number of demodulators to try const int Nbitsmax = 50000000; // maximum number of bits to ever simulate per SNR point const int Nu = 1000; // length of data packet (before applying channel coding) int Nbers, Nfers; // target number of bit/frame errors per SNR point double BERmin, FERmin; // BER/FER at which to terminate simulation if (Tc == 1) { // Fast fading channel, BER is of primary interest BERmin = 0.001; // stop simulating a given method if BER<this value FERmin = 1.0e-10; // stop simulating a given method if FER<this value Nbers = 1000; // move to next SNR point after counting 1000 bit errors Nfers = 200; // do not stop on this condition } else { // Slow fading channel, FER is of primary interest here BERmin = 1.0e-15; // stop simulating a given method if BER<this value FERmin = 0.01; // stop simulating a given method if FER<this value Nbers = -1; // do not stop on this condition Nfers = 200; // move to next SNR point after counting 200 frame errors } // -- Channel code parameters -- Convolutional_Code code; ivec generator(3); generator(0) = 0133; // use rate 1/3 code generator(1) = 0165; generator(2) = 0171; double rate = 1.0 / 3.0; code.set_generator_polynomials(generator, 7); bvec dummy; code.encode_tail(randb(Nu), dummy); const int Nc = length(dummy); // find out how long the coded blocks are // ============= Initialize ==================================== const int Nctx = (int)(2 * nC * nTx * ceil(double(Nc) / double(2 * nC * nTx))); // Total number of bits to transmit const int Nvec = Nctx / (2 * nC * nTx); // Number of channel vectors to transmit const int Nbitspvec = 2 * nC * nTx; // Number of bits per channel vector // initialize MIMO channel with uniform QAM per complex dimension and Gray coding ND_UQAM chan; chan.set_M(nTx, 1 << (2*nC)); cout << chan << endl; // initialize interleaver Sequence_Interleaver<bin> sequence_interleaver_b(Nctx); Sequence_Interleaver<int> sequence_interleaver_i(Nctx); sequence_interleaver_b.randomize_interleaver_sequence(); sequence_interleaver_i.set_interleaver_sequence(sequence_interleaver_b.get_interleaver_sequence()); // RNG_randomize(); Array<cvec> Y(Nvec); // received data Array<cmat> H(Nvec / Tc + 1); // channel matrix (new matrix for each coherence interval) ivec Contflag = ones_i(Nmethods); // flag to determine whether to run a given demodulator if (pow(2.0, nC*2.0*nTx) > 256) { // ML decoder too complex.. Contflag(1) = 0; } if (nTx > nRx) { Contflag(0) = 0; // ZF not for underdetermined systems } cout << "Running methods: " << Contflag << endl; cout.setf(ios::fixed, ios::floatfield); cout.setf(ios::showpoint); cout.precision(5); // ================== Run simulation ======================= for (int nsnr = 0; nsnr < length(EbN0db); nsnr++) { const double Eb = 1.0; // transmitted energy per information bit const double N0 = inv_dB(-EbN0db(nsnr)); const double sigma2 = N0; // Variance of each scalar complex noise sample const double Es = rate * 2 * nC * Eb; // Energy per complex scalar symbol // (Each transmitted scalar complex symbol contains rate*2*nC // information bits.) const double Ess = sqrt(Es); Array<BERC> berc(Nmethods); // counter for coded BER Array<BERC> bercu(Nmethods); // counter for uncoded BER Array<BLERC> ferc(Nmethods); // counter for coded FER for (int i = 0; i < Nmethods; i++) { ferc(i).set_blocksize(Nu); } long int nbits = 0; while (nbits < Nbitsmax) { nbits += Nu; // generate and encode random data bvec inputbits = randb(Nu); bvec txbits; code.encode_tail(inputbits, txbits); // coded block length is not always a multiple of the number of // bits per channel vector txbits = concat(txbits, randb(Nctx - Nc)); txbits = sequence_interleaver_b.interleave(txbits); // -- generate channel and data ---- for (int k = 0; k < Nvec; k++) { /* A complex valued channel matrix is used here. An alternative (with equivalent result) would be to use a real-valued (structured) channel matrix of twice the dimension. */ if (k % Tc == 0) { // generate a new channel realization every Tc intervals H(k / Tc) = Ess * randn_c(nRx, nTx); } // modulate and transmit bits bvec bitstmp = txbits(k * 2 * nTx * nC, (k + 1) * 2 * nTx * nC - 1); cvec x = chan.modulate_bits(bitstmp); cvec e = sqrt(sigma2) * randn_c(nRx); Y(k) = H(k / Tc) * x + e; } // -- demodulate -- Array<QLLRvec> LLRin(Nmethods); for (int i = 0; i < Nmethods; i++) { LLRin(i) = zeros_i(Nctx); } QLLRvec llr_apr = zeros_i(nC * 2 * nTx); // no a priori input to demodulator QLLRvec llr_apost = zeros_i(nC * 2 * nTx); for (int k = 0; k < Nvec; k++) { // zero forcing demodulation if (Contflag(0)) { chan.demodulate_soft_bits(Y(k), H(k / Tc), sigma2, llr_apr, llr_apost, ND_UQAM::ZF_LOGMAP); LLRin(0).set_subvector(k*Nbitspvec, llr_apost); } // ML demodulation if (Contflag(1)) { chan.demodulate_soft_bits(Y(k), H(k / Tc), sigma2, llr_apr, llr_apost); LLRin(1).set_subvector(k*Nbitspvec, llr_apost); } } // -- decode and count errors -- for (int i = 0; i < Nmethods; i++) { bvec decoded_bits; if (Contflag(i)) { bercu(i).count(txbits(0, Nc - 1), LLRin(i)(0, Nc - 1) < 0); // uncoded BER LLRin(i) = sequence_interleaver_i.deinterleave(LLRin(i), 0); // QLLR values must be converted to real numbers since the convolutional decoder wants this vec llr = chan.get_llrcalc().to_double(LLRin(i).left(Nc)); // llr=-llr; // UNCOMMENT THIS LINE IF COMPILING WITH 3.10.5 OR EARLIER (BEFORE HARMONIZING LLR CONVENTIONS) code.decode_tail(llr, decoded_bits); berc(i).count(inputbits(0, Nu - 1), decoded_bits(0, Nu - 1)); // coded BER ferc(i).count(inputbits(0, Nu - 1), decoded_bits(0, Nu - 1)); // coded FER } } /* Check whether it is time to terminate the simulation. Terminate when all demodulators that are still running have counted at least Nbers or Nfers bit/frame errors. */ int minber = 1000000; int minfer = 1000000; for (int i = 0; i < Nmethods; i++) { if (Contflag(i)) { minber = min(minber, round_i(berc(i).get_errors())); minfer = min(minfer, round_i(ferc(i).get_errors())); } } if (Nbers > 0 && minber > Nbers) { break;} if (Nfers > 0 && minfer > Nfers) { break;} } cout << "-----------------------------------------------------" << endl; cout << "Eb/N0: " << EbN0db(nsnr) << " dB. Simulated " << nbits << " bits." << endl; cout << " Uncoded BER: " << bercu(0).get_errorrate() << " (ZF); " << bercu(1).get_errorrate() << " (ML)" << endl; cout << " Coded BER: " << berc(0).get_errorrate() << " (ZF); " << berc(1).get_errorrate() << " (ML)" << endl; cout << " Coded FER: " << ferc(0).get_errorrate() << " (ZF); " << ferc(1).get_errorrate() << " (ML)" << endl; cout.flush(); /* Check wheter it is time to terminate simulation. Stop when all methods have reached the min BER/FER of interest. */ int contflag = 0; for (int i = 0; i < Nmethods; i++) { if (Contflag(i)) { if (berc(i).get_errorrate() > BERmin) { contflag = 1; } else { Contflag(i) = 0; } if (ferc(i).get_errorrate() > FERmin) { contflag = 1; } else { Contflag(i) = 0; } } } if (contflag) { continue; } else {break; } } return 0; }
int main(void) { //general parameters double threshold_value = 50; string map_metric="logMAP"; ivec gen = "037 021";//octal form int constraint_length = 5; int nb_errors_lim = 1500; int nb_bits_lim = int(1e6); int perm_len = pow2i(14);//permutation length int nb_iter = 10;//number of iterations in the turbo decoder vec EbN0_dB = "0:0.1:5"; double R = 1.0/4.0;//coding rate (non punctured SCCC) double Ec = 1.0;//coded bit energy //other parameters string filename = "Res/sccc_"+map_metric+".it"; int nb_bits_tail = perm_len/gen.length(); int nb_bits = nb_bits_tail-(constraint_length-1);//number of bits in a block (without tail) vec sigma2 = (0.5*Ec/R)*pow(inv_dB(EbN0_dB), -1.0);//N0/2 double Lc;//scaling factor for intrinsic information int nb_blocks;//number of blocks int nb_errors; bvec bits(nb_bits);//data bits bvec nsc_coded_bits;//tail is added bmat rsc_parity_bits; ivec perm(perm_len); ivec inv_perm(perm_len); int rec_len = gen.length()*perm_len; bvec coded_bits(rec_len); vec rec(rec_len); //SISO RSC vec rsc_intrinsic_coded(rec_len); vec rsc_apriori_data(perm_len); vec rsc_extrinsic_coded; vec rsc_extrinsic_data; //SISO NSC vec nsc_intrinsic_coded(perm_len); vec nsc_apriori_data(nb_bits_tail); nsc_apriori_data.zeros();//always zero vec nsc_extrinsic_coded; vec nsc_extrinsic_data; //decision bvec rec_bits(nb_bits_tail); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n; //Non recursive non Systematic Convolutional Code Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); //Recursive Systematic Convolutional Code Rec_Syst_Conv_Code rsc; rsc.set_generator_polynomials(gen, constraint_length);//initial state should be the zero state //BPSK modulator BPSK bpsk; //AWGN channel AWGN_Channel channel; //SISO blocks SISO siso; siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); //BER BERC berc; //Progress timer tr::Progress_Timer timer; timer.set_max(snr_len); //Randomize generators RNG_randomize(); //main loop timer.progress(0.0); for (en=0;en<snr_len;en++) { channel.set_noise(sigma2(en)); Lc = -2.0/sigma2(en);//take into account the BPSK mapping nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*nb_bits<nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(nb_bits); //serial concatenated convolutional code nsc.encode_tail(bits, nsc_coded_bits);//tail is added here to information bits to close the trellis nsc_coded_bits = nsc_coded_bits(perm);//interleave rsc.encode(nsc_coded_bits, rsc_parity_bits);//no tail added for(n=0;n<perm_len;n++) { coded_bits(2*n) = nsc_coded_bits(n);//systematic output coded_bits(2*n+1) = rsc_parity_bits(n,0);//parity output } //BPSK modulation (1->-1,0->+1) + channel rec = channel(bpsk.modulate_bits(coded_bits)); //turbo decoder rsc_intrinsic_coded = Lc*rec;//intrinsic information of coded bits rsc_apriori_data.zeros();//a priori LLR for information bits for (n=0;n<nb_iter;n++) { //first decoder siso.rsc(rsc_extrinsic_coded, rsc_extrinsic_data, rsc_intrinsic_coded, rsc_apriori_data, false); //deinterleave+threshold nsc_intrinsic_coded = threshold(rsc_extrinsic_data(inv_perm), threshold_value); //second decoder siso.nsc(nsc_extrinsic_coded, nsc_extrinsic_data, nsc_intrinsic_coded, nsc_apriori_data, true); //decision rec_bits = bpsk.demodulate_bits(-nsc_extrinsic_data);//suppose that a priori info is zero //count errors berc.clear(); berc.count(bits, rec_bits.left(nb_bits)); ber(n,en) += berc.get_errorrate(); //interleave rsc_apriori_data = nsc_extrinsic_coded(perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); //show progress timer.progress(1+en); } timer.toc_print(); #ifdef TO_FILE //save results to file it_file ff(filename); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff << Name("gen") << gen; ff << Name("R") << R; ff << Name("nb_iter") << nb_iter; ff << Name("total_nb_bits") << nb_bits; ff << Name("nb_errors_lim") << nb_errors_lim; ff << Name("nb_bits_lim") << nb_bits_lim; ff.close(); #else //show BER cout << ber << endl; #endif return 0; }
int main( int argc, char* argv[]) { //Arg initial here int Number_of_bits = 2048; //Declarations basic int i; double Ps, N0, dist_1, dist_2, h1, h2, Eb; double EbN0; double rcvd_power_1, rcvd_power_2; int nFFT, nCylicPrefix; //Read arg Simple if( argc == 4) { Number_of_bits = atoi( argv[1]); dist_1 = strtod(argv[2], NULL); dist_2 = strtod(argv[3], NULL); } //Declare vectors and others vec alpha; //vec is a vector containing double vec bit_error_rate_1, bit_error_rate_2; vec ber_theo_1, ber_theo_2; // Theoretical results for multiple access bvec transmitted_bits_1, transmitted_bits_2; //bvec is a vector containing bits bvec received_bits_1, received_bits_2; cvec transmitted_symbols_1, transmitted_symbols_2, transmitted_symbols; //cvec is a vector containing double_complex cvec received_symbols_1, received_symbols_2, feedback_symbols_1, feedback_symbols_2; cvec ofdm_symbols_1, ofdm_symbols_2; // Declarations of classes: QPSK mod; //The QPSK modulator class QAM qammod(16); //QAM-16 //QAM mod(64); // -64 AWGN_Channel awgn_channel; //The AWGN channel class it_file ff; //For saving the results to file BERC berc; //Used to count the bit errors Real_Timer tt; //The timer used to measure the execution time OFDM ofdm; //OFDM modulator class MA_Filter<std::complex<double>, std::complex<double>, std::complex<double> > multipath_channel; //Simulate multi-path enviornment int ch_nb_taps = 3; cvec ini_state = to_cvec( zeros(ch_nb_taps)); vec ch_imp_response_real = "1.000000000000000 0.436232649307735 0.198694326007661";//randray( ch_nb_taps); ch_imp_response_real /= sqrt(sum_sqr( ch_imp_response_real));//normalized power profile cvec ch_imp_response = to_cvec( ch_imp_response_real); multipath_channel.set_coeffs( ch_imp_response); multipath_channel.set_state(ini_state);//inital state is zero //Reset and start the timer: tt.tic(); //Init: //Ps = 5 * pow(10, -3); //The transmitted energy per mod symbol is 1, 5e-3 W/MHz 802.11 Ps = 4 * pow(10, 0.0); //ETSI TS 136 104 V9.4.0 (2010-07) p17 LTE JAPAN 4 W/MHz //Ps = 4 * pow(10, 1.0); //max 46 dbm N0 = 4 * pow(10, -15); //Thermal noise -144dBm/MHz //dist_1 = 800; //Distance form transmitter to receiver 1 (meter) //dist_2 = 1000; // * 2 double f = 2600; // Mhz 150-1500 double hM = 2; // meter 1-10 double hb = 120; // meter 30-200 double C_H = 0.8 + (1.1 * log10(f) - 0.7) * hM - 1.56 * log10(f); // Hata medium size city double h1dB = 69.55 + 26.16 * log10(f) - 13.82*log10(hb) - C_H + (44.9 - 6.55*log10(hb)) * log10(dist_1/1000); double h2dB = 69.55 + 26.16 * log10(f) - 13.82*log10(hb) - C_H + (44.9 - 6.55*log10(hb)) * log10(dist_2/1000); //cout << "HatadB:" << h1dB << endl; //cout << "HatadB:" << h2dB << endl; //h1 = pow(10, -h1dB/10); //h2 = pow(10, -h2dB/10); h1 = pow(dist_1, -4.5); //Channel gain for receiver 1 h2 = pow(dist_2, -4.5); // cout << "h1 = " << h1 << " h2 = " << h2 << endl; alpha = linspace(0.3, 0.0, 13);//Simulate for different weight on power nFFT = 2048; //FFT size, default is 2048 LTE-a nCylicPrefix = 144; //Length of Prefix, standard 144 (first prefix is different in real case) // test upconv cvec ocsi; cvec t_spanned; double unit_time = 3.25520833 * pow(10,-8); // 1/(2048*15k) const double pi = 3.1415926535897; const std::complex<double> unit_img (0.0,1.0); double fc = 2.6 * pow(10,9); // 2.6GHz t_spanned.set_size(2048, false); for (int i = 0; i < 2048; i++) { t_spanned[i] = exp(2*pi*fc*unit_time*i*unit_img); } // Declarations for equalizer & NSC coding ivec gen = "07 05"; //octal notation int constraint_length = 3; //constraint length int blockSize = 13;//permutation length //encoder output block size // other parameters int nb_bits_tail = blockSize / gen.length(); //encoder input size + tail size int nb_bits = nb_bits_tail - (constraint_length - 1); //encoder block size int nb_blocks; //number of blocks // Convolutional code Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); //Allocate storage space for the result vector. //The "false" argument means "Do not copy the old content of the vector to the new storage area." bit_error_rate_1.set_size(alpha.length(), false); bit_error_rate_2.set_size(alpha.length(), false); //Storage for theoretical ber ber_theo_1.set_size(alpha.length(), false); ber_theo_2.set_size(alpha.length(), false); //Randomize the random number generators in it++: RNG_randomize(); //Set OFDM parameters ofdm.set_parameters(nFFT, nCylicPrefix); //Iterate over all EbN0dB values: for (i = 0; i < alpha.length(); i++) { //Show how the simulation progresses: //cout << "Now simulating alpha value = " << alpha(i); //cout << " # " << i + 1 << "/" << alpha.length() << endl; //Generate a vector of random bits to transmit: transmitted_bits_1 = randb(Number_of_bits*2); transmitted_bits_2 = randb(Number_of_bits); //convolutional code encode //bvec out_binary_1 = encode(nsc, constraint_length, transmitted_bits_1, blockSize, false); //bvec out_binary_2 = encode(nsc, constraint_length, transmitted_bits_2, blockSize, false); bvec out_binary_1 = transmitted_bits_1; bvec out_binary_2 = transmitted_bits_2; //Modulate the bits to mod symbols: transmitted_symbols_1 = qammod.modulate_bits(out_binary_1); transmitted_symbols_2 = mod.modulate_bits(out_binary_2); //Multiplex two signals transmitted_symbols = transmitted_symbols_1 * pow(alpha(i), 0.5) + transmitted_symbols_2 * pow(1 - alpha(i), 0.5); transmitted_symbols = transmitted_symbols * pow(Ps, 0.5); //eval_avg_power(transmitted_symbols); //Fading transmitted_symbols_1 = transmitted_symbols * pow(h1, 0.5); transmitted_symbols_2 = transmitted_symbols * pow(h2, 0.5); //OFDM modulate zero_pad_back(transmitted_symbols_1, 2048); zero_pad_back(transmitted_symbols_2, 2048); ofdm.modulate(transmitted_symbols_1, ofdm_symbols_1); ofdm.modulate(transmitted_symbols_2, ofdm_symbols_2); //Set the noise variance of the AWGN channel: //ofdm_symbols_1 = concat(ofdm_symbols_1, zeros_c(2)); //B //ofdm_symbols_2 = concat(ofdm_symbols_2, zeros_c(2)); //B //ofdm_symbols_1 = concat(ofdm_symbols_1, zeros_c(4)); //A //ofdm_symbols_2 = concat(ofdm_symbols_2, zeros_c(4)); //A //cout << "N0: " << N0 << endl; awgn_channel.set_noise(N0); //Up-conversion //Run the transmited symbols through the channel using the () operator: //ofdm_symbols_1 = awgn_channel( multipath_channel( ofdm_symbols_1)); //ofdm_symbols_2 = awgn_channel( multipath_channel( ofdm_symbols_2)); ofdm_symbols_1 = awgn_channel( ofdm_symbols_1); ofdm_symbols_2 = awgn_channel( ofdm_symbols_2); //ofdm_symbols_1 = ofdm_symbols_1.get(0, ofdm_symbols_1.length()-3); //B //ofdm_symbols_2 = ofdm_symbols_2.get(0, ofdm_symbols_2.length()-3); //B // test zone!! KEEP OUT!! //A /*cvec ofdm_symbols_eqed_tmp; mmse_equalizer_simple(ofdm_symbols_1, ofdm_symbols_eqed_tmp, ch_imp_response_real, N0, false); ofdm_symbols_1 = ofdm_symbols_eqed_tmp; mmse_equalizer_simple(ofdm_symbols_2, ofdm_symbols_eqed_tmp, ch_imp_response_real, N0, false); ofdm_symbols_2 = ofdm_symbols_eqed_tmp;*/ //alpha no greater than 0.5 //OFDM demodulate ofdm.demodulate(ofdm_symbols_1, received_symbols_1); ofdm.demodulate(ofdm_symbols_2, received_symbols_2); //cvec FDMtmp; //B //FDE(received_symbols_1, FDMtmp, ch_imp_response_real, 2048, false); //B //ofdm_symbols_1 = FDMtmp; //B //FDE(received_symbols_2, FDMtmp, ch_imp_response_real, 2048, false); //B //ofdm_symbols_2 = FDMtmp; //B //Demodulate the received mod symbols into received bits: Layer 1 received_bits_2 = mod.demodulate_bits(received_symbols_2 / pow(1-alpha(i), 0.5) / pow(Ps, 0.5) / pow(h2, 0.5)); //bvec out_binary_recover_2 = decode(nsc, constraint_length, received_bits_2, blockSize, false); bvec out_binary_recover_2 = received_bits_2; //Demodulate the received mod symbols into received bits: Layer 2 received_bits_1 = mod.demodulate_bits(received_symbols_1 / pow(1-alpha(i), 0.5) / pow(Ps, 0.5) / pow(h1, 0.5)); feedback_symbols_2 = pow(Ps * (1-alpha(i)) * h1, 0.5) * mod.modulate_bits(received_bits_1); received_bits_1 = qammod.demodulate_bits((received_symbols_1-feedback_symbols_2) / pow(alpha(i), 0.5) / pow(Ps, 0.5) / pow(h1, 0.5)); //bvec out_binary_recover_1 = decode(nsc, constraint_length, received_bits_1, blockSize, false); bvec out_binary_recover_1 = received_bits_1; //Calculate the bit error rate: berc.clear(); //Clear the bit error rate counter berc.count(transmitted_bits_2, out_binary_recover_2.get(0, Number_of_bits)); //Count the bit errors bit_error_rate_2(i) = berc.get_errorrate(); //Save the estimated BER in the result vector berc.clear(); berc.count(transmitted_bits_1, out_binary_recover_1.get(0, Number_of_bits)); bit_error_rate_1(i) = berc.get_errorrate(); } tt.toc(); // Theoretical results for multiple access for (size_t i = 0; i < alpha.length(); ++i) { //BER for theo 1 EbN0 = (Ps * 0.5 * h1 * alpha(i)) / (N0 + Ps * 0.5 * h1 * (1 - alpha(i))); ber_theo_1(i) = 0.5*erfc(pow(EbN0, 0.5)); } for (size_t i = 0; i < alpha.length(); ++i) { //BER for theo 2 EbN0 = (Ps * 0.5 * h2 * (1-alpha(i))) / N0; ber_theo_2(i) = 0.5*erfc(pow(EbN0, 0.5)); } //Print the results: cout << endl; time_t rawtime; time (&rawtime); std::string nowTime( ctime( &rawtime)); /*cout << nowTime << endl; cout << "alpha = " << alpha << " " << endl; cout << "BER 1 = " << bit_error_rate_1 << endl; cout << "BER 2 = " << bit_error_rate_2 << endl; cout << "Theoretical BER 1 = " << ber_theo_1 << endl; cout << "Theoretical BER 2 = " << ber_theo_2 << endl; cout << endl;*/ //Chech feasibility bool feasibility = false; double threshold = 0.01; for (size_t i = 1; i < alpha.length(); i++) { if (bit_error_rate_1(i) < threshold && bit_error_rate_2(i) < threshold) { feasibility = true; } } if (feasibility) { cout << " PASS " << endl; } //Save the results to file: const char xFilename[] = "result"; char oFilename[100]; int fileIndex = 0; strcpy( oFilename, xFilename); while(std::ifstream( oFilename)){ ++fileIndex; sprintf( oFilename, "%s%d", xFilename, fileIndex); } cout << "Saving results to " << oFilename << endl; std::ofstream oo; oo.open(oFilename); oo << alpha << endl; oo << bit_error_rate_1 << endl; oo << bit_error_rate_2 << endl; oo.close(); //Exit program: return 0; }
int main(void) { //general parameters double threshold_value = 50; string map_metric = "maxlogMAP"; ivec gen = "07 05";//octal notation int constraint_length = 3; int ch_nb_taps = 4;//number of channel multipaths int nb_errors_lim = 3000; int nb_bits_lim = int(1e6); int perm_len = pow2i(14);//permutation length int nb_iter = 10;//number of iterations in the turbo decoder vec EbN0_dB = "0:0.5:10"; double R = 1.0 / 2.0;//coding rate of FEC double Ec = 1.0;//coded bit energy #ifdef USE_PRECODER ivec prec_gen = "03 02";//octal notation int prec_gen_length = 2; #endif //other parameters int nb_bits_tail = perm_len / gen.length(); int nb_bits = nb_bits_tail - (constraint_length - 1);//number of bits in a block (without tail) vec sigma2 = (0.5 * Ec / R) * pow(inv_dB(EbN0_dB), -1.0);//N0/2 int nb_blocks;//number of blocks int nb_errors; bvec bits(nb_bits);//data bits bvec nsc_coded_bits(perm_len);//tail is added bvec em_bits(perm_len); bmat parity_bits; ivec perm(perm_len); ivec inv_perm(perm_len); vec rec(perm_len); //SISO equalizer vec eq_apriori_data(perm_len); vec eq_extrinsic_data; //SISO NSC vec nsc_intrinsic_coded(perm_len); vec nsc_apriori_data(nb_bits_tail); nsc_apriori_data.zeros();//always zero vec nsc_extrinsic_coded; vec nsc_extrinsic_data; //decision bvec rec_bits(nb_bits_tail); int snr_len = EbN0_dB.length(); mat ber(nb_iter, snr_len); ber.zeros(); register int en, n; //CCs Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); #ifdef USE_PRECODER Rec_Syst_Conv_Code prec; prec.set_generator_polynomials(prec_gen, prec_gen_length); #endif //BPSK BPSK bpsk; //AWGN AWGN_Channel awgn; //multipath channel impulse response (Rayleigh fading) with real coefficients vec ch_imp_response(ch_nb_taps); vec ini_state = ones(ch_nb_taps);//initial state is zero MA_Filter<double, double, double> multipath_channel; //SISO blocks SISO siso; siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); #ifdef USE_PRECODER siso.set_precoder_generator(prec_gen(0), prec_gen_length); #endif //BER BERC berc; //Randomize generators RNG_randomize(); //main loop for (en = 0;en < snr_len;en++) { cout << "EbN0_dB = " << EbN0_dB(en) << endl; awgn.set_noise(sigma2(en)); siso.set_noise(sigma2(en)); nb_errors = 0; nb_blocks = 0; while ((nb_errors < nb_errors_lim) && (nb_blocks*nb_bits < nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(nb_bits); //convolutional code nsc.encode_tail(bits, nsc_coded_bits);//tail is added here to information bits to close the trellis //permutation em_bits = nsc_coded_bits(perm); #ifdef USE_PRECODER //precoder prec.encode(em_bits, parity_bits); em_bits = parity_bits.get_col(0); #endif //BPSK modulation (1->-1,0->+1) + multipath channel ch_imp_response = randray(ch_nb_taps); ch_imp_response /= sqrt(sum_sqr(ch_imp_response));//normalized power profile multipath_channel.set_coeffs(ch_imp_response); multipath_channel.set_state(ini_state);//inital state is zero rec = awgn(multipath_channel(bpsk.modulate_bits(em_bits))); //turbo equalizer eq_apriori_data.zeros();//a priori information of emitted symbols siso.set_impulse_response(ch_imp_response); for (n = 0;n < nb_iter;n++) { //first decoder siso.equalizer(eq_extrinsic_data, rec, eq_apriori_data, false);//no tail //deinterleave+threshold nsc_intrinsic_coded = SISO::threshold(eq_extrinsic_data(inv_perm), threshold_value); //second decoder siso.nsc(nsc_extrinsic_coded, nsc_extrinsic_data, nsc_intrinsic_coded, nsc_apriori_data, true);//tail //decision rec_bits = bpsk.demodulate_bits(-nsc_extrinsic_data);//assume that a priori info is zero //count errors berc.clear(); berc.count(bits, rec_bits.left(nb_bits)); ber(n, en) += berc.get_errorrate(); //interleave eq_apriori_data = nsc_extrinsic_coded(perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en) / nb_blocks); } //save results to file it_file ff("turbo_equalizer_bersim_multipath.it"); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff.close(); return 0; }
int main(void) { //general parameters string mud_method = "maxlogTMAP"; int nb_usr = 2; int spreading_factor = 16; #ifdef USE_CC string map_metric="maxlogMAP"; ivec gen = "037 021"; int constraint_length = 5; spreading_factor = 8; #endif double threshold_value = 50; int ch_nb_taps = 4;//number of channel multipaths int nb_errors_lim = 1500; int nb_bits_lim = int(1e3);//int(1e6); int perm_len = 1024;//38400;//permutation length int nb_iter = 15;//number of iterations in the turbo decoder vec EbN0_dB = "10";//"0:10:20"; double Ec = 1.0;//chip energy #ifdef USE_CC int inv_R = spreading_factor*gen.length(); #else int inv_R = spreading_factor; #endif double R = 1.0/double(inv_R);//coding rate //other parameters string filename = "IDMA_"+mud_method+"_"+to_str(nb_usr)+".it"; #ifdef USE_CC filename = "cc"+filename; #endif filename = "Res/"+filename; int nb_bits = perm_len/inv_R;//number of bits in a block vec sigma2 = (0.5*Ec/R)*pow(inv_dB(EbN0_dB), -1.0);//N0/2 int nb_blocks = 0;//number of blocks int nb_errors = 0;//number of errors bmat bits(nb_usr,nb_bits);//data bits #ifdef USE_CC bvec coded_bits(nb_bits*gen.length()); vec mod_bits(nb_bits*gen.length()); #else vec mod_bits(nb_bits); #endif vec chips(perm_len); imat perm(nb_usr,perm_len); imat inv_perm(nb_usr,perm_len); vec em(perm_len); vec rec(perm_len+ch_nb_taps-1);//padding zeros are added //SISO MUD mat mud_apriori_data(nb_usr,perm_len); mat mud_extrinsic_data; //SISO decoder (scrambler or CC) vec dec_intrinsic_coded(perm_len); vec dec_apriori_data(nb_bits); dec_apriori_data.zeros();//always zero vec dec_extrinsic_coded; vec dec_extrinsic_data; //decision bvec rec_bits(nb_bits); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n,u; #ifdef USE_CC //CC Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); #endif //BPSK BPSK bpsk; //scrambler pattern vec pattern = kron(ones(spreading_factor/2), vec("1.0 -1.0")); //AWGN AWGN_Channel awgn; //multipath channel impulse response (Rayleigh fading) with real coefficients vec single_ch(ch_nb_taps); mat ch_imp_response(nb_usr, ch_nb_taps); vec ini_state = zeros(ch_nb_taps); MA_Filter<double,double,double> multipath_channel(ini_state); multipath_channel.set_state(ini_state);//initial state is always 0 due to Zero Padding technique vec padding_zeros = zeros(ch_nb_taps-1); //SISO blocks SISO siso; siso.set_scrambler_pattern(pattern); siso.set_mud_method(mud_method); #ifdef USE_CC siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); siso.set_tail(false); #endif //BER BERC berc; //progress timer tr::Progress_Timer timer; timer.set_max(snr_len); //Randomize generators RNG_randomize(); //main loop timer.progress(0.0); for (en=0; en<snr_len; en++) { awgn.set_noise(sigma2(en)); siso.set_noise(sigma2(en)); nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*nb_bits<nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { rec.zeros(); for (u=0; u<nb_usr; u++) { //permutation perm.set_row(u, sort_index(randu(perm_len))); //inverse permutation inv_perm.set_row(u, sort_index(perm.get_row(u))); //bits generation bits.set_row(u, randb(nb_bits)); #ifdef USE_CC //convolutional code nsc.encode(bits.get_row(u), coded_bits);//no tail //BPSK modulation (1->-1,0->+1) mod_bits = bpsk.modulate_bits(coded_bits); #else //BPSK modulation (1->-1,0->+1) mod_bits = bpsk.modulate_bits(bits.get_row(u)); #endif //scrambler chips = kron(mod_bits, pattern); //permutation em = chips(perm.get_row(u)); //multipath channel single_ch = randray(ch_nb_taps); single_ch /= sqrt(sum_sqr(single_ch));//normalized power profile ch_imp_response.set_row(u, single_ch); multipath_channel.set_coeffs(ch_imp_response.get_row(u)); rec += multipath_channel(concat(em, padding_zeros));//Zero Padding } rec = awgn(rec); //turbo MUD mud_apriori_data.zeros();//a priori LLR of emitted symbols siso.set_impulse_response(ch_imp_response); for (n=0; n<nb_iter; n++) { //MUD siso.mud(mud_extrinsic_data, rec, mud_apriori_data); berc.clear();//mean error rate over all users for (u=0; u<nb_usr; u++) { //deinterleave dec_intrinsic_coded = mud_extrinsic_data.get_row(u)(inv_perm.get_row(u)); #ifdef USE_CC //decoder+descrambler siso.nsc(dec_extrinsic_coded, dec_extrinsic_data, dec_intrinsic_coded, dec_apriori_data); #else //descrambler siso.descrambler(dec_extrinsic_coded, dec_extrinsic_data, dec_intrinsic_coded, dec_apriori_data); #endif //decision rec_bits = bpsk.demodulate_bits(-dec_extrinsic_data);//suppose that a priori info is zero //count errors berc.count(bits.get_row(u), rec_bits); //interleave+threshold mud_apriori_data.set_row(u, threshold(dec_extrinsic_coded(perm.get_row(u)), threshold_value)); } ber(n,en) += berc.get_errorrate(); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); //show progress timer.progress(1+en); } timer.toc_print(); //save results to file #ifdef TO_FILE it_file ff(filename); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff << Name("nb_usr") << nb_usr; ff << Name("gen") << spreading_factor; ff << Name("nb_iter") << nb_iter; ff << Name("total_nb_bits") << nb_bits; ff << Name("nb_errors_lim") << nb_errors_lim; ff << Name("nb_bits_lim") << nb_bits_lim; #ifdef USE_CC ff << Name("gen") << gen; #endif ff.close(); #else //show BER cout << ber << endl; #endif return 0; }
int main(int argc, char *argv[]) { //receiver parameters ivec gen = "0133 0171"; int constraint_length = 7; int const_size = 16;//constellation size int coherence_time = 512;//expressed in symbol durations, multiple of T, T<=coherence_time<=tx_duration, T is the ST code duration double threshold_value = 50; string map_metric="maxlogMAP"; string demapper_method = "mmsePIC";//Hassibi_maxlogMAP or GA or sGA or mmsePIC or zfPIC or Alamouti_maxlogMAP int nb_errors_lim = 1500; int nb_bits_lim = int(1e6); int perm_len = pow2i(14);//permutation length int nb_iter = 5;//number of iterations in the turbo decoder int rec_antennas = 2;//number of reception antennas vec EbN0_dB = "0:20"; double Es = 1.0;//mean symbol energy int em_antennas = 2;//number of emission antennas int channel_uses = 1;//ST code duration string code_name = "V-BLAST_MxN";//V-BLAST_MxN, Golden_2x2, Damen_2x2, Alamouti_2xN bool ideal_channel = false; bool to_file = false; //get parameters if any if (EXIT_FAILURE == get_opts(argc, argv, demapper_method, const_size, nb_errors_lim, nb_bits_lim, perm_len, nb_iter, rec_antennas, em_antennas, channel_uses, code_name, ideal_channel, to_file, EbN0_dB)) { print_help(argv[0]); return EXIT_FAILURE; } //convolutional code generator polynomials Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); double coding_rate = 1.0/2.0; //QAM modulator class QAM mod(const_size); //Space-Time code parameters STC st_block_code(code_name, const_size, em_antennas, channel_uses);//generate matrices for LD code (following Hassibi's approach) int symb_block = st_block_code.get_nb_symbols_per_block(); em_antennas = st_block_code.get_nb_emission_antenna();//these parameters could by changed depending on the selected code channel_uses = st_block_code.get_channel_uses(); //recompute interleaver length int G = coherence_time*mod.bits_per_symbol()*symb_block; perm_len = G*(perm_len/G);//recompute interleaver length int block_len = int(coding_rate*perm_len);//informational block length int nb_symb = perm_len/mod.bits_per_symbol();//number of symbols at the modulator output int nb_subblocks = nb_symb/symb_block;//number of blocks of ST code emitted in an interleaver period int tx_duration = channel_uses*nb_subblocks;//transmission duration expressed in number of symbol periods //show configuration parameters std::cout << "const_size = " << const_size << "\ndemapper_method = " << demapper_method << "\nnb_errors_lim = " << nb_errors_lim << "\nnb_bits_lim = " << nb_bits_lim << "\nperm_len = " << perm_len << "\ncode_name = " << code_name << "\nem_antennas = " << em_antennas << "\nchannel_uses = " << channel_uses << "\nnb_iter = " << nb_iter << "\nrec_antennas = " << rec_antennas << "\nEbN0_dB = " << EbN0_dB << std::endl; if (true == ideal_channel) { if (em_antennas == rec_antennas) { std::cout << "Using ideal AWGN MIMO channel (no MAI)" << std::endl; } else { std::cout << "Warning: cannot use ideal AWGN MIMO channel" << std::endl; ideal_channel = false; } } else { std::cout << "Using random MIMO channel (with MAI)" << std::endl; } //fading channel parameters if (coherence_time%channel_uses)//check if the coherence time is a multiple of channel_uses { coherence_time = channel_uses*(coherence_time/channel_uses); std::cout << "Warning! The coherence time must be a multiple of T. Choosing coherence_time=channel_uses*floor(coherence_time/channel_uses) = "\ << coherence_time << std::endl; } if (coherence_time>tx_duration) { coherence_time = channel_uses*(tx_duration/channel_uses); std::cout << "Warning! The coherence time must be <= tx_duration. Choosing coherence_time = channel_uses*floor(tx_duration/channel_uses) = "\ << coherence_time << std::endl; } cmat fading_pattern = ones_c(1, coherence_time/channel_uses); //other parameters string filename = "STBICM_"+map_metric+"_"+demapper_method+".it"; if (true == to_file) { std::cout << "Saving results to " << filename << std::endl; } double R = coding_rate*double(mod.bits_per_symbol()*symb_block)/double(channel_uses);//ST code rate in (info.) bits/channel use vec sigma2 = (0.5*Es/(R*double(mod.bits_per_symbol())))*pow(inv_dB(EbN0_dB), -1.0);//N0/2 int nb_blocks;//number of blocks int nb_errors; bvec bits(block_len);//data bits bvec coded_bits(perm_len);//no tail cvec em(nb_symb); ivec perm(perm_len); ivec inv_perm(perm_len); //SISO demapper vec demapper_apriori_data(perm_len); vec demapper_extrinsic_data(perm_len); //SISO NSC vec nsc_intrinsic_coded(perm_len); vec nsc_apriori_data(block_len); nsc_apriori_data.zeros();//always zero vec nsc_extrinsic_coded(perm_len); vec nsc_extrinsic_data(block_len); //decision bvec rec_bits(block_len); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n,ns; cmat S(tx_duration, em_antennas); cmat rec(tx_duration,rec_antennas); //Rayleigh fading cmat ch_attenuations(em_antennas*rec_antennas,tx_duration/channel_uses); //SISO blocks SISO siso; siso.set_map_metric(map_metric); siso.set_generators(gen, constraint_length); siso.set_demapper_method(demapper_method); siso.set_constellation(mod.bits_per_symbol(), mod.get_symbols()/sqrt(em_antennas), mod.get_bits2symbols()); siso.set_st_block_code(st_block_code.get_nb_symbols_per_block(), st_block_code.get_1st_gen_matrix(), st_block_code.get_2nd_gen_matrix(), rec_antennas); //decision BPSK bpsk; //BER BERC berc; //Randomize generators RNG_randomize(); //main loop std::cout << std::endl; for (en=0;en<snr_len;en++) { std::cout << "EbN0_dB = " << EbN0_dB[en] << std::endl; siso.set_noise(sigma2(en)); nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*block_len<nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(block_len); //convolutional code nsc.encode(bits, coded_bits);//no tail //permutation+QAM modulation em = mod.modulate_bits(coded_bits(perm))/sqrt(em_antennas);//normalize emitted symbols //ST code S = st_block_code.encode(em); /* channel matrices (there are tx_duration/tau_c different channel matrices MxN) * a channel matrix is represented as a M*Nx1 vector (first M elements are the first column of the channel matrix) * the channel matrix is constant over tau_c symbol periods (a multiple of T symbol durations) * the channel matrix is the transpose of the true channel matrix */ if (false == ideal_channel) { ch_attenuations = kron(randn_c(em_antennas*rec_antennas, tx_duration/coherence_time), fading_pattern); } else { cmat mimo_channel = kron(reshape(eye_c(em_antennas), em_antennas*rec_antennas, 1), ones_c(1, tx_duration/coherence_time)); ch_attenuations = kron(mimo_channel, fading_pattern); } //flat-fading MIMO channel for (ns=0;ns<nb_subblocks;ns++) rec.set_submatrix(ns*channel_uses, 0, \ S(ns*channel_uses, (ns+1)*channel_uses-1, 0, em_antennas-1)*reshape(ch_attenuations.get_col(ns), em_antennas, rec_antennas)); rec += sqrt(2*sigma2(en))*randn_c(tx_duration,rec_antennas);//sigma2 is the variance on each dimension //turbo receiver demapper_apriori_data.zeros();//a priori information of emitted bits siso.set_impulse_response(ch_attenuations); for (n=0;n<nb_iter;n++) { //first decoder siso.demapper(demapper_extrinsic_data, rec, demapper_apriori_data); //deinterleave+threshold nsc_intrinsic_coded = SISO::threshold(demapper_extrinsic_data(inv_perm), threshold_value); //second decoder siso.nsc(nsc_extrinsic_coded, nsc_extrinsic_data, nsc_intrinsic_coded, nsc_apriori_data, false); //decision rec_bits = bpsk.demodulate_bits(-nsc_extrinsic_data);//suppose that a priori info is zero //count errors berc.clear(); berc.count(bits, rec_bits); ber(n,en) += berc.get_errorrate(); //interleave demapper_apriori_data = nsc_extrinsic_coded(perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); } if (true == to_file) { //save results to file it_file ff(filename); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff << Name("gen") << gen; ff << Name("coding_rate") << coding_rate; ff << Name("nb_iter") << nb_iter; ff << Name("block_len") << block_len; ff << Name("nb_errors_lim") << nb_errors_lim; ff << Name("nb_bits_lim") << nb_bits_lim; ff << Name("const_size") << const_size; ff.close(); } else { //show BER cout << "BER = " << ber << endl; } return 0; }