channel.cpp

单用户dscdma的仿真

#include <iostream>
using namespace std;
#include <complex>
#include "channel.h"
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include<math.h>
#include<fstream>
#define PI 3.1415926535
#define sqr(x) ((x)*(x))
#define x1 100
#define x2 30000
void channel::AWGN ( )
{
int i,j,k;
double ro;
double   seed=(double)time(NULL);
inoise= new double[x2];
SNR=pow(10,SNRdB/10);
SignalPower=0;
//cout<<"------------------------"<<numberofuserbit<<"--------------"<<Fspreadfactor<<"--------------"<<nsamp<<"\n";
//cout<<sqr(ChannelRealIn[0][0]);
for(i=0;i<Fspreadfactor;i++)
for(j=0;j<nsamp;j++) 
{SignalPower=SignalPower+sqr(ChannelRealIn[i][j])+sqr(ChannelImagIn[i][j]);
       
}


//cout<<"ChannelRealIn[0][0]="<<ChannelRealIn[0][10]<<"\n";
//cout<<"SignalPower="<<SignalPower<<"\n";
//cout<<numberofuserbit/Tspreadfactor<<"\n";
SignalPower=SignalPower/((1.0*nsamp)/Tspreadfactor);//符号功率
//SignalPower=1;
//cout<<"((numberofuserbit/2+numberofuserbit%2)/Tspreadfactor)="<<((numberofuserbit/2+numberofuserbit%2)/Tspreadfactor)<<"\n";
//cout<<"SignalPower="<<SignalPower<<"\n";
sigma=0.5*0.5*SignalPower/(SNR);
sigma=sqrt(sigma);
//cout<<"sigma="<<sigma<<"\n";
ro=1;


//for(i=0;i<100;i++)
//cout<<inoise[i]<<"\n";
/*for(i=0;i<Fspreadfactor;i++)
{    for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
		cout<<ChannelImagIn[i][j]<<" ";
        cout<<"\n";
}
*/

randn(inoise,0,ro,seed,2*nsamp*Fspreadfactor);
//for(k=0;k<numberofuserbit*Fspreadfactor;k++)
/*cout<<inoise[k]*sigma<<" \n";
cout<<"\n";
*/
if(rayornot!=0)
{for(i=0;i<Fspreadfactor;i++)
{ 
    for(j=0;j<nsamp;j++) 
	{ChannelRealOut[i][j]=sefadeRealOut[i][j]+inoise[i*Fspreadfactor+j]*sigma;
	   ChannelImagOut[i][j]=sefadeImagOut[i][j]+inoise[i*Fspreadfactor+j+nsamp]*sigma;
//ChannelRealOut[i][j]=ChannelRealIn[i][j];
//	   ChannelImagOut[i][j]=ChannelImagIn[i][j];
	}
}

}
else
{for(i=0;i<Fspreadfactor;i++)
{ 
    for(j=0;j<nsamp;j++) 
	{ChannelRealOut[i][j]=ChannelRealIn[i][j]+inoise[i*Fspreadfactor+j]*sigma;
	   ChannelImagOut[i][j]=ChannelImagIn[i][j]+inoise[i*Fspreadfactor+j+nsamp]*sigma;
//ChannelRealOut[i][j]=ChannelRealIn[i][j];
//	   ChannelImagOut[i][j]=ChannelImagIn[i][j];
	}
}


}

delete [] inoise;
DeAllocate2DArray(sefadeRealOut,x1);                //删除内存
DeAllocate2DArray(sefadeImagOut,x1);                //删除内存
    delete ramp;  
    delete rcos;
    delete rsin;
/*cout<<"I支路加噪"<<"\n";
for(i=0;i<Fspreadfactor;i++)
  
{ for(j=0;j<nsamp;j++) 
    cout<<ChannelRealOut[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路加噪"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<nsamp;j++) 
    cout<< ChannelImagOut[i][j]<<" ";
    cout<<"\n";
} */

}

