st.cpp

Turbo码性能仿真源程序信道编码方面的

#include <math.h>
#include "Global.h"
#include "ST.h"


void ST::Init( int nt, int stacknum, int framelen, int spreadlen, int datalen, int chipnum, int tranchipnum )
{
	int i;

	Nt			= nt;
	DataLen		= datalen;
	StackNum	= stacknum;
	SpreadLen	= spreadlen;
	FrameLen	= framelen;
	ChipNum		= chipnum;
	TranChipNum = tranchipnum;
	
	ST::MemoryAllocation( );
	ST::InterleaverSet( );
	for( i=0; i<SpreadLen; i++ )
		SpreadSeq2[i] =  2 * ( SpreadSeq[i] = (float) ( 1 - ( ( (i%2)^((i/2)%2) ) << 1 ) ) );
}

void ST::MemoryAllocation( )
{
	int i, j;

	ReShaffleRule = new Dual *[StackNum];
	ImShaffleRule = new Dual *[StackNum];
	for( i=0; i<StackNum; i++ )
	{
		ReShaffleRule[i] = new Dual [FrameLen];
		ImShaffleRule[i] = new Dual [FrameLen];
	}

	ShaffleRule	= new int *[Nt];
	ExChipInfo	= new float *[Nt];
	for( i=0; i<Nt; i++ )
	{
		ShaffleRule[i] = new int [TranChipNum];
		ExChipInfo[i] = new float [TranChipNum];
	}

	Mean = new Complex [FrameLen];
	Var	 = new Complex [FrameLen];
	RowMean = new Complex **[Nt];
	RowVar	= new Complex **[Nt];
	for( i=0; i<Nt; i++ )
	{
		RowMean[i] = new Complex *[StackNum];
		RowVar[i]  = new Complex *[StackNum];
	}
	for( i=0; i<Nt; i++ ) for( j=0; j<StackNum; j++ )
	{
		RowMean[i][j] = new Complex [FrameLen];
		RowVar[i][j]  = new Complex [FrameLen];
	}
}

void ST::End( )
{
	int i, j;

	for( i=0; i<StackNum; i++ )
	{
		delete [] ReShaffleRule[i];
		delete [] ImShaffleRule[i];
	}
	delete [] ReShaffleRule;
	delete [] ImShaffleRule; 

	for( i=0; i<Nt; i++ )
	{
		delete [] ShaffleRule[i];
		delete [] ExChipInfo[i];
	}
	delete [] ShaffleRule;
	delete [] ExChipInfo;

	delete [] Mean;
	delete [] Var;

	for( i=0; i<Nt; i++ ) for( j=0; j<StackNum; j++ )
	{
		delete [] RowMean[i][j];
		delete [] RowVar[i][j];
	}
	for( i=0; i<Nt; i++ )
	{
		delete [] RowMean[i];
		delete [] RowVar[i];
	}
	delete [] RowMean;
	delete [] RowVar;
}

void ST::InterleaverSet( )
{
	int i, j, m, nt;

	for( nt=0; nt<Nt; nt++ )
	{
		ST::InterleaverInit( );
		ST::RowScramable( &ReShaffleRule[0][0] );
		ST::RowScramable( &ImShaffleRule[0][0] );
		while( Check( &ReShaffleRule[0][0], &ImShaffleRule[0][0] ) == 0 )
			ST::RowScramable( &ImShaffleRule[0][0] );

		for( i=1; i<StackNum; i++ )
		{
			ST::RowScramable( &ReShaffleRule[i][0] );
			while( Check( &ReShaffleRule[i][0], &ReShaffleRule[i-1][0] ) == 0 )
				ST::RowScramable( &ReShaffleRule[i][0] );

			ST::RowScramable( &ImShaffleRule[i][0] );
			while( (Check(&ImShaffleRule[i][0],&ImShaffleRule[i-1][0])==0) || (Check(&ReShaffleRule[i][0],&ImShaffleRule[i][0])==0) )
				ST::RowScramable( &ImShaffleRule[i][0] );
		}
		for( m=i=0; i<StackNum; i++ ) for( j=0; j<FrameLen; j++ )
		{
			ShaffleRule[nt][m++] = ReShaffleRule[i][j].Pos;
			ShaffleRule[nt][m++] = ImShaffleRule[i][j].Pos;
		}
	}
}

