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;
}