/////////////////////////////////////////////////////////
//                                                  /////
//                  产生正态分布的随机数         ///////
//       产生任意均值与方差的n个正态分布随机数     /////
//        函数的参数：mu和ro(μ和σ值)要事先给定。//////
//////////////////////////////////////////////////////////
void channel::randn(double *out,double mu,double ro,double seed,int number)
{
 int i;
 int M;
 M=65536;
 for ( i=0; i<number; i++)
 {
  double rand=0.0;
  for (int j=1; j<=12; j++)    //产生多个[0,1]区间内均匀分布伪随机数
  {
   seed=(seed)*2053+13849;
   seed=(unsigned long)seed%M;   //以65536为模对种子取余
   rand=rand+(seed)/(double)M;
  }
  out[i]=mu+ro*(rand-6.0);
 }

}
/////////////////////////////////////////////////////////
//                                                  /////
//                                                 ///////
//        frequency selecting fade信道            /////
//                                                 //////
//////////////////////////////////////////////////////////
void channel::frequencyselectingfade ( )
{  int i,j,k;
	double *iout,*qout,*itmp,*qtmp,*idata,*qdata,*itmp3,*qtmp3;
	double atts[10],theta[10]; 
    double total_attn=0;
   
   idata=new double[nsamp];
   qdata=new double[nsamp];
   iout=new double[nsamp];
   qout=new double[nsamp];
   for(i=0;i<nsamp;i++)
   {iout[i]=0;
    qout[i]=0;
   }
  for(i=0;i<Fspreadfactor;i++)
   for(j=0;j<nsamp;j++) 
   {  idata[i*(nsamp)+j]=ChannelRealIn[i][j];
	  qdata[i*(nsamp)+j]=ChannelImagIn[i][j];
   }
   for(i=0;i<numberofpath;i++)
   total_attn+=pow(10,(-1.0 * dlvl[i]/ 10.0));
   //cout<<"total_attn="<<total_attn<<"\n";
  for(k=0;k<numberofpath;k++)
  {  atts[k]=pow(10,(-0.05*dlvl[k]));
	  if (dlvl[k]>=40.0) atts[k]=0.0;
	  theta[k]=th[k]*PI/180.0;
      itmp=new double[nsamp];
      qtmp=new double[nsamp];
	  delay ( idata,qdata,itmp,  qtmp,itau[k]);               //delay 函数
//cout<<"\n";	  
/*cout<<"支路延迟"<<"\n";
for(i=0;i<nsamp;i++)
	   {
	     cout<<itmp[i]<<" ";
       
      
	   }*/
     delete idata;
    delete  qdata;
     itmp3=new double[nsamp];
     qtmp3=new double[nsamp];
      Rayleighfade(itmp,qtmp,itmp3,qtmp3,itn[k],n0[k]);  //Rayleighfade函数
	/*  cout<<"\n";	
cout<<"支路瑞丽"<<"\n";
for(i=0;i<nsamp;i++)
	   {
	     cout<<itmp3[i]<<" ";
       
      
	   }*/

     delete itmp;
     delete qtmp;
	 for(i=0;i<nsamp;i++)
	 {iout[i]=iout[i]+atts[k]*itmp3[i]/sqrt(total_attn); 
      qout[i]=qout[i]+atts[k]*qtmp3[i]/sqrt(total_attn); 
	 }
  /*cout<<"\n";	
   cout<<"支路瑞丽2"<<"\n";
   for(i=0;i<nsamp;i++)
	   {
	     cout<<iout[i]<<" ";
       
      
	   }
*/
     delete itmp3;
     delete qtmp3;
  }
sefadeRealOut=Allocate2DArray(x1,10000);           //动态2维数组分配内存
sefadeImagOut=Allocate2DArray(x1,10000);           //动态2维数组分配内存
  for(i=0;i<Fspreadfactor;i++)
   for(j=0;j<nsamp;j++) 
   {  sefadeRealOut[i][j]=iout[i*(numberofuserbit/2+numberofuserbit%2)+j];
	  sefadeImagOut[i][j]=qout[i*(numberofuserbit/2+numberofuserbit%2)+j];
   }
delete iout;
delete qout;
//cout<<"\n";
/*cout<<"I支路多径"<<"\n";
for(i=0;i<Fspreadfactor;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<sefadeRealOut[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路多径"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<< sefadeImagOut[i][j]<<" ";
    cout<<"\n";
} */

}
/////////////////////////////////////////////////////////
//                                                  /////
//                                                 ///////
//                 Rayleighfade信道                /////
//                                                 //////
//////////////////////////////////////////////////////////
void channel::Rayleighfade (double *itmp,double *qtmp,double *itmp3, double *qtmp3,double counter,int no)
{

double as0,ac0,ic0,wm,n,ts,wmts,paino;
double *xc,*xs,*ic,*cwn,*cwmt;
int i,j,k,nn;
                   
if (fd!=0.0)  
{   
 
	ac0 = sqrt(1.0 / (2.0*(no + 1)));   //power normalized constant(ich)
    as0 = sqrt(1.0 / (2.0*no));         //power normalized constant(qch)
    ic0 = counter;                        //fading counter 
    wm = 2.0*PI*fd;
	//cout<<"\n"<<wm;
    n = 4*no + 2;
	//cout<<"\n"<<n;
    ts = tstp;
    wmts = wm*ts;
	//cout<<"\n"<<wmts;
    paino = PI/no;
//cout<<"\n"<<paino;
	ic=new double[nsamp];
    xc=new double[nsamp];
    xs=new double[nsamp];
    cwn=new double[nsamp];
	cwmt=new double[nsamp];
	for(i=0;i<nsamp;i++)
	{ xc[i]=0;
      xs[i]=0;
    }
    for(i=0;i<nsamp;i++)
        ic[i]=i+ic0;
    for (nn = 1;nn<no+1; nn++)
	  for(i=0;i<nsamp;i++)
	  {cwn[i] = cos( cos(2.0*PI*nn/n)*ic[i]*wmts );
	    xc[i] = xc[i] + cos(paino*nn)*cwn[i];
		//cout<<"\n"<<"cwn[i]="<<cwn[i]<<" ";
	    xs[i] = xs[i] + sin(paino*nn)*cwn[i];
      }
	 for(i=0;i<nsamp;i++)
	  {//cout<<"\n"<<"cos(paino*nn)*cwn[i]="<<cos(paino*nn)*cwn[i]<<" ";
		 //cout<<"\n"<<"cwn[i]1="<<cwn[i]<<" ";
	//	cout<<"\n"<<"xc[i]1="<<xc[i]<<" ";
		 //cout<<"\n"<<"xs[i]="<<xs[i]<<" ";
	    
      }
	for(i=0;i<nsamp;i++)
	  {
        cwmt[i] = sqrt(2.0)*cos(ic[i]*wmts);
        xc[i] = (2.0*xc[i] + cwmt[i])*ac0;
        xs[i] = 2.0*xs[i]*as0;
      }
    for(i=0;i<nsamp;i++)
	  {//cout<<"\n"<<"cwn[i]1="<<cwn[i]<<" ";
		 //cout<<"\n"<<"xc[i]="<<xc[i]<<" ";
		 //cout<<"\n"<<"xs[i]="<<xs[i]<<" ";
	    
      }


        ramp=new double[nsamp];  
        rcos=new double[nsamp];
        rsin=new double[nsamp];
      for(i=0;i<nsamp;i++)
      {  ramp[i]=sqrt(sqr(xc[i])+sqr(xs[i]));
         rcos[i]=xc[i]/ramp[i];
         rsin[i]=xs[i]/ramp[i];
      }
     /*for(i=0;i<nsamp;i++)
      { cout<<"\n"<<"ramp[i]="<<ramp[i]<<" ";
        
      }*/

     if(flat==1)
	 { for(i=0;i<nsamp;i++)
		{
		 itmp3[i]=sqrt(sqr(xc[i])+sqr(xs[i]))*itmp[i]; 
		 qtmp3[i]=sqrt(sqr(xc[i])+sqr(xs[i]))*qtmp[i];
        }
	 }
     else
	 {
       for(i=0;i<nsamp;i++)
	   {
	     itmp3[i]=xc[i]*itmp[i]-xs[i]*qtmp[i];
         qtmp3[i]=xs[i]*itmp[i]+xc[i]*qtmp[i];
      
	   }
	 }
	
	 delete ic;
    delete xc;
    delete xs;
    delete cwn;
	delete cwmt;

  
}
 else
 {for(i=0;i<nsamp;i++)
  { itmp3[i]=itmp[i];
    qtmp3[i]=qtmp[i];
  }
 }

}
/////////////////////////////////////////////////////////
//                                                  /////
//                                                 ///////
//                 产生delay                          /////
//                                                 //////
//////////////////////////////////////////////////////////
void channel::delay (double *idata,double *qdata,double *itmp,double *qtmp,int idel)  
{
	int i;
  if(idel!=0)
   for(i=0;i<idel;i++)
	{itmp[i]=0;
     qtmp[i]=0; 
    }
  
   for(i=0;i<nsamp-idel;i++)
   { itmp[i+idel]=idata[i];
     qtmp[i+idel]=qdata[i];
   }
}