int ST::Check( Dual *Re, Dual *Im )
{
	int i;

	for( i=0; i<FrameLen; i++ )
		if( Re[i].Flag == Im[i].Flag ) return 0;
	return 1;
}

void ST::RowScramable( Dual *Row )
{
	int i;
	int rule[FRAMELEN+1];
	Dual temp[FRAMELEN+1];

	for( i=0; i<FrameLen; i++ )
		rule[i] = i;

	Scramble( &rule[0], FrameLen, _ScrambleNum );

	for( i=0; i<FrameLen; i++ )
		temp[i] = Row[i];

	for( i=0; i<FrameLen; i++ )
		Row[i] = temp[rule[i]];
}


void ST::InterleaverInit( )
{
	int i, j, m;

	for( m=i=0; i<StackNum; i++ ) for( j=0; j<FrameLen; j++ )
	{
		ReShaffleRule[i][j].Flag = ImShaffleRule[i][j].Flag = m / SpreadLen;
		ReShaffleRule[i][j].Pos = m++;
		ImShaffleRule[i][j].Pos = m++;
	}
}

void ST::Encoder( int *input, Complex *output )
{
	int i, j;
	float SpreadTemp[CHIPNUM+2*STACKNUM];
	Complex StackTemp[FRAMELEN+1];

	ST::Spreader( &input[0], &SpreadTemp[0] );
	for( i=0; i<Nt; i++ )
	{
		for( j=0; j<FrameLen; j++ )
			StackTemp[j].Re = StackTemp[j].Im = 0;

		ST::Stacker( i, &SpreadTemp[0], &StackTemp[0] ); // stack in Nt antenna.

		for( j=0; j<FrameLen; j++ )
			output[j] += StackTemp[j] * FadeFactor[i];  // complex product.
	}
}

void ST::Spreader( int *intput, float *temp )
{
	int i, j, m;
	float d;

	for( m=i=0; i<DataLen; i++ )
	{
		d = (float) ( 1 - (intput[i]<<1) );
		for( j=0; j<SpreadLen; j++ )
			temp[m++] = d * SpreadSeq[j];
	}
	while( m < TranChipNum ) temp[m++] = 1;
}

void ST::Stacker( int nt, float *temp, Complex *output )  // Here output is not equal to output in "Encoder 
{
	int i, j, m;

	for( m=i=0; i<StackNum; i++ ) for( j=0; j<FrameLen; j++ )
	{
		output[j].Re += temp[ShaffleRule[nt][m++]];
		output[j].Im += temp[ShaffleRule[nt][m++]];
	}
}

void ST::PreProcess( float sigma )
{
	int i, j, nt;
	float h2, var;

	var = 0;
	for( nt=0; nt<Nt; nt++ )
	{
		FadeFactor2[nt].Re = FadeFactor[nt].Re * FadeFactor[nt].Re;
		FadeFactor2[nt].Im = FadeFactor[nt].Im * FadeFactor[nt].Im;
		h2 = FadeFactor2[nt].Re + FadeFactor2[nt].Im;
		var += h2;

		for( i=0; i<StackNum; i++ ) for( j=0; j<FrameLen; j++ )
		{
			RowMean[nt][i][j].Re = RowMean[nt][i][j].Im = 0;
			RowVar[nt][i][j].Re = RowVar[nt][i][j].Im = h2;
		}
	}

	var = var * StackNum + sigma *sigma;
	for( i=0; i<FrameLen; i++ )
	{
		Mean[i].Re = Mean[i].Im = 0;
		Var[i].Re = Var[i].Im = var;
	}
}

