www.pudn.com > MIMOTest.rar > TestFunction.cpp

 
#include "stdafx.h" 
#include "TestFunction.h" 
 
 
void Test_STBC(void) 
{ 
 
  MIMO  mimo; 
  QAM qpsk(16); 
  CSTBC STCoding;     //Space-Time Coding 
  MIMOChannel channel; 
  const vec EbN0dB = "-5:1:20";        // SNR range 
  int Number_of_bits; 
  double Ec, Eb; 
  vec  EbN0, N0, noise_variance, bit_error_rate; //vec is a vector containing double 
 
 
  Ec = 1.0;                      //The transmitted energy per QPSK symbol is 1. 
  Eb = Ec / 2.0;                 //The transmitted energy per bit is 0.5. 
  //EbN0dB = linspace(0.0,9.0,10); //Simulate for 10 Eb/N0 values from 0 to 9 dB. 
  EbN0 = inv_dB(EbN0dB);         //Calculate Eb/N0 in a linear scale instead of dB. 
  N0 = Eb * pow(EbN0,-1.0);      //N0 is the variance of the (complex valued) noise. 
  Number_of_bits = 1000000;       //One hundred thousand bits is transmitted for each Eb/N0 value 
 
  Array beruc(length(EbN0dB));  // counter for uncoded BER 
  bit_error_rate.set_size(EbN0dB.length(),false); 
 
  for (int nsnr=0; nsnr sequence_interleaver_b(Nctx); 
  Sequence_Interleaver 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 Y(Nvec);        // received data 
  Array 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 berc(Nmethods);  // counter for coded BER 
    Array bercu(Nmethods); // counter for uncoded BER 
    Array ferc(Nmethods); // counter for coded FER 
 
    for (int i=0; i LLRin(Nmethods); 
      for (int i=0; i0 && 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; iBERmin)    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; 
}