// --------------------------------------------------------------------------
// 动态分配二维数组
// 使用方法(以int类型8行10列为例)： int **dyarr = Allocate2DArray<int>(8,10)
//template<double>
 double ** channel::  Allocate2DArray(size_t pm_Rows, size_t pm_Cols)
{
    double **arr = new double*[pm_Rows];
    for (int i = 0; i < pm_Rows; i++)
        arr[i] = new double[pm_Cols];
    return arr;
}

// --------------------------------------------------------------------------
// 释放动态分配的二维数组
// 使用方法(以int类型8行10列为例)： Allocate2DArray<int>(dyarr,8)
//template<double>
void channel::DeAllocate2DArray(double **arr, size_t pm_Rows)
{
    for (int i = 0; i < pm_Rows; i++)
        delete[] arr[i];
    delete[] arr;
}

int ** channel::intAllocate2DArray(size_t pm_Rows, size_t pm_Cols)
{
    int **arr = new int*[pm_Rows];
    for (int i = 0; i < pm_Rows; i++)
        arr[i] = new int[pm_Cols];
    return arr;
}

// --------------------------------------------------------------------------
// 释放动态分配的二维数组
// 使用方法(以int类型8行10列为例)： Allocate2DArray<int>(dyarr,8)
//template<double>
void channel::intDeAllocate2DArray(int **arr, size_t pm_Rows)
{
    for (int i = 0; i < pm_Rows; i++)
        delete[] arr[i];
    delete[] arr;
}