コード例 #1
0
void multipath_channel(channel_desc_t *desc,
                       double **tx_sig_re,
                       double **tx_sig_im,
                       double **rx_sig_re,
                       double **rx_sig_im,
                       uint32_t length,
                       uint8_t keep_channel)
{

  int i,ii,j,l;
  int length1, length2, tail;
  __m128d rx_tmp128_re_f,rx_tmp128_im_f,rx_tmp128_re,rx_tmp128_im, rx_tmp128_1,rx_tmp128_2,rx_tmp128_3,rx_tmp128_4,tx128_re,tx128_im,ch128_x,ch128_y,pathloss128;

  double path_loss = pow(10,desc->path_loss_dB/20);
  int dd = abs(desc->channel_offset);

  pathloss128 = _mm_set1_pd(path_loss);

#ifdef DEBUG_CH
  printf("[CHANNEL] keep = %d : path_loss = %g (%f), nb_rx %d, nb_tx %d, dd %d, len %d \n",keep_channel,path_loss,desc->path_loss_dB,desc->nb_rx,desc->nb_tx,dd,desc->channel_length);
#endif

  if (keep_channel) {
    // do nothing - keep channel
  } else {
    random_channel(desc,0);
  }

  start_meas(&desc->convolution);

#ifdef DEBUG_CH

  for (l = 0; l<(int)desc->channel_length; l++) {
    printf("%p (%f,%f) ",desc->ch[0],desc->ch[0][l].x,desc->ch[0][l].y);
  }

  printf("\n");
#endif

  tail = ((int)length-dd)%2;

  if(tail)
    length1 = ((int)length-dd)-1;
  else
    length1 = ((int)length-dd);

  length2 = length1/2;

  for (i=0; i<length2; i++) { //
    for (ii=0; ii<desc->nb_rx; ii++) {
      // rx_tmp.x = 0;
      // rx_tmp.y = 0;
      rx_tmp128_re_f = _mm_setzero_pd();
      rx_tmp128_im_f = _mm_setzero_pd();

      for (j=0; j<desc->nb_tx; j++) {
        for (l = 0; l<(int)desc->channel_length; l++) {
          if ((i>=0) && (i-l)>=0) { //SIMD correct only if length1 > 2*channel_length...which is almost always satisfied
            // tx.x = tx_sig_re[j][i-l];
            // tx.y = tx_sig_im[j][i-l];
            tx128_re = _mm_loadu_pd(&tx_sig_re[j][2*i-l]); // tx_sig_re[j][i-l+1], tx_sig_re[j][i-l]
            tx128_im = _mm_loadu_pd(&tx_sig_im[j][2*i-l]);
          } else {
            //tx.x =0;
            //tx.y =0;
            tx128_re = _mm_setzero_pd();
            tx128_im = _mm_setzero_pd();
          }

          ch128_x = _mm_set1_pd(desc->ch[ii+(j*desc->nb_rx)][l].x);
          ch128_y = _mm_set1_pd(desc->ch[ii+(j*desc->nb_rx)][l].y);
          //  rx_tmp.x += (tx.x * desc->ch[ii+(j*desc->nb_rx)][l].x) - (tx.y * desc->ch[ii+(j*desc->nb_rx)][l].y);
          //  rx_tmp.y += (tx.y * desc->ch[ii+(j*desc->nb_rx)][l].x) + (tx.x * desc->ch[ii+(j*desc->nb_rx)][l].y);
          rx_tmp128_1 = _mm_mul_pd(tx128_re,ch128_x);
          rx_tmp128_2 = _mm_mul_pd(tx128_re,ch128_y);
          rx_tmp128_3 = _mm_mul_pd(tx128_im,ch128_x);
          rx_tmp128_4 = _mm_mul_pd(tx128_im,ch128_y);
          rx_tmp128_re = _mm_sub_pd(rx_tmp128_1,rx_tmp128_4);
          rx_tmp128_im = _mm_add_pd(rx_tmp128_2,rx_tmp128_3);
          rx_tmp128_re_f = _mm_add_pd(rx_tmp128_re_f,rx_tmp128_re);
          rx_tmp128_im_f = _mm_add_pd(rx_tmp128_im_f,rx_tmp128_im);
        } //l
      }  // j

      //rx_sig_re[ii][i+dd] = rx_tmp.x*path_loss;
      //rx_sig_im[ii][i+dd] = rx_tmp.y*path_loss;
      rx_tmp128_re_f = _mm_mul_pd(rx_tmp128_re_f,pathloss128);
      rx_tmp128_im_f = _mm_mul_pd(rx_tmp128_im_f,pathloss128);
      _mm_storeu_pd(&rx_sig_re[ii][2*i+dd],rx_tmp128_re_f); // max index: length-dd -1 + dd = length -1
      _mm_storeu_pd(&rx_sig_im[ii][2*i+dd],rx_tmp128_im_f);
      /*
      if ((ii==0)&&((i%32)==0)) {
      printf("%p %p %f,%f => %e,%e\n",rx_sig_re[ii],rx_sig_im[ii],rx_tmp.x,rx_tmp.y,rx_sig_re[ii][i-dd],rx_sig_im[ii][i-dd]);
      }
      */
      //rx_sig_re[ii][i] = sqrt(.5)*(tx_sig_re[0][i] + tx_sig_re[1][i]);
      //rx_sig_im[ii][i] = sqrt(.5)*(tx_sig_im[0][i] + tx_sig_im[1][i]);

    } // ii
  } // i

  stop_meas(&desc->convolution);

}
コード例 #2
0
//#define DEBUG_CH
uint8_t multipath_channel_nosigconv(channel_desc_t *desc)
{

  random_channel(desc,0);
  return(1);
}
コード例 #3
0
ファイル: emos_sim.c プロジェクト: mspublic/openair4G-mirror
// Leosam 08/08: What are the arguments?
int
main (int argc, char **argv)
{

	// Command line parsing
	int input_val = 1000;	// Value serving as an input relatad to the SNR
	int max_num_ofdm_sym = 64;	// Index of the last frame for the channel estimation
	int be_verbose = 0;	// Operate in verbose mode
	int index;
	int c;
	unsigned int rx_energy[NB_ANTENNAS], n0_energy[NB_ANTENNAS];

	if (argc == 1)
	{
		error ();
		exit (-1);
	}

	while ((c = getopt (argc, argv, "hVv:n:")) != -1)
	{
		switch (c)
		{
		case 'h':
			help ();
			exit (1);
		case 'V':
			be_verbose = 1;
			break;
		case 'v':
			input_val = atoi (optarg);
			break;
			return 1;
		case 'n':
			max_num_ofdm_sym = atoi (optarg);
			break;
			return 1;
		default:
			error ();
			exit (-1);
		}
	}

	//
	// Initialization stuff
	//

	int i, ii, j, ret, delay, l;
	short seed[3];

	// Leosam 08/08: What is this amps?
	double amps[8] = { 1.0, .8, .4, .2, .1, .05, .025, .01 };
	struct complex ch[NB_ANTENNAS * NB_ANTENNAS][10 + (int) (1 + 2 * BW * Td)];
	struct complex rx_tmp, tx, n, phase;

	char *chbch_pdu;
	int chbch_size;
	int extension;
	unsigned char dummy_mac_pdu[120];

#ifdef USER_MODE
  char fname[40], vname[40];
#endif // USER_MODE

	if (be_verbose)
		printf ("Allocating memory for PHY_VARS\n");

	// Memory allocation for PHY and MAC structures
	PHY_vars = malloc (sizeof (PHY_VARS));
	PHY_config = malloc (sizeof (PHY_CONFIG));
	mac_xface = malloc (sizeof (MAC_xface));

	// Loading of the configuration data
	if ((config = fopen ("config.cfg", "r")) == NULL)	// this can be configured
	{
		if (be_verbose)
			printf ("[Main USER] The openair configuration file <config.cfg> could not be found!\n");
		exit (0);
	}

	if ((scenario = fopen ("scenario.scn", "r")) == NULL)
	{
		if (be_verbose)
			printf ("[Main USER] The openair scenario file <scenario.scn> could not be found!\n");
		exit (0);
	}

	if (be_verbose)
		printf ("Opened configuration files\n");

	reconfigure_MACPHY (scenario);

	if (be_verbose)
		dump_config ();

	//  Leosam 08/08: This is repeated bellow. Is it necessary?
	mac_xface->is_cluster_head = 0;

	// Initialize the PHY and MAC variables
	phy_init (NB_ANTENNAS_TX);
	if (be_verbose)
		printf ("Initialized PHY variables\n");


	// Fill MAC PDU buffer for CHBCH
	seed[0] = (short) time (NULL);
	seed[1] = (short) time (NULL);
	seed[2] = (short) time (NULL);
	seed48 (&seed[0]);

	randominit ();

	/*
	 * for (i=0;i<mac_xface->mac_tch->bch_tx[0].size-4;i++) {
	 * mac_xface->mac_tch->bch_tx[0].data[i] = i;//(u8)lrand48();
	 * }
	 * 
	 * 
	 * printf("Filled CHBCH PDU with random data\n");
	 * 
	 * // Generate one CHBCH
	 * phy_generate_chbch(0);
	 * 
	 */

	//
	//  Preparation for the TX procedure
	// 

	// Creation of the CHBCH
	chbch_size = (NUMBER_OF_CARRIERS_PER_GROUP * (NUMBER_OF_CHBCH_SYMBOLS) * 16) >> 3;
	if (be_verbose)
		printf ("chbch_size = %d\n", chbch_size);
	chbch_pdu = malloc (chbch_size);

	for (i = 0; i < chbch_size - 4; i++)
	{
		chbch_pdu[i] = i;
	}

	if (be_verbose)
		printf ("Filled CHBCH PDU (%d bytes) with data\n", chbch_size);

	// Leosam 08/08: O.o
	delay = 1032;
	//	delay = 0;

	// Generation of the CHBCH
	phy_generate_chbch (0, 1, NB_ANTENNAS_TX, chbch_pdu);

	// Generation of the pilot symbols
	for (i = 16; i < max_num_ofdm_sym; i++)
	{
		phy_generate_sch (0, i, 0xFFFF, 1, NB_ANTENNAS_TX);
	}
	
	mac_xface->is_cluster_head = 0;
	
	if (be_verbose)
	{
		for (ii=0; ii<NB_ANTENNAS; ii++)
		{
			sprintf (fname, "txsig%d.m", ii);
			sprintf (vname, "txs%d", ii);

			write_output (fname, vname,
										(s16 *) PHY_vars->tx_vars[ii].TX_DMA_BUFFER,
										NUMBER_OF_SYMBOLS_PER_FRAME * OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES, 1, 1);
		}
	}


	// generate channels
	if (be_verbose)
		printf ("Generating MIMO Channels\n");

	phase.r = 0;
	phase.i = 0;
	
	printf("Phase pointer %0x\n",&phase);

	for (i = 0; i < NB_ANTENNAS; i++)
	{
		for (j = 0; j < NB_ANTENNAS; j++)
		{
			random_channel (amps, Td, 8, BW, ch[j + (i * NB_ANTENNAS)],0.0,&phase);
		}
	}

	if (be_verbose)
		printf ("chbch_pdu %x (%d)\n", PHY_vars->chbch_data[0].demod_pdu, chbch_size);

	if (be_verbose)
	{
		for (l = 0; l < (1 + 2 * BW * Td); l++)
		{
			printf ("(%f,%f)\n", ch[0][l]);
		}
	}

	//
	// TX procedure
	//

	// Transmission 
	//
	//////////////////////////
	
	// Foreach symbol
	for (i = 0; i < (max_num_ofdm_sym) * OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES; i++)
	{
		// Foreach RX antenna
		for (ii = 0; ii < NB_ANTENNAS; ii++)
		{
			rx_tmp.r = 0;
			rx_tmp.i = 0;
			n.r = gaussdouble (0.0, 10.0);
			n.i = gaussdouble (0.0, 10.0);
			
			// Foreach TX antenna
			for (j = 0; j < NB_ANTENNAS; j++)
			{
				
				// Foreach symbol
				for (l = 0; l < (1 + 2 * BW * Td); l++)
				{

					tx.r = (double) (((s16 *) & PHY_vars->tx_vars[j].
							  TX_DMA_BUFFER[0 *
									OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES])
							 [2 * (i - l)]) / sqrt (1.0 * input_val);
					tx.i = (double) (((s16 *) & PHY_vars->tx_vars[j].
							  TX_DMA_BUFFER[0 *
									OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES])
							 [1 +
							  (2 * (i - l))]) / sqrt (1.0 * input_val);

					rx_tmp.r +=
						(tx.r * ch[j + (ii * NB_ANTENNAS)][l].r) -
						(tx.i * ch[j + (ii * NB_ANTENNAS)][l].i);
					rx_tmp.i +=
						(tx.i * ch[j + (ii * NB_ANTENNAS)][l].r) +
						(tx.r * ch[j + (ii * NB_ANTENNAS)][l].i);

				}
			}
 
			((s16 *) & PHY_vars->rx_vars[ii].
			 RX_DMA_BUFFER[delay + (0 * OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES)])[2 * i] =
					(short) (rx_tmp.r + n.r);
			((s16 *) & PHY_vars->rx_vars[ii].
			 RX_DMA_BUFFER[delay + (0 * OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES)])[1 +
											(2 * i)] =
					(short) (rx_tmp.i + n.i);
		}
	}

	if (be_verbose)
	{
		for (ii=0; ii<NB_ANTENNAS; ii++)
		{
			sprintf (fname, "rxsig%d.m", ii);
			sprintf (vname, "rxs%d", ii);

			write_output (fname, vname,
			      (s16 *) PHY_vars->rx_vars[ii].RX_DMA_BUFFER,
						NUMBER_OF_SYMBOLS_PER_FRAME * OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES, 1, 1);
		}
	}

	//
	// RX procedure
	//  

	if (be_verbose)
		printf ("Starting RX\n");

	// Sync
	phy_synch_time (PHY_vars->rx_vars[0].RX_DMA_BUFFER,
			&sync_pos, 
			FRAME_LENGTH_COMPLEX_SAMPLES, 
			768, 
			CHSCH, 
			0);

	// Forcing sync to 0 since were running offline
	if (be_verbose)
		msg ("sync_pos = %d\n", sync_pos);
	PHY_vars->rx_vars[0].offset = 0;	//sync_pos;
	
	// estamte the signal and noise energy
	for (ii=0; ii < NB_ANTENNAS; ii++)
	{
		rx_energy[ii] = signal_energy((int *)&PHY_vars->rx_vars[ii].RX_DMA_BUFFER[PHY_vars->rx_vars[0].offset+CYCLIC_PREFIX_LENGTH],
																	OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES);
		n0_energy[ii] = signal_energy((int *)&PHY_vars->rx_vars[ii].RX_DMA_BUFFER[PHY_vars->rx_vars[0].offset+CYCLIC_PREFIX_LENGTH + 
																	(NUMBER_OF_CHSCH_SYMBOLS+NUMBER_OF_CHBCH_SYMBOLS+1) * OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES],
																	OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES);
		//msg("CYCLIC_PREFIX_LENGTH=%d, NUMBER_OF_CHSCH_SYMBOLS=%d, NUMBER_OF_CHBCH_SYMBOLS=%d, OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES=%d\n", CYCLIC_PREFIX_LENGTH, NUMBER_OF_CHSCH_SYMBOLS, NUMBER_OF_CHBCH_SYMBOLS, OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES);
		msg("symbol = %d\n", PHY_vars->rx_vars[ii].RX_DMA_BUFFER[PHY_vars->rx_vars[0].offset+CYCLIC_PREFIX_LENGTH + 
				(NUMBER_OF_CHSCH_SYMBOLS+NUMBER_OF_CHBCH_SYMBOLS) * OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES]);
		msg("SNR Ant %d = %d / %d \n", ii, rx_energy[ii], n0_energy[ii]);
	}	

	// CHBCH channel estimation
	phy_channel_estimation_top(PHY_vars->rx_vars[0].offset,0,0,0,NB_ANTENNAS,0);
	//phy_channel_estimation_top (PHY_vars->rx_vars[0].offset, 0, 0, 0);

	phy_decode_chbch (0, &dummy_mac_pdu[0], NB_ANTENNAS, NB_ANTENNAS_TX, 120);

	if (be_verbose)
	{
		for (i = 0; i < chbch_size; i++)
		{
			msg ("Data %x : %x\n", i, PHY_vars->chbch_data[0].demod_pdu[i]);
		}
	}
	
	printf("PERROR_SHIFT: %d\n", PERROR_SHIFT);
	
	//
	// Channel estimation procedure
	//
// 	for (i = 0; i < max_num_ofdm_sym; i++)
// 	{
// 		phy_channel_estimation_top(PHY_vars->rx_vars[0].offset,i,0,0,1);
// 	}
	  
	phy_channel_est_emos(16, 16, max_num_ofdm_sym-1, TRUE, 0);

	phy_cleanup ();
	if (be_verbose)
		printf ("Exiting\n");

}
コード例 #4
0
void multipath_channel(channel_desc_t *desc,
                       double **tx_sig_re,
                       double **tx_sig_im,
                       double **rx_sig_re,
                       double **rx_sig_im,
                       uint32_t length,
                       uint8_t keep_channel)
{

  int i,ii,j,l;
  struct complex rx_tmp,tx;

  double path_loss = pow(10,desc->path_loss_dB/20);
  int dd;
  dd = abs(desc->channel_offset);

#ifdef DEBUG_CH
  printf("[CHANNEL] keep = %d : path_loss = %g (%f), nb_rx %d, nb_tx %d, dd %d, len %d \n",keep_channel,path_loss,desc->path_loss_dB,desc->nb_rx,desc->nb_tx,dd,desc->channel_length);
#endif

  if (keep_channel) {
    // do nothing - keep channel
  } else {
    random_channel(desc,0);
  }

#ifdef DEBUG_CH

  for (l = 0; l<(int)desc->channel_length; l++) {
    printf("%p (%f,%f) ",desc->ch[0],desc->ch[0][l].x,desc->ch[0][l].y);
  }

  printf("\n");
#endif

  for (i=0; i<((int)length-dd); i++) {
    for (ii=0; ii<desc->nb_rx; ii++) {
      rx_tmp.x = 0;
      rx_tmp.y = 0;

      for (j=0; j<desc->nb_tx; j++) {
        for (l = 0; l<(int)desc->channel_length; l++) {
          if ((i>=0) && (i-l)>=0) {
            tx.x = tx_sig_re[j][i-l];
            tx.y = tx_sig_im[j][i-l];
          } else {
            tx.x =0;
            tx.y =0;
          }

          rx_tmp.x += (tx.x * desc->ch[ii+(j*desc->nb_rx)][l].x) - (tx.y * desc->ch[ii+(j*desc->nb_rx)][l].y);
          rx_tmp.y += (tx.y * desc->ch[ii+(j*desc->nb_rx)][l].x) + (tx.x * desc->ch[ii+(j*desc->nb_rx)][l].y);
        } //l
      }  // j

      rx_sig_re[ii][i+dd] = rx_tmp.x*path_loss;
      rx_sig_im[ii][i+dd] = rx_tmp.y*path_loss;
      /*
      if ((ii==0)&&((i%32)==0)) {
      printf("%p %p %f,%f => %e,%e\n",rx_sig_re[ii],rx_sig_im[ii],rx_tmp.x,rx_tmp.y,rx_sig_re[ii][i-dd],rx_sig_im[ii][i-dd]);
      }
      */
      //rx_sig_re[ii][i] = sqrt(.5)*(tx_sig_re[0][i] + tx_sig_re[1][i]);
      //rx_sig_im[ii][i] = sqrt(.5)*(tx_sig_im[0][i] + tx_sig_im[1][i]);

    } // ii
  } // i
}
コード例 #5
0
ファイル: ch_desc_proto.c プロジェクト: sdnnfv/openair4G
int main()
{
    int enb_count = 16;
    int ue_count = 50;
    double sect_angle[3]= {0,2*PI/3,4*PI/3};
    double gain_max;
    double theta;
    double min_path_loss = 0;
    int att_enb_index;
    node_desc_t *enb_data[enb_count];
    node_desc_t *ue_data[ue_count];
    channel_desc_t *ul_channel[ue_count][enb_count];
    channel_desc_t *dl_channel[ue_count][enb_count];
    int count;
    int mcs;
    int ue_index, enb_index;
    int return_value;
    int nb_rb = 25; //No. of resource blocks
    double sinr[enb_count][2*nb_rb];
    double sinr_eff[ue_count][MCS_COUNT];
    double bler[ue_count][MCS_COUNT];
    double gain_sec[3];
    double thermal_noise;
    double interference;
    double coupling;
    FILE *fp;
    char buffer[100];
    char *sinr_bler;
    double tlu_sinr;
    double tlu_bler;
    int line_num;
    char *file_name[]= {"bler_1.csv", "bler_2.csv", "bler_3.csv", "bler_4.csv", "bler_5.csv", "bler_6.csv", "bler_7.csv", "bler_8.csv",
                        "bler_9.csv", "bler_10.csv", "bler_11.csv", "bler_12.csv", "bler_13.csv", "bler_14.csv", "bler_15.csv", "bler_16.csv",
                        "bler_17.csv", "bler_18.csv", "bler_19.csv", "bler_20.csv", "bler_21.csv", "bler_22.csv"
                       };

    double beta[MCS_COUNT] = {0, 0, 0, 0, 0.9459960937499999, 1.2912109374999994, 1.0133789062499998, 1.000390625,
                              1.02392578125, 1.8595703124999998, 2.424389648437498, 2.3946533203124982, 2.5790039062499988,
                              2.4084960937499984, 2.782617187499999, 2.7868652343749996, 3.92099609375, 4.0392578125,
                              4.56109619140625, 5.03338623046875, 5.810888671875, 6.449108886718749
                             };

    double enb_position[][2] = {{1100,1100},{1100,2100},{1100,3100},{1100,4100},
        {2100,1100},{2100,2100},{2100,3100},{2100,4100},
        {3100,1100},{3100,2100},{3100,3100},{3100,4100},
        {4100,1100},{4100,2100},{4100,3100},{4100,4100}
    };

    double ue_position[][2] = {{3340,4740},{1500,620},{1780,4220},{1300,3540},{780,3100},
        {1140,540},{1340,3660},{860,1220},{2700,2140},{3860,3060},
        {3740,1060},{1700,3060},{2180,1620},{4420,1060},{1300,3340},
        {3700,3180},{3780,540},{1700,4380},{4140,4740},{820,4380},
        {3300,1540},{2100,1780},{1780,2260},{1940,2620},{1580,1700},
        {1460,1940},{940,1340},{2100,3540},{1260,4340},{2940,4060},
        {3980,940},{540,2220},{3060,2140},{4620,3940},{4260,2820},
        {3860,3500},{4140,4140},{3900,3500},{1500,2140},{2620,3820},
        {3420,2820},{1580,3940},{660,2100},{2740,1180},{2500,2500},
        {3580,3580},{3740,3140},{3020,3020},{4340,4140},{980,4300}
    };

    randominit(0);

    /////////////////////////////////////////////////////////////////////////////////////////////////
    int tabl_len=0;
    double local_table[MCS_COUNT][9][9];

    for (mcs = 5; mcs <= MCS_COUNT; mcs++) {

        fp = fopen(file_name[mcs - 1],"r");

        if (fp == NULL) {
            printf("ERROR: Unable to open the file\n");
        } else {
            fgets(buffer, 100, fp);
            tabl_len=0;

            while (!feof(fp)) {

                sinr_bler = strtok(buffer, ";");
                local_table[mcs-1][0][tabl_len] = atof(sinr_bler);
                sinr_bler = strtok(NULL,";");
                local_table[mcs-1][1][tabl_len] = atof(sinr_bler);
                tabl_len++;
                fgets(buffer, 100, fp);
            }

            fclose(fp);
        }

        printf("\n table for mcs %d\n",mcs);

        for (tabl_len=0; tabl_len<9; tabl_len++)
            printf("%lf  %lf \n ",local_table[mcs-1][0][tabl_len],local_table[mcs-1][1][tabl_len]);


    }



    ////////////////////////////////////////////////////////////////////////////////////////////////////

    for (enb_index = 0; enb_index < enb_count; enb_index++)
        enb_data[enb_index] = (node_desc_t *)(malloc(sizeof(node_desc_t)));

    for (ue_index = 0; ue_index < ue_count; ue_index++)
        ue_data[ue_index] = (node_desc_t *)(malloc(sizeof(node_desc_t)));

    for (enb_index = 0; enb_index < enb_count; enb_index++)  {
        enb_data[enb_index]->x = enb_position[enb_index][0];
        enb_data[enb_index]->y = enb_position[enb_index][1];
        enb_data[enb_index]->tx_power_dBm = 40;
        enb_data[enb_index]->ant_gain_dBi = 15;
        enb_data[enb_index]->rx_noise_level = 5; //value in db
        enb_data[enb_index]->n_sectors = 3;
    }

    for (ue_index = 0; ue_index < ue_count; ue_index++)  {
        ue_data[ue_index]->x = ue_position[ue_index][0];
        ue_data[ue_index]->y = ue_position[ue_index][1];
        ue_data[ue_index]->phi_rad = 2 * PI;
        ue_data[ue_index]->tx_power_dBm = 20;
        ue_data[ue_index]->ant_gain_dBi = 0;
        ue_data[ue_index]->rx_noise_level = 9; //value in db
    }

    for (ue_index = 0; ue_index < ue_count; ue_index++) {
        min_path_loss = 10000;

        for (enb_index = 0; enb_index < enb_count; enb_index++) {
            ul_channel[ue_index][enb_index] = new_channel_desc_scm(1, 1, SCM_C, 7.68, 0, 0, 0);
            dl_channel[ue_index][enb_index] = new_channel_desc_scm(1, 1, SCM_C, 7.68, 0, 0, 0);
            //printf("ue %d enb %d\n", ue_index, enb_index);

            /* Calculating the angle in the range -pi to pi from the slope */
            //(ue_data[ue_index])->alpha_rad[enb_index] = (double)(atan2((ue_data[ue_index]->x - enb_data[enb_index]->x), (ue_data[ue_index]->y - enb_data[enb_index]->y)));
            ue_data[ue_index]->alpha_rad[enb_index] = atan2((ue_data[ue_index]->x - enb_data[enb_index]->x), (ue_data[ue_index]->y - enb_data[enb_index]->y));
            //printf("angle is tan %lf\n", ue_data[ue_index]->alpha_rad[enb_index]);

            if ((ue_data[ue_index]->alpha_rad[enb_index]) < 0) {
                ue_data[ue_index]->alpha_rad[enb_index] = 2*PI + ue_data[ue_index]->alpha_rad[enb_index];
                //printf("angle in radians is %lf\n", ue_data[ue_index]->alpha_rad[enb_index]);
            }

            for(count = 0; count < enb_data[enb_index]->n_sectors; count++) {
                theta = sect_angle[count] - ue_data[ue_index]->alpha_rad[enb_index];
                gain_sec[count] = -(Am < (12 * pow((theta/theta_3dB),2)) ? Am : (12 * pow((theta/theta_3dB),2)));
            }

            /* gain = -min(Am , 12 * (theta/theta_3dB)^2) */
            gain_max = (gain_sec[SEC1] > gain_sec[SEC2]) ? ((gain_sec[SEC1] > gain_sec[SEC3]) ? gain_sec[SEC1]:gain_sec[SEC3]) :
                       ((gain_sec[SEC2] > gain_sec[SEC3]) ? gain_sec[SEC2]:gain_sec[SEC3]);

            get_chan_desc(enb_data[enb_index], ue_data[ue_index], ul_channel[ue_index][enb_index], &scenario);
            get_chan_desc(enb_data[enb_index], ue_data[ue_index], dl_channel[ue_index][enb_index], &scenario);

            //printf("Path loss for link between ue %d and enb %d is %lf and gain is %lf \n", ue_index, enb_index, dl_channel[ue_index][enb_index]->path_loss_dB, gain_max);

            if (dl_channel[ue_index][enb_index]->path_loss_dB < min_path_loss) {
                min_path_loss = dl_channel[ue_index][enb_index]->path_loss_dB;
                att_enb_index = enb_index;
            }

            //return_value = random_channel(ul_channel[ue_index][enb_index]);
            return_value = random_channel(dl_channel[ue_index][enb_index]);

            /* Thermal noise is calculated using 10log10(K*T*B) K = Boltzmann´s constant T = room temperature B = bandwidth */
            /* Taken as constant for the time being since the BW is not changing */
            thermal_noise = -105; //value in dBm

            if (0 == return_value) {
                //freq_channel(ul_channel[ue_index][enb_index], nb_rb);
                freq_channel(dl_channel[ue_index][enb_index], nb_rb);
                coupling = MCL > (dl_channel[ue_index][enb_index]->path_loss_dB-(enb_data[enb_index]->ant_gain_dBi + gain_max)) ?
                           MCL : (dl_channel[ue_index][enb_index]->path_loss_dB-(enb_data[enb_index]->ant_gain_dBi + gain_max));

                //printf ("coupling factor is %lf\n", coupling);
                for (count = 0; count < (2 * nb_rb); count++) {
                    sinr[enb_index][count] = enb_data[enb_index]->tx_power_dBm
                                             - coupling
                                             - (thermal_noise + ue_data[ue_index]->rx_noise_level)
                                             + 10 * log10 (pow(dl_channel[ue_index][enb_index]->chF[0][count].r, 2)
                                                           + pow(dl_channel[ue_index][enb_index]->chF[0][count].i, 2));

                    //printf("Dl_link SNR for res. block %d is %lf\n", count, sinr[enb_index][count]);
                }
            }
        }

        for (count = 0; count < 2 * nb_rb; count++) {
            interference = 0;

            for (enb_index = 0; enb_index < enb_count; enb_index++) {
                if (att_enb_index != enb_index) {
                    interference += pow(10, 0.1 * sinr[enb_index][count]);
                }
            }

            sinr[att_enb_index][count] -= 10*log10(1 + interference);

            //printf("***Dl_link SINR for res. block %d is %lf\n", count, sinr[att_enb_index][count]);

            for (mcs = 5; mcs <= MCS_COUNT; mcs++) {
                sinr_eff[ue_index][mcs-1] += exp(-(pow(10, (sinr[att_enb_index][count])/10))/beta[mcs-1]);
                //printf("Effective snr   %lf\n",sinr_eff[ue_index][mcs-1]);
                //sinr_eff[ue_index][mcs] += exp(-(sinr[att_enb_index][count])/beta[mcs]);
            }
        }

        for (mcs = 5; mcs <= MCS_COUNT; mcs++) {
            //printf("mcs value  %d \n",mcs);
            //printf("beta value  %lf \n",-beta[mcs-1]);
            //printf("snr_eff value  %lf \n",log(sinr_eff[ue_index][mcs-1]));

            sinr_eff[ue_index][mcs-1] =  -beta[mcs-1] *log((sinr_eff[ue_index][mcs-1])/(2*nb_rb));//
            //printf("snr_eff value  %lf \n",sinr_eff[ue_index][mcs-1]);
            sinr_eff[ue_index][mcs-1] = 10 * log10(sinr_eff[ue_index][mcs-1]);
            sinr_eff[ue_index][mcs-1] *= 10;
            sinr_eff[ue_index][mcs-1] = floor(sinr_eff[ue_index][mcs-1]);

            if ((int)sinr_eff[ue_index][mcs-1]%2) {
                sinr_eff[ue_index][mcs-1] += 1;
            }

            sinr_eff[ue_index][mcs-1] /= 10;

            //printf("Effective snr   %lf  \n",sinr_eff[ue_index][mcs-1]);

            bler[ue_index][mcs-1] = 0;

            /*line_num = 0;
            fp = fopen(file_name[mcs - 1],"r");
            if (fp == NULL) {
              printf("ERROR: Unable to open the file\n");
            }
            else {
              fgets(buffer, 100, fp);
              while (!feof(fp)) {
            line_num++;
            sinr_bler = strtok(buffer, ";");
            tlu_sinr = atof(sinr_bler);
            sinr_bler = strtok(NULL,";");
            tlu_bler = atof(sinr_bler);
            if (1 == line_num) {
            if (sinr_eff[ue_index][mcs-1] < tlu_sinr) {
            bler[ue_index][mcs-1] = 1;
            break;
            }
            }
            if (sinr_eff[ue_index][mcs-1] == tlu_sinr) {
            bler[ue_index][mcs-1] = tlu_bler;
            }
            fgets(buffer, 100, fp);
              }
              fclose(fp);*/
            for (tabl_len=0; tabl_len<9; tabl_len++) {

                if(tabl_len==0)
                    if (sinr_eff[ue_index][mcs-1] < local_table[mcs-1][0][tabl_len]) {
                        bler[ue_index][mcs-1] = 1;
                        break;
                    }


                if (sinr_eff[ue_index][mcs-1] == local_table[mcs-1][0][tabl_len]) {
                    bler[ue_index][mcs-1] = local_table[mcs-1][1][tabl_len];
                }

            }

            //printf("\n###Dl_link UE %d attached to eNB %d \n MCS %d effective SNR %lf BLER %lf", ue_index, att_enb_index, mcs,sinr_eff[ue_index][mcs-1],bler[ue_index][mcs-1]);
        }

        //printf("\n\n");

        printf("\n     Ue_ix enb_ix  mcs5    mcs6    mcs7    mcs8    mcs9   mcs10   mcs11   mcs12   mcs13\
   mcs14   mcs15   mcs16   mcs17   mcs18   mcs19   mcs20   mcs21   mcs22\n");

        printf("SINR %4d   %4d  %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f\
   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f\n",
               ue_index, att_enb_index, sinr_eff[ue_index][4], sinr_eff[ue_index][5], sinr_eff[ue_index][6], sinr_eff[ue_index][7],
               sinr_eff[ue_index][8], sinr_eff[ue_index][9], sinr_eff[ue_index][10], sinr_eff[ue_index][11], sinr_eff[ue_index][12],
               sinr_eff[ue_index][13], sinr_eff[ue_index][14], sinr_eff[ue_index][15], sinr_eff[ue_index][16], sinr_eff[ue_index][17],
               sinr_eff[ue_index][18], sinr_eff[ue_index][19], sinr_eff[ue_index][20], sinr_eff[ue_index][21], sinr_eff[ue_index][22]);

        printf("BLER %4d   %4d  %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f\
   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f   %+4.2f\n",
               ue_index, att_enb_index, bler[ue_index][4], bler[ue_index][5], bler[ue_index][6], bler[ue_index][7],
               bler[ue_index][8], bler[ue_index][9], bler[ue_index][10], bler[ue_index][11], bler[ue_index][12],
               bler[ue_index][13], bler[ue_index][14], bler[ue_index][15], bler[ue_index][16], bler[ue_index][17],
               bler[ue_index][18], bler[ue_index][19], bler[ue_index][20], bler[ue_index][21], bler[ue_index][22]);
    }
}