performanceanalyzer.cpp

QPSK调制Modem的C实现及文档说明

/*****************************************************************************
 * Class -- BERcalculator                                                    *
 * Functions -- CalculateBER                                                 *
 * Outputs -- Bit error rate                                                 *
 *                                                                           *
 * Note: every time it processes it takes 9 samples(=1 symbol)               *
 *****************************************************************************/

ofstream WriteSNR(SNR,ios::out);    /* for output of SNR to a file for graph */
ofstream WriteBER(BER,ios::out);

class PerformanceAnalyzer
{ private:
   double SNRdB;
  public:
   PerformanceAnalyzer() { SNRdB=0; }
   void CalculateBER(char data[],char sink[],char ResultOut[]);
   void CalculateBER(char data[],char sink[]);
   void CalculateSNR(char data1[],char data2[]);
};

void PerformanceAnalyzer::CalculateBER(char data[],char sink[],char ResultOut[])
{  int temp1=0,temp2=0;
   int CountTotalBits=0;
   int CountErrorBits=0;
   ifstream ReadData(data,ios::in);
   ifstream ReadSink(sink,ios::in);
   ofstream Write1(ResultOut,ios::out);
   while (!ReadSink.eof())
    { if (fabs(temp1-temp2)==1) ++CountErrorBits;
      ReadSink>>temp1;
      ReadData>>temp2;
      ++CountTotalBits;
    }         /* -1 accounts for the comparision of end of file */
   Write1<<"This file contains BER for noiseless channel."<<endl;
   Write1<<"The expected BER is zero for the correctness of the program."<<endl;
   Write1<<endl;
   Write1<<"============================"<<endl;
   Write1<<"Total bits compared: " <<(CountTotalBits-1)<<endl;
   Write1<<"   Total error bits: " <<CountErrorBits<<endl;
   Write1<<"     Bit Error Rate: ";
   Write1<<((float)CountErrorBits)/CountTotalBits<<endl;
   Write1<<"============================"<<endl;
}

void PerformanceAnalyzer::CalculateBER(char data[],char sink[])
{  int temp1=0,temp2=0;
   int CountTotalBits=0;
   int CountErrorBits=0;
   ifstream ReadData(data,ios::in);
   ifstream ReadSink(sink,ios::in);
   while (!ReadSink.eof())
    { if (fabs(temp1-temp2)==1) ++CountErrorBits;
      ReadSink>>temp1;
      ReadData>>temp2;
      ++CountTotalBits;
    }
   cout<<"Calculating BER..."<<endl<<endl;
   cout<<"================================="<<endl;
   cout<<"Total bits compared: " <<(CountTotalBits-1)<<endl;
   cout<<"   Total error bits: " <<CountErrorBits<<endl;
   cout<<"     Bit Error Rate: ";
   cout<<((float)CountErrorBits)/CountTotalBits<<endl;
   cout<<"            SNR(dB): " <<SNRdB<<endl;
   cout<<"================================="<<endl;
   WriteBER<<((float)CountErrorBits)/CountTotalBits<<endl;
   WriteSNR<<SNRdB<<endl;
}

void PerformanceAnalyzer::CalculateSNR(char data1[],char data2[])
{ double SignalPower=0;
  double NoisePower=0;
  double NoiseTemp; /* temparory storage */
  double Ik,Qk; /* temparory storage */
  double NoiseIk,NoiseQk;
  modulator DeMR;
  RRcFilter RRCF1;       /* filter for cos(or I) rail */
  RRcFilter RRCF2;       /* filter for sin(or Q) rail */
  ifstream ReadDataStrobes0(data1,ios::in);
  ifstream ReadNoiseSamples(data2,ios::in);
  /* accounts for filter delay */
  for (int i=0; i<64; ++i)
   { ReadNoiseSamples>>NoiseTemp;
     NoiseIk=RRCF1.conv(DeMR.CosModulation(NoiseTemp));
     NoiseQk=RRCF2.conv(DeMR.SinModulation(NoiseTemp));
   }
  cout<<"Calculating SNR..."<<endl;
  while (!ReadDataStrobes0.eof())
   { ReadDataStrobes0>>Ik;
     ReadDataStrobes0>>Qk;
     SignalPower=SignalPower+(Ik*Ik+Qk*Qk);
     /******************************************************************/
     /* reads a noise sample from channel output, passes through the   */
     /* demodulators and the filters to obtain decision noise samples, */
     /* thus calculating the noise power at the decision point.        */
     /******************************************************************/
     ReadNoiseSamples>>NoiseTemp;
     NoiseIk=RRCF1.conv(DeMR.CosModulation(NoiseTemp));
     NoiseQk=RRCF2.conv(DeMR.SinModulation(NoiseTemp));
     NoisePower=NoisePower+(NoiseIk*NoiseIk+NoiseQk*NoiseQk);
   }
  SNRdB=10*log10(SignalPower/NoisePower);
}