void ST::Input( Complex *Sb )
{
	int i, j, m, nt;
	double tmp;
	Complex Y;
	
	for( nt=0; nt<Nt; nt++ )
		for( m=i=0; i<StackNum; i++ )
			for( j=0; j<FrameLen; j++ )
			{
				Y = APrioriProb( FadeFactor[nt], Sb[j]-(Mean[j]-RowMean[nt][i][j]), Var[j]-RowVar[nt][i][j] );
				ExChipInfo[nt][ShaffleRule[nt][m++]] = ( Y.Re );
				ExChipInfo[nt][ShaffleRule[nt][m++]] = ( Y.Im );
			}

	for( m=i=0; i<DataLen; i++ )
	{
		tmp = 1;
		for( j=0; j<SpreadLen; j++, m++ )
			for( nt=0; nt<Nt; nt++ )
			{
				ExChipInfo[nt][m] = ( (float) exp( LClip1(SpreadSeq2[j]*ExChipInfo[nt][m]) ) );
				// (20) 2*h_k , the factor 2 is in SpreadSeq2[j].
				tmp *= ExChipInfo[nt][m];
			}
		DeSpreadChipInfo[i] = RClip2( tmp ); // tmp includes all product of  antenna and spread 
	}
}
void ST::Output( float s2 )
{
	int i, j, m, nt;
	Complex Y;

	for( m=i=0; i<DataLen; i++ ) for( j=0; j<SpreadLen; j++, m++ ) for( nt=0; nt<Nt; nt++ )
		ExChipInfo[nt][m] = SpreadSeq[j] * ST::ProbToMean( (DeSpreadChipInfo[i]/ExChipInfo[nt][m]) );// total - self =other

	for( nt=0; nt<Nt; nt++ ) for( i=ChipNum; i<TranChipNum; i++ )
		ExChipInfo[nt][i] = 1;

	for( nt=0; nt<Nt; nt++ )
		for( m=i=0; i<StackNum; i++ )
			for( j=0; j<FrameLen; j++ )
			{
				Y.Re = ExChipInfo[nt][ShaffleRule[nt][m++]];  //Y=mean=E(x)
				Y.Im = ExChipInfo[nt][ShaffleRule[nt][m++]];
				ST::Ext( nt, i, j, Y );
			}

	for( i=0; i<FrameLen; i++ )
	{
		Mean[i].Re = Mean[i].Im = 0;
		Var[i].Re = Var[i].Im = s2;
	}

	for( nt=0; nt<Nt; nt++ )for( i=0; i<StackNum; i++ )
		ST::StatisticOut( nt, i ); // All antenna's values adds together.
}

void ST::Ext( int nt, int row, int col, Complex Y )
{

	RowMean[nt][row][col].Re = FadeFactor[nt].Re * Y.Re - FadeFactor[nt].Im * Y.Im;
	RowMean[nt][row][col].Im = FadeFactor[nt].Im * Y.Re + FadeFactor[nt].Re * Y.Im; //RowMean=h*E(x)
	Y.Re = RClipT( 1 - Y.Re * Y.Re ); // // here Y=Variance=Var(x)
	Y.Im = RClipT( 1 - Y.Im * Y.Im );//
	RowVar[nt][row][col].Re = FadeFactor2[nt].Re * Y.Re + FadeFactor2[nt].Im * Y.Im;
	RowVar[nt][row][col].Im = FadeFactor2[nt].Im * Y.Re + FadeFactor2[nt].Re * Y.Im;

//	RowVar[nt][row][col].Re = (FadeFactor2[nt].Re +FadeFactor2[nt].Im )* Y.Re ;
//	RowVar[nt][row][col].Im = (FadeFactor2[nt].Re +FadeFactor2[nt].Im ) * Y.Im;
}

//Y = APrioriProb( FadeFactor[nt], Sb[j]-(Mean[j]-RowMean[nt][i][j]), Var[j]-RowVar[nt][i][j] );
// Y=h*(r/var)
Complex ST::APrioriProb( Complex h, Complex r, Complex var )
{
	Complex tmp;
	float rR = r.Re / RClipT( var.Re );
	float rI = r.Im / RClipT( var.Im );

	tmp.Re = ( h.Re * rR + h.Im * rI );
	tmp.Im = ( h.Re * rI - h.Im * rR );
	return tmp;
}

void ST::StatisticOut( int nt, int row )
{
	int i;

	for( i=0; i<FrameLen; i++ )
	{
		Mean[i] += RowMean[nt][row][i];
		Var[i] += RowVar[nt][row][i];
	}
}

float ST::ProbToMean( float Pr )
{
	return ( Pr - 1 ) / ( Pr + 1 );
}