/* | Project:     WCDMA simulation environment | Module:     | Author:      Maarit Melvasalo | Date:        February 1999 | | History: |              March 18,  1999 Maarit Melvasalo  |                      Channel memory vector changed to mode were  |                      several different vectors can be memorized   |       |              May 3, 1999 Maarit Melvasalo                  |                      Channel model changed |              June 16, 1999 Maarit Melvasalo   |                      Documentation added and cleaning up the code | | Copyright disclaimer: |   This software was developed at the National Institute of Standards |   and Technology by employees of the Federal Government in the course |   of their official duties. Pursuant to title 17 Section 105 of the |   United States Code this software is not subject to copyright |   protection and is in the public domain. | |   We would appreciate acknowledgement if the software is used. |/* * Static data structures. */#include <stdlib.h> #include <math.h>#include <stdio.h>#include "config_wcdma.h"#include "channel.h"#ifndef TRUE#define TRUE 1#define FALSE 0#endif /* TRUE *//* Channel matrix to keep in memory the channel impulses   (both amplitudes and delays and their changes)    and previous chips etc /**/static channel_matrix_double  channel_data_double[MAX_CHANNELS];/* List that keeps record which channel instances are used /**/static enum instance_state channel_alloc_list_double[MAX_CHANNELS] ;/* General initialization flag /**/static int general_channel_init_flag_double = FALSE;/* Total number of occupied channels/**/static int channel_index_double = 0;/* -------------------------------------------------------------------- *//* * Function:    wcdma_channel_init * Desc.:       Channel initialization *              Allocates memory for the chips that effect the future call time inputs   *  * Return:      instance number or -1 if all instances are already occupied. * * Note:       *//* -------------------------------------------------------------------- */int wcdma_channel_init_double(		      double channel_impulse[],	/* IN: Channel impulse vector*/		      int  channel_delays[],/* IN: Delay taps */		      int  nTaps,           /* IN: channel impulse vector size */		      int  nImpulse,        /* IN: number of channel impulse vectors */		      double impulse_prob[],/* IN: Channel impulse vector probabilities*/		      int  steps,           /* IN: Total number of frames send during ssim/**/		      double esno,          /* IN: SNR/**/		      double power,         /* IN: Power/**/		      int  nCode            /* IN: Length of the spreading code/**/){  int i,j,instance,n_intervals,delay_diff;    /*     * If first call, initialize static data.     */    if (general_channel_init_flag_double == FALSE) {        for (i=0; i < MAX_CHANNELS; i++) {            channel_alloc_list_double[i] = FREE_INSTANCE;        } /* for */        general_channel_init_flag_double = TRUE;    } /* if general_init_flag */    /*     * Find first free instance number.     */    instance = -1;    for (i=0; i < MAX_CHANNELS; i++) {        if (channel_alloc_list_double[i] == FREE_INSTANCE) {            instance = i;            break;        } }    if (instance == -1) return(-1); /* no free instances */    if (nCode < 0) return(-1); /* Spreading code length incorrect/**/      /*        Store the channel data	Note if the channel is changed there might be some old data	left in the memory, but this do not effect the calculations.	/**/    channel_data_double[instance].n_taps = nTaps;    channel_data_double[instance].n_impulses = nImpulse;    channel_data_double[instance].cur_impulse = 0;    /*        Standard noise deviation is calculated for each chip.       See  Michel C. Jeruchim:               "Simulation of communication Systems", Plenum 1992	      page. 283       Power  =  noise power       nCode = code length         esno = Signal to noise ratio       The random number is scaled between -1 and 1 and multiplied by noise_std       calculated here.      /**/    channel_data_double[instance].noise_std =        sqrt(power / nCode / 2 / pow(10.0,(esno/10.0)) ) ; /**/                /* Select the channel mode       CONSTANT       RANDOM       INTERPOL       /**/       if( nImpulse == 1)      { channel_data_double[instance].mode = CONST;} /* CONSTANT channel model /**/          else if (steps == 0)          /* RANDOM channel model /**/      { channel_data_double[instance].mode = RANDOM;      /* 	 Calculate cumulative impulse vector probalitites 	 /**/      channel_data_double[instance].cumul_prob[0] = impulse_prob[0];      for (i = 1; i < nImpulse; i++){	channel_data_double[instance].cumul_prob[i] = 	  impulse_prob[i] +  channel_data_double[instance].cumul_prob[i-1];      }}        else {        /* INTERPOLATING channel model /**/      channel_data_double[instance].mode = INTERPOL;       /* 	 Define the number of iteration steps in between two channel impulses	 /**/      n_intervals = ceil (steps / (nImpulse - 1)) + min(1, steps % (nImpulse - 1));/**/      for(j = 0; j<nImpulse; j++){	channel_data_double[instance].max[j] = n_intervals;	channel_data_double[instance].use[j] = 0;}    }    /*      Update the channel data matrix for all channel taps      /**/    for(i = 0; i < nTaps; i++){      channel_data_double[instance].cur_channel[i] = channel_impulse[i];      channel_data_double[instance].cur_delays[i] = channel_delays[i];      if( channel_data_double[instance].mode == RANDOM){	/* RANDOM channel model  	   Save all the impulses and delays	   /**/	for(j = 0; j < nImpulse-1; j++){	  channel_data_double[instance].amplitudes[j][i] = channel_impulse[j * nTaps + i]; 	  channel_data_double[instance].delays[j][i] = channel_delays[j * nTaps + i];	}}      else if( channel_data_double[instance].mode == INTERPOL){ 	/* INTERPOLATING channel model 	   Calculate the derivates of the amplitudes and the  	   number of timesteps between delay tap changes (and the direction of the change)	   /**/	for(j = 0; j< nImpulse-1; j++){	  channel_data_double[instance].amplitudes[j][i] = 	      (channel_impulse[(j+1) * nTaps + i] - channel_impulse[j * nTaps + i])/n_intervals;	  delay_diff = channel_delays[(j+1) * nTaps + i] - channel_delays[j * nTaps + i] ;	  if( delay_diff != 0) {	    channel_data_double[instance].delays[j][i] =  	      ( n_intervals / (abs(delay_diff)+1) + min(1, n_intervals % (abs(delay_diff)+1))) ;            if( delay_diff < 0 )  {	      channel_data_double[instance].delays[j][i] = -  channel_data_double[instance].delays[j][i] ;}	  }	  else {channel_data_double[instance].delays[j][i] = 0;}	}}    } /*Update for each channel tap/**/        /*        Find the longest delay in the channel (to allocate enough memory for stored chips)       /**/    channel_data_double[instance].max_memory = channel_delays[nTaps-1];    for (j = 2; j <= nImpulse; j++){      if ( channel_delays[j * nTaps - 1]  > channel_data_double[instance].max_memory )	    channel_data_double[instance].max_memory = channel_delays[j * nTaps-1];     }    /*      Allocate memory for the memory storage of previous time chips      /**/    channel_data_double[instance].I_prev_chips  =       (double*)calloc( channel_data_double[instance].max_memory, sizeof(double));    channel_data_double[instance].Q_prev_chips  =       (double*)calloc( channel_data_double[instance].max_memory, sizeof(double));    /*        Update the static tables to keep in mind which channel instances are in use       /**/        channel_alloc_list_double[instance] = INSTANCE_IN_USE;    channel_index_double ++;    /*      If you want to check what has been updated call:      channel_print(instance);/**/    return(instance);}/* -------------------------------------------------------------------- *//* * Function:    wcdma_channel * Desc.:       Channel response *              The function which performs the givne channel *              for the input signal and upstaes the channel *              and stores the last chips for next call.   * * Note: *         channel_impulse and tap_delay vectors need to same length and *         their elements are corresponding, i.e. the tap_delay[i]  *         indicates how many chipintervals the channel_impulse  *         is delayd. The channel_impulse[i] indicates the attennuation *         coefficient.  * *        THE LAST ELEMENT OF tap_delay[i] VECTOR IMPLIES WHAT IS THE TOTAL *        DELAY FOR THE CHANNEL.  *//* -------------------------------------------------------------------- */int wcdma_channel_double( 	     double  Inputs[],	        /* IN: input chip vector */	     double  Qnputs[],	        /* IN: input chip vector */	     int  nInputs,	        /* IN: input vector size */	     int  instance,	        /* IN:  */	     double channel[],          /* OUT: Channel impulse vector*/	     int  delay[],              /* OUT: Delays of channel taps*/	     double Iout[],             /* OUT: output bit vector */ 	     double Qout[]              /* OUT: output bit vector */){    int i,  memory_length, nTaps ;    double std_noise;    double *prev_I,*prev_Q;    channel_matrix_double *channel_datum_double;    /*      Get the channel data for given channel instance      /**/    channel_datum_double = &channel_data_double[instance];    nTaps = channel_datum_double->n_taps;    std_noise = channel_datum_double->noise_std ;    /*        If AWGN noise is added to the channel       /**/    if(std_noise > 0 )      i = wcdma_channel_conv_double(Inputs,Qnputs,nInputs,instance,Iout,Qout);    /*        If no noise is added /**/ 	    else      i = wcdma_channel_conv_nonoise_double(Inputs,Qnputs,nInputs,instance,Iout,Qout);        /*        Return the used channel amplitude and delay vectors       /**/    for(i=0;i<nTaps;i++){      channel[i] = channel_datum_double->cur_channel[i];      delay[i] = channel_datum_double->cur_delays[i];    }    /*        Update the channel amplitude and delay vectors if not CONSTANT channel       /**/        if (channel_datum_double->mode > CONST){      wcdma_update_channel_double(channel_datum_double);    }    /*        Save the last chips of this input block to next function call       /**/    i = wcdma_update_memory_chips_double(Inputs,Qnputs,nInputs,channel_datum_double);    /**/        return(0);}/* -------------------------------------------------------------------- *//* * Function:    wcdma_channel_conv_nonoise  * Desc.:       Channel response *              Performs the channel concolution and adds no noise to it *              (i.e. is almost the same as function wcdma_channel_conv) * Note: *         channel_impulse and tap_delay vectors need to same length and *         their elements are corresponding, i.e. the tap_delay[i]  *         indicates how many chipintervals the channel_impulse  *         is delayd. The channel_impulse[i] indicates the attennuation *         coefficient.  * *        THE LAST ELEMENT OF tap_delay[i] VECTOR IMPLIES WHAT IS THE TOTAL *        DELAY FOR THE CHANNEL.  *//* -------------------------------------------------------------------- */int wcdma_channel_conv_nonoise_double( 	     double  Inputs[],	        /* IN: input chip vector */	     double  Qnputs[],	        /* IN: input chip vector */	     int  nInputs,	        /* IN: input vector size */	     int  instance,	        /* IN: indicates the channel instance used/**/ 	     double Iout[],             /* OUT: output bit vector */	     double Qout[]              /* OUT: output bit vector */){    int i, j, i_tmp, tmp_delay,d_zero;    int  taps, mem_len;    double I_collect , Q_collect , noise,std_noise;    int  *delay;     double  *channel, *prev_I, *prev_Q;    channel_matrix_double *channel_datum_double;    /*      Get infromation about the used channel from the channel matrix      /**/          channel_datum_double = &channel_data_double[instance];    taps = channel_datum_double->n_taps;    /*        Current channel amplitudes and delays       /**/    channel = &channel_datum_double->cur_channel[0];    delay = &channel_datum_double->cur_delays[0];    mem_len = delay[taps -1];    /*      The chips saved from previous function call      /**/    prev_I = &(channel_datum_double->I_prev_chips[0]);    prev_Q = &(channel_datum_double->Q_prev_chips[0]);    /*        The first mem_len chips are effected also by the        previous input chips.        /**/    for(i = mem_len ; i > 0; i--) {      I_collect = 0;  /* gathers all the multipaths signals for I /**/      Q_collect = 0;  /* and for Q/**/      d_zero = i - mem_len;      for(j = 0; j < taps; j++) {	    i_tmp = d_zero + delay[j];             if( i_tmp > 0) {	      /* Use the stored chips to update the output		 /**/	      I_collect += prev_I[i_tmp - 1] * channel[j];	      Q_collect += prev_Q[i_tmp - 1] * channel[j];	    } 	    else {	      /* Use the new input chips  to update the output		 /**/	      i_tmp = abs(i_tmp);	      I_collect += Inputs[i_tmp] * channel[j];