ulsim.c 69.8 KB
Newer Older
1
/*******************************************************************************
ghaddab's avatar
ghaddab committed
2
3
    OpenAirInterface 
    Copyright(c) 1999 - 2014 Eurecom
4

ghaddab's avatar
ghaddab committed
5
6
7
8
    OpenAirInterface is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
9
10


ghaddab's avatar
ghaddab committed
11
12
13
14
    OpenAirInterface is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
15

ghaddab's avatar
ghaddab committed
16
17
18
19
    You should have received a copy of the GNU General Public License
    along with OpenAirInterface.The full GNU General Public License is 
   included in this distribution in the file called "COPYING". If not, 
   see <http://www.gnu.org/licenses/>.
20
21

  Contact Information
ghaddab's avatar
ghaddab committed
22
23
24
25
  OpenAirInterface Admin: openair_admin@eurecom.fr
  OpenAirInterface Tech : openair_tech@eurecom.fr
  OpenAirInterface Dev  : openair4g-devel@eurecom.fr
  
ghaddab's avatar
ghaddab committed
26
  Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
27

ghaddab's avatar
ghaddab committed
28
 *******************************************************************************/
29
30
31
32

/*! \file ulsim.c
 \brief Top-level DL simulator
 \author R. Knopp
33
 \date 2011 - 2014
34
35
36
37
38
39
40
 \version 0.1
 \company Eurecom
 \email: knopp@eurecom.fr
 \note
 \warning
*/

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <string.h>
#include <math.h>
#include <unistd.h>
#include "SIMULATION/TOOLS/defs.h"
#include "PHY/types.h"
#include "PHY/defs.h"
#include "PHY/vars.h"
#include "MAC_INTERFACE/vars.h"

#include "SCHED/defs.h"
#include "SCHED/vars.h"
#include "LAYER2/MAC/vars.h"
#include "OCG_vars.h"

#ifdef XFORMS
#include "PHY/TOOLS/lte_phy_scope.h"
#endif

extern unsigned short dftsizes[33];
extern short *ul_ref_sigs[30][2][33];
//#define AWGN
//#define NO_DCI

#define BW 7.68
//#define ABSTRACTION
//#define PERFECT_CE

/*
  #define RBmask0 0x00fc00fc
  #define RBmask1 0x0
  #define RBmask2 0x0
  #define RBmask3 0x0
*/
PHY_VARS_eNB *PHY_vars_eNB;
PHY_VARS_UE *PHY_vars_UE;

#define MCS_COUNT 23//added for PHY abstraction

channel_desc_t *eNB2UE[NUMBER_OF_eNB_MAX][NUMBER_OF_UE_MAX];
channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX];
//Added for PHY abstraction
node_desc_t *enb_data[NUMBER_OF_eNB_MAX]; 
node_desc_t *ue_data[NUMBER_OF_UE_MAX];
//double sinr_bler_map[MCS_COUNT][2][16];

gauthier's avatar
gauthier committed
86
extern uint16_t beta_ack[16],beta_ri[16],beta_cqi[16];
87
88
89
//extern  char* namepointer_chMag ;


90

91
92
93
94
95
#ifdef XFORMS
FD_lte_phy_scope_enb *form_enb;
char title[255];
#endif

96
97
98
99
100
101
102
103
/*the following parameters are used to control the processing times*/
double t_tx_max = -1000000000; /*!< \brief initial max process time for tx */
double t_rx_max = -1000000000; /*!< \brief initial max process time for rx */
double t_tx_min = 1000000000; /*!< \brief initial min process time for tx */
double t_rx_min = 1000000000; /*!< \brief initial min process time for tx */
int n_tx_dropped = 0; /*!< \brief initial max process time for tx */
int n_rx_dropped = 0; /*!< \brief initial max process time for rx */

gauthier's avatar
gauthier committed
104
void lte_param_init(unsigned char N_tx, unsigned char N_rx,unsigned char transmission_mode,uint8_t extended_prefix_flag,uint8_t N_RB_DL,uint8_t frame_type,uint8_t tdd_config,uint8_t osf) {
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

  LTE_DL_FRAME_PARMS *lte_frame_parms;

  printf("Start lte_param_init\n");
  PHY_vars_eNB = malloc(sizeof(PHY_VARS_eNB));
  PHY_vars_UE = malloc(sizeof(PHY_VARS_UE));
  //PHY_config = malloc(sizeof(PHY_CONFIG));
  mac_xface = malloc(sizeof(MAC_xface));

  randominit(0);
  set_taus_seed(0);
  
  lte_frame_parms = &(PHY_vars_eNB->lte_frame_parms);

  lte_frame_parms->frame_type         = frame_type;
  lte_frame_parms->tdd_config         = tdd_config;
  lte_frame_parms->N_RB_DL            = N_RB_DL;   //50 for 10MHz and 25 for 5 MHz
  lte_frame_parms->N_RB_UL            = N_RB_DL;   
  lte_frame_parms->Ncp                = extended_prefix_flag;
  lte_frame_parms->Ncp_UL             = extended_prefix_flag;
  lte_frame_parms->Nid_cell           = 10;
  lte_frame_parms->nushift            = 0;
  lte_frame_parms->nb_antennas_tx     = N_tx;
  lte_frame_parms->nb_antennas_rx     = N_rx;
  //  lte_frame_parms->Csrs = 2;
  //  lte_frame_parms->Bsrs = 0;
  //  lte_frame_parms->kTC = 0;
  //  lte_frame_parms->n_RRC = 0;
  lte_frame_parms->mode1_flag = (transmission_mode == 1)? 1 : 0;
  lte_frame_parms->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift = 0;//n_DMRS1 set to 0

  init_frame_parms(lte_frame_parms,osf);
  
  //copy_lte_parms_to_phy_framing(lte_frame_parms, &(PHY_config->PHY_framing));
  
  phy_init_top(lte_frame_parms); //allocation
  
  lte_frame_parms->twiddle_fft      = twiddle_fft;
  lte_frame_parms->twiddle_ifft     = twiddle_ifft;
  lte_frame_parms->rev              = rev;
  
  PHY_vars_UE->lte_frame_parms = *lte_frame_parms;
  
  phy_init_lte_top(lte_frame_parms);

  phy_init_lte_ue(PHY_vars_UE,1,0);

  phy_init_lte_eNB(PHY_vars_eNB,0,0,0);

  printf("Done lte_param_init\n");


}




#define UL_RB_ALLOC 0x1ff;




int main(int argc, char **argv) {

  char c;
  int i,j,aa,u;

  int aarx,aatx;
  double channelx,channely;
  double sigma2, sigma2_dB=10,SNR,SNR2,snr0=-2.0,snr1,SNRmeas,rate,saving_bler;
knopp's avatar
   
knopp committed
175
  double input_snr_step=.2,snr_int=30;
176
177
178
179
180
181
182
183
184
185
  double blerr;

  //int **txdataF, **txdata;

  int **txdata;

  LTE_DL_FRAME_PARMS *frame_parms;
  double **s_re,**s_im,**r_re,**r_im;
  double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel
  double iqim=0.0;
gauthier's avatar
gauthier committed
186
  uint8_t extended_prefix_flag=0;
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
  int cqi_flag=0,cqi_error,cqi_errors,ack_errors,cqi_crc_falsepositives,cqi_crc_falsenegatives;
  int ch_realization;
  int eNB_id = 0;
  int chMod = 0 ;
  int UE_id = 0;
  unsigned char nb_rb=25,first_rb=0,mcs=0,round=0,bundling_flag=1;
  unsigned char l;

  unsigned char awgn_flag = 0 ;
  SCM_t channel_model=Rice1;


  unsigned char *input_buffer,harq_pid;
  unsigned short input_buffer_length;
  unsigned int ret;
  unsigned int coded_bits_per_codeword,nsymb;
  int subframe=3;
  unsigned int tx_lev=0,tx_lev_dB,trials,errs[4]={0,0,0,0},round_trials[4]={0,0,0,0};
205
  uint8_t transmission_mode=1,n_rx=1,n_tx=1;
206
 
207
  FILE *bler_fd=NULL;
208
  char bler_fname[512];
209

210
211
212
  FILE *time_meas_fd=NULL;
  char time_meas_fname[256];
 
213
214
215
216
217
  FILE *input_fdUL=NULL,*trch_out_fdUL=NULL;
  //  unsigned char input_file=0;
  char input_val_str[50],input_val_str2[50];
 
  //  FILE *rx_frame_file;
218
  FILE *csv_fdUL=NULL;
219

220
  FILE *fperen=NULL;
221
  char fperen_name[512];  
222
  
223
  FILE *fmageren=NULL;
224
225
  char fmageren_name[512];
  
226
  FILE *flogeren=NULL;
227
228
229
230
231
232
233
234
235
236
237
238
239
  char flogeren_name[512];

  /* FILE *ftxlev;
     char ftxlev_name[512];
  */
  
  char csv_fname[512];
  int n_frames=5000;
  int n_ch_rlz = 1;
  int abstx = 0; 
  int hold_channel=0; 
  channel_desc_t *UE2eNB;

gauthier's avatar
gauthier committed
240
  uint8_t control_only_flag = 0;
241
242
  int delay = 0;	
  double maxDoppler = 0.0;	
gauthier's avatar
gauthier committed
243
  uint8_t srs_flag = 0;
244

gauthier's avatar
gauthier committed
245
  uint8_t N_RB_DL=25,osf=1;
246

gauthier's avatar
gauthier committed
247
248
249
250
  uint8_t cyclic_shift = 0;
  uint8_t cooperation_flag = 0; //0 no cooperation, 1 delay diversity, 2 Alamouti
  uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
  uint8_t tdd_config=3,frame_type=FDD;
251

gauthier's avatar
gauthier committed
252
  uint8_t N0=30;
253
254
255
256
257
258
259
  double tx_gain=1.0;
  double cpu_freq_GHz;
  int avg_iter,iter_trials;

  uint32_t UL_alloc_pdu;
  int s,Kr,Kr_bytes;
  int dump_perf=0;
260
  int test_perf=0;
261
262
  int dump_table =0;

263
264
265
  double effective_rate=0.0;
  char channel_model_input[10];
  
266
267
  uint8_t max_turbo_iterations=4;
  uint8_t llr8_flag=0;
268
  int nb_rb_set = 0;
knopp's avatar
   
knopp committed
269
  int sf;
270

knopp's avatar
   
knopp committed
271
272
  opp_enabled=1; // to enable the time meas

273
  cpu_freq_GHz = (double)get_cpu_freq_GHz();
274
275
276
277
278
279

  printf("Detected cpu_freq %f GHz\n",cpu_freq_GHz);


  logInit();

280
  while ((c = getopt (argc, argv, "hapZbm:n:Y:X:x:s:w:e:q:d:D:O:c:r:i:f:y:c:oA:C:R:g:N:l:S:T:QB:PI:L")) != -1) {
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
    switch (c) {
    case 'a':
      channel_model = AWGN;
      chMod = 1;
      break;
    case 'b':
      bundling_flag = 0;
      break;
    case 'd':
      delay = atoi(optarg);
      break;
    case 'D':
      maxDoppler = atoi(optarg);
      break;
    case 'm':
      mcs = atoi(optarg);
      break;
    case 'n':
      n_frames = atoi(optarg);
      break;
    case 'Y':
      n_ch_rlz = atoi(optarg);
      break;  
    case 'X':
      abstx= atoi(optarg);
      break;  
    case 'g':
308
      sprintf(channel_model_input,optarg,10);
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
      switch((char)*optarg) {
      case 'A': 
	channel_model=SCM_A;
	chMod = 2;
	break;
      case 'B': 
	channel_model=SCM_B;
	chMod = 3;
	break;
      case 'C': 
	channel_model=SCM_C;
	chMod = 4;
	break;
      case 'D': 
	channel_model=SCM_D;
	chMod = 5;
	break;
      case 'E': 
	channel_model=EPA;
	chMod = 6;
	break;
      case 'F': 
	channel_model=EVA;
	chMod = 7;
	break;
      case 'G': 
	channel_model=ETU;
	chMod = 8;
	break;
      case 'H':
	channel_model=Rayleigh8;
	chMod = 9;
	break;
      case 'I':
	channel_model=Rayleigh1;
	chMod = 10;
	break;
      case 'J':
	channel_model=Rayleigh1_corr;
	chMod = 11;
	break;
      case 'K':
	channel_model=Rayleigh1_anticorr;
	chMod = 12;
	break;
      case 'L':
	channel_model=Rice8;
	chMod = 13;
	break;
      case 'M':
	channel_model=Rice1;
	chMod = 14;
	break;
362
363
364
365
      case 'N':
	channel_model=AWGN;
	chMod = 1;
	break;
366
367
368
369
370
371
372
      default:
	msg("Unsupported channel model!\n");
	exit(-1);
	break;
      }
      break;
    case 's':
knopp's avatar
   
knopp committed
373
374
375
376
377
378
379
      snr0 = atof(optarg);
      break;
    case 'w':
      snr_int = atof(optarg);
      break;
    case 'e':
      input_snr_step= atof(optarg);
380
      break;
381
382
383
384
385
386
387
388
389
390
391
    case 'x':
      transmission_mode=atoi(optarg);
      if ((transmission_mode!=1) &&
	  (transmission_mode!=2)) {
	msg("Unsupported transmission mode %d\n",transmission_mode);
	exit(-1);
      }
      if (transmission_mode>1) {
	n_tx = 1;
      }
      break;
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
    case 'y':
      n_rx = atoi(optarg);
      break;
    case 'S':
      subframe = atoi(optarg);
      break;
    case 'T':
      tdd_config=atoi(optarg);
      frame_type=TDD;
      break;
    case 'p':
      extended_prefix_flag=1;
      break;
    case 'r':
      nb_rb = atoi(optarg);
407
      nb_rb_set = 1;
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
      break;
    case 'f':
      first_rb = atoi(optarg);
      break;
    case 'c':
      cyclic_shift = atoi(optarg);
      break;
    case 'N':
      N0 = atoi(optarg);
      break;
   
    case 'o':
      srs_flag = 1;
      break;

    case 'i':
      input_fdUL = fopen(optarg,"r");
      msg("Reading in %s (%p)\n",optarg,input_fdUL);
      if (input_fdUL == (FILE*)NULL) {
	msg("Unknown file %s\n",optarg);
	exit(-1);
      }
      //      input_file=1;
      break;
    case 'A':
      beta_ACK = atoi(optarg);
      if (beta_ACK>15) {
	printf("beta_ack must be in (0..15)\n");
	exit(-1);
      }
      break;
    case 'C':
      beta_CQI = atoi(optarg);
      if ((beta_CQI>15)||(beta_CQI<2)) {
	printf("beta_cqi must be in (2..15)\n");
	exit(-1);
      }
      break;
      
    case 'R':
      beta_RI = atoi(optarg);
      if ((beta_RI>15)||(beta_RI<2)) {
	printf("beta_ri must be in (0..13)\n");
	exit(-1);
      }
      break;
    case 'Q':
      cqi_flag=1;
      break;
    case 'B':
      N_RB_DL=atoi(optarg);
      break;
    case 'P':
      dump_perf=1;
462
      opp_enabled=1;
463
      break;
464
465
466
467
    case 'O':
      test_perf=atoi(optarg);
      //print_perf =1;
      break;
468
469
470
471
472
473
    case 'L':
      llr8_flag=1;
      break;
    case 'I':
      max_turbo_iterations=atoi(optarg);
      break;
474
475
476
    case 'Z':
      dump_table = 1;
      break;
477
478
479
480
481
482
483
484
485
    case 'h':
    default:
      printf("%s -h(elp) -a(wgn on) -m mcs -n n_frames -s snr0 -t delay_spread -p (extended prefix on) -r nb_rb -f first_rb -c cyclic_shift -o (srs on) -g channel_model [A:M] Use 3GPP 25.814 SCM-A/B/C/D('A','B','C','D') or 36-101 EPA('E'), EVA ('F'),ETU('G') models (ignores delay spread and Ricean factor), Rayghleigh8 ('H'), Rayleigh1('I'), Rayleigh1_corr('J'), Rayleigh1_anticorr ('K'), Rice8('L'), Rice1('M'), -d Channel delay, -D maximum Doppler shift \n",argv[0]);
      exit(1);
      break;
    }
  }
  
  lte_param_init(1,n_rx,1,extended_prefix_flag,N_RB_DL,frame_type,tdd_config,osf);  
486
487
488
  if (nb_rb_set == 0)
     nb_rb = PHY_vars_eNB->lte_frame_parms.N_RB_UL;

489
490
491
492
  printf("1 . rxdataF_comp[0] %p\n",PHY_vars_eNB->lte_eNB_pusch_vars[0]->rxdataF_comp[0][0]);
  printf("Setting mcs = %d\n",mcs);
  printf("n_frames = %d\n",	n_frames);

knopp's avatar
   
knopp committed
493
  snr1 = snr0+snr_int;
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
  printf("SNR0 %f, SNR1 %f\n",snr0,snr1);

  /*
    txdataF    = (int **)malloc16(2*sizeof(int*));
    txdataF[0] = (int *)malloc16(FRAME_LENGTH_BYTES);
    txdataF[1] = (int *)malloc16(FRAME_LENGTH_BYTES);
  
    txdata    = (int **)malloc16(2*sizeof(int*));
    txdata[0] = (int *)malloc16(FRAME_LENGTH_BYTES);
    txdata[1] = (int *)malloc16(FRAME_LENGTH_BYTES);
  */

  frame_parms = &PHY_vars_eNB->lte_frame_parms;

  txdata = PHY_vars_UE->lte_ue_common_vars.txdata;

  
  s_re = malloc(2*sizeof(double*));
  s_im = malloc(2*sizeof(double*));
  r_re = malloc(2*sizeof(double*));
  r_im = malloc(2*sizeof(double*));
  //  r_re0 = malloc(2*sizeof(double*));
  //  r_im0 = malloc(2*sizeof(double*));

  nsymb = (PHY_vars_eNB->lte_frame_parms.Ncp == 0) ? 14 : 12;
  
  coded_bits_per_codeword = nb_rb * (12 * get_Qm(mcs)) * nsymb;

  rate = (double)dlsch_tbs25[get_I_TBS(mcs)][nb_rb-1]/(coded_bits_per_codeword);

  printf("Rate = %f (mod %d), coded bits %d\n",rate,get_Qm(mcs),coded_bits_per_codeword);
  
526
  sprintf(bler_fname,"ULbler_mcs%d_nrb%d_ChannelModel%d_nsim%d.csv",mcs,nb_rb,chMod,n_frames);
527
  bler_fd = fopen(bler_fname,"w");
528
529
 
  fprintf(bler_fd,"#SNR;mcs;nb_rb;TBS;rate;errors[0];trials[0];errors[1];trials[1];errors[2];trials[2];errors[3];trials[3]\n");
530
531

  if (test_perf != 0) {
532
533
534
535
    char hostname[1024];
    hostname[1023] = '\0';
    gethostname(hostname, 1023);
    printf("Hostname: %s\n", hostname);
thomasl's avatar
   
thomasl committed
536
537
538
539
540
    char dirname[FILENAME_MAX];
    sprintf(dirname, "%s//SIMU/USER/pre-ci-logs-%s", getenv("OPENAIR_TARGETS"),hostname);
    mkdir(dirname, 0777);
    sprintf(time_meas_fname,"%s/time_meas_prb%d_mcs%d_antrx%d_channel%s_tx%d.csv",
	    dirname,
541
542
543
	    N_RB_DL,mcs,n_rx,channel_model_input,transmission_mode);
    time_meas_fd = fopen(time_meas_fname,"w");
  }
544
	
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
  if(abstx){
    sprintf(fperen_name,"ULchan_estims_F_mcs%d_rb%d_chanMod%d_nframes%d_chanReal%d.m",mcs,nb_rb,chMod,n_frames,n_ch_rlz);
    fperen = fopen(fperen_name,"a+");
    fprintf(fperen,"chest_f = [");
    fclose(fperen); 
  
    sprintf(fmageren_name,"ChanMag_F_mcs%d_rb%d_chanMod%d_nframes%d_chanReal%d.m",mcs,nb_rb,chMod,n_frames,n_ch_rlz);
    fmageren = fopen(fmageren_name,"a+");
    fprintf(fmageren,"mag_f = [");
    fclose(fmageren); 
  
    sprintf(flogeren_name,"Log2Max_mcs%d_rb%d_chanMod%d_nframes%d_chanReal%d.m",mcs,nb_rb,chMod,n_frames,n_ch_rlz);
    flogeren = fopen(flogeren_name,"a+");
    fprintf(flogeren,"mag_f = [");
    fclose(flogeren); 
  }
  /*
    sprintf(ftxlev_name,"txlevel_mcs%d_rb%d_chanMod%d_nframes%d_chanReal%d.m",mcs,nb_rb,chMod,n_frames,n_ch_rlz);
    ftxlev = fopen(ftxlev_name,"a+");
    fprintf(ftxlev,"txlev = [");
    fclose(ftexlv); 
  */
  
  if(abstx){
    // CSV file 
    sprintf(csv_fname,"EULdataout_tx%d_mcs%d_nbrb%d_chan%d_nsimus%d_eren.m",transmission_mode,mcs,nb_rb,chMod,n_frames);
    csv_fdUL = fopen(csv_fname,"w");
    fprintf(csv_fdUL,"data_all%d=[",mcs);
  }
574

575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
  for (i=0;i<2;i++) {
    s_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
    s_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
    r_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
    r_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
    //    r_re0[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
    //    bzero(r_re0[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
    //    r_im0[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
    //    bzero(r_im0[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
  }


#ifdef XFORMS
  fl_initialize (&argc, argv, NULL, 0, 0);
  form_enb = create_lte_phy_scope_enb();
  sprintf (title, "LTE PHY SCOPE eNB");
  fl_show_form (form_enb->lte_phy_scope_enb, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);  
#endif

  PHY_vars_UE->lte_ue_pdcch_vars[0]->crnti = 14;

  PHY_vars_UE->lte_frame_parms.soundingrs_ul_config_common.srs_BandwidthConfig = 2;
  PHY_vars_UE->lte_frame_parms.soundingrs_ul_config_common.srs_SubframeConfig = 7;
  PHY_vars_UE->soundingrs_ul_config_dedicated[eNB_id].srs_Bandwidth = 0;
  PHY_vars_UE->soundingrs_ul_config_dedicated[eNB_id].transmissionComb = 0;
  PHY_vars_UE->soundingrs_ul_config_dedicated[eNB_id].freqDomainPosition = 0;

  PHY_vars_eNB->lte_frame_parms.soundingrs_ul_config_common.srs_BandwidthConfig = 2;
  PHY_vars_eNB->lte_frame_parms.soundingrs_ul_config_common.srs_SubframeConfig = 7;

  PHY_vars_eNB->soundingrs_ul_config_dedicated[UE_id].srs_ConfigIndex = 1;
  PHY_vars_eNB->soundingrs_ul_config_dedicated[UE_id].srs_Bandwidth = 0;
  PHY_vars_eNB->soundingrs_ul_config_dedicated[UE_id].transmissionComb = 0;
  PHY_vars_eNB->soundingrs_ul_config_dedicated[UE_id].freqDomainPosition = 0;
  PHY_vars_eNB->cooperation_flag = cooperation_flag;
  //  PHY_vars_eNB->eNB_UE_stats[0].SRS_parameters = PHY_vars_UE->SRS_parameters;

  PHY_vars_eNB->pusch_config_dedicated[UE_id].betaOffset_ACK_Index = beta_ACK;
  PHY_vars_eNB->pusch_config_dedicated[UE_id].betaOffset_RI_Index  = beta_RI;
  PHY_vars_eNB->pusch_config_dedicated[UE_id].betaOffset_CQI_Index = beta_CQI;
  PHY_vars_UE->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index = beta_ACK;
  PHY_vars_UE->pusch_config_dedicated[eNB_id].betaOffset_RI_Index  = beta_RI;
  PHY_vars_UE->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index = beta_CQI;
Florian Kaltenberger's avatar
Florian Kaltenberger committed
618
619

  PHY_vars_UE->ul_power_control_dedicated[eNB_id].deltaMCS_Enabled = 1;
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
  
  printf("PUSCH Beta : ACK %f, RI %f, CQI %f\n",(double)beta_ack[beta_ACK]/8,(double)beta_ri[beta_RI]/8,(double)beta_cqi[beta_CQI]/8);

  UE2eNB = new_channel_desc_scm(PHY_vars_eNB->lte_frame_parms.nb_antennas_tx,
                                PHY_vars_UE->lte_frame_parms.nb_antennas_rx,
                                channel_model,
                                BW,
                                forgetting_factor,
                                delay,
                                0);
  // set Doppler
  UE2eNB->max_Doppler = maxDoppler;

  // NN: N_RB_UL has to be defined in ulsim
  PHY_vars_eNB->ulsch_eNB[0] = new_eNB_ulsch(8,max_turbo_iterations,N_RB_DL,0);
  PHY_vars_UE->ulsch_ue[0]   = new_ue_ulsch(8,N_RB_DL,0);
636
  
637
638
  // Create transport channel structures for 2 transport blocks (MIMO)
  for (i=0;i<2;i++) {
639
640
    PHY_vars_eNB->dlsch_eNB[0][i] = new_eNB_dlsch(1,8,N_RB_DL,0);
    PHY_vars_UE->dlsch_ue[0][i]  = new_ue_dlsch(1,8,MAX_TURBO_ITERATIONS,N_RB_DL,0);
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
  
    if (!PHY_vars_eNB->dlsch_eNB[0][i]) {
      printf("Can't get eNB dlsch structures\n");
      exit(-1);
    }
    
    if (!PHY_vars_UE->dlsch_ue[0][i]) {
      printf("Can't get ue dlsch structures\n");
      exit(-1);
    }
    
    PHY_vars_eNB->dlsch_eNB[0][i]->rnti = 14;
    PHY_vars_UE->dlsch_ue[0][i]->rnti   = 14;

  }
656
  
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675

  switch (PHY_vars_eNB->lte_frame_parms.N_RB_UL) {
  case 6:
    break;
  case 25:
    if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->type    = 0;
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->rballoc = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,PHY_vars_eNB->lte_frame_parms.N_RB_UL,((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->rballoc,*(uint32_t *)&UL_alloc_pdu);
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->mcs     = mcs;
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->ndi     = 1;
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->TPC     = 0;
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->cqi_req = cqi_flag&1;
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->cshift  = 0;
      ((DCI0_5MHz_TDD_1_6_t*)&UL_alloc_pdu)->dai     = 1;
    }
    else {
      ((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->type    = 0;
      ((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->rballoc = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
gauthier's avatar
gauthier committed
676
      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,PHY_vars_eNB->lte_frame_parms.N_RB_UL,((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->rballoc,*(uint32_t *)&UL_alloc_pdu);
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
      ((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->mcs     = mcs;
      ((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->ndi     = 1;
      ((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->TPC     = 0;
      ((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->cqi_req = cqi_flag&1;
      ((DCI0_5MHz_FDD_t*)&UL_alloc_pdu)->cshift  = 0;
    }
    break;
  case 50:
    if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->type    = 0;
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->rballoc = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,PHY_vars_eNB->lte_frame_parms.N_RB_UL,((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->rballoc,*(uint32_t *)&UL_alloc_pdu);
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->mcs     = mcs;
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->ndi     = 1;
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->TPC     = 0;
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->cqi_req = cqi_flag&1;
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->cshift  = 0;
      ((DCI0_10MHz_TDD_1_6_t*)&UL_alloc_pdu)->dai     = 1;
    }
    else {
      ((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->type    = 0;
      ((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->rballoc = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
gauthier's avatar
gauthier committed
699
      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,PHY_vars_eNB->lte_frame_parms.N_RB_UL,((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->rballoc,*(uint32_t *)&UL_alloc_pdu);
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
      ((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->mcs     = mcs;
      ((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->ndi     = 1;
      ((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->TPC     = 0;
      ((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->cqi_req = cqi_flag&1;
      ((DCI0_10MHz_FDD_t*)&UL_alloc_pdu)->cshift  = 0;
    }
    break;
  case 100:
    if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->type    = 0;
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->rballoc = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,PHY_vars_eNB->lte_frame_parms.N_RB_UL,((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->rballoc,*(uint32_t *)&UL_alloc_pdu);
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->mcs     = mcs;
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->ndi     = 1;
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->TPC     = 0;
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->cqi_req = cqi_flag&1;
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->cshift  = 0;
      ((DCI0_20MHz_TDD_1_6_t*)&UL_alloc_pdu)->dai     = 1;
    }
    else {
      ((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->type    = 0;
      ((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->rballoc = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_UL,first_rb,nb_rb);// 12 RBs from position 8
gauthier's avatar
gauthier committed
722
      printf("nb_rb %d/%d, rballoc %d (dci %x)\n",nb_rb,PHY_vars_eNB->lte_frame_parms.N_RB_UL,((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->rballoc,*(uint32_t *)&UL_alloc_pdu);
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
      ((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->mcs     = mcs;
      ((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->ndi     = 1;
      ((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->TPC     = 0;
      ((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->cqi_req = cqi_flag&1;
      ((DCI0_20MHz_FDD_t*)&UL_alloc_pdu)->cshift  = 0;
    }
    break;
  default:
    break;
  }


  PHY_vars_UE->PHY_measurements.rank[0] = 0;
  PHY_vars_UE->transmission_mode[0] = 2;
  PHY_vars_UE->pucch_config_dedicated[0].tdd_AckNackFeedbackMode = bundling_flag == 1 ? bundling : multiplexing;
  PHY_vars_eNB->transmission_mode[0] = 2;
  PHY_vars_eNB->pucch_config_dedicated[0].tdd_AckNackFeedbackMode = bundling_flag == 1 ? bundling : multiplexing;
  PHY_vars_UE->lte_frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 1;
  PHY_vars_eNB->lte_frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = 1;
  PHY_vars_UE->lte_frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 0;
  PHY_vars_eNB->lte_frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = 0;
  PHY_vars_UE->lte_frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = 0;
  PHY_vars_eNB->lte_frame_parms.pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = 0;
knopp's avatar
   
knopp committed
746
  PHY_vars_UE->frame_tx=1;
knopp's avatar
   
knopp committed
747

knopp's avatar
   
knopp committed
748
749
750
751
752
753
  for (sf=0;sf<10;sf++) { 
    PHY_vars_eNB->proc[sf].frame_tx=1; 
    PHY_vars_eNB->proc[sf].subframe_tx=sf;
    PHY_vars_eNB->proc[sf].frame_rx=1;
    PHY_vars_eNB->proc[sf].subframe_rx=sf;
  }
knopp's avatar
   
knopp committed
754

755
756
757
758
759
  msg("Init UL hopping UE\n");
  init_ul_hopping(&PHY_vars_UE->lte_frame_parms);
  msg("Init UL hopping eNB\n");
  init_ul_hopping(&PHY_vars_eNB->lte_frame_parms);

knopp's avatar
   
knopp committed
760
  PHY_vars_eNB->proc[subframe].frame_rx = PHY_vars_UE->frame_tx;
knopp's avatar
   
knopp committed
761
  if (ul_subframe2pdcch_alloc_subframe(&PHY_vars_eNB->lte_frame_parms,subframe) > subframe) // allocation was in previous frame
knopp's avatar
   
knopp committed
762
    PHY_vars_eNB->proc[ul_subframe2pdcch_alloc_subframe(&PHY_vars_eNB->lte_frame_parms,subframe)].frame_tx = (PHY_vars_UE->frame_tx-1)&1023;
knopp's avatar
   
knopp committed
763

764
765
766
  PHY_vars_UE->dlsch_ue[0][0]->harq_ack[ul_subframe2pdcch_alloc_subframe(&PHY_vars_eNB->lte_frame_parms,subframe)].send_harq_status = 1;


knopp's avatar
   
knopp committed
767
  //  printf("UE frame %d, eNB frame %d (eNB frame_tx %d)\n",PHY_vars_UE->frame,PHY_vars_eNB->proc[subframe].frame_rx,PHY_vars_eNB->proc[ul_subframe2pdcch_alloc_subframe(&PHY_vars_eNB->lte_frame_parms,subframe)].frame_tx);
knopp's avatar
   
knopp committed
768
  PHY_vars_UE->frame_tx = (PHY_vars_UE->frame_tx-1)&1023;
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797

  generate_ue_ulsch_params_from_dci((void *)&UL_alloc_pdu,
				    14,
				    ul_subframe2pdcch_alloc_subframe(&PHY_vars_UE->lte_frame_parms,subframe),
				    format0,
				    PHY_vars_UE,
				    SI_RNTI,
				    0,
				    P_RNTI,
				    CBA_RNTI,
				    0,
				    srs_flag);

  //  printf("RIV %d\n",UL_alloc_pdu.rballoc);

  generate_eNB_ulsch_params_from_dci((void *)&UL_alloc_pdu,
				     14,
				     ul_subframe2pdcch_alloc_subframe(&PHY_vars_eNB->lte_frame_parms,subframe),
				     format0,
				     0,
				     PHY_vars_eNB,
				     SI_RNTI,
				     0,
				     P_RNTI,
				     CBA_RNTI,
				     srs_flag);



knopp's avatar
   
knopp committed
798
  PHY_vars_UE->frame_tx = (PHY_vars_UE->frame_tx+1)&1023;
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
  
  
  for (ch_realization=0;ch_realization<n_ch_rlz;ch_realization++){
 
    /*
      if(abstx){
      int ulchestim_f[300*12];
      int ulchestim_t[2*(frame_parms->ofdm_symbol_size)];
      }
    */
	 
    if(abstx){
      printf("**********************Channel Realization Index = %d **************************\n", ch_realization);
      saving_bler=1;
    }
	

knopp's avatar
   
knopp committed
816
817
    //    if ((subframe>5) || (subframe < 4))
    //      PHY_vars_UE->frame++;
818
 
knopp's avatar
   
knopp committed
819
    for (SNR=snr0;SNR<snr1;SNR+=input_snr_step) {
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
      errs[0]=0;
      errs[1]=0;
      errs[2]=0;
      errs[3]=0;
      round_trials[0] = 0;
      round_trials[1] = 0;
      round_trials[2] = 0;
      round_trials[3] = 0;
      cqi_errors=0;
      ack_errors=0;
      cqi_crc_falsepositives=0;
      cqi_crc_falsenegatives=0;
      round=0;
	
      //randominit(0);

knopp's avatar
   
knopp committed
836

knopp's avatar
   
knopp committed
837
      harq_pid = subframe2harq_pid(&PHY_vars_UE->lte_frame_parms,PHY_vars_UE->frame_tx,subframe);
knopp's avatar
   
knopp committed
838
      //      printf("UL frame %d/subframe %d, harq_pid %d\n",PHY_vars_UE->frame,subframe,harq_pid);
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
      if (input_fdUL == NULL) {
	input_buffer_length = PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->TBS/8;
	input_buffer = (unsigned char *)malloc(input_buffer_length+4);

	if (n_frames == 1) {
	  trch_out_fdUL= fopen("ulsch_trchUL.txt","w");
	  for (i=0;i<input_buffer_length;i++) {
	    input_buffer[i] = taus()&0xff;
	    for (j=0;j<8;j++)
	      fprintf(trch_out_fdUL,"%d\n",(input_buffer[i]>>(7-j))&1);
	  }
	  fclose(trch_out_fdUL);
	}
	else {
	  for (i=0;i<input_buffer_length;i++)
	    input_buffer[i] = taus()&0xff;
	}
      }
      else {
	n_frames=1;
	i=0;
	while (!feof(input_fdUL)) {
	  fscanf(input_fdUL,"%s %s",input_val_str,input_val_str2);//&input_val1,&input_val2);
	
	  if ((i%4)==0) {
	    ((short*)txdata[0])[i/2] = (short)((1<<15)*strtod(input_val_str,NULL));
	    ((short*)txdata[0])[(i/2)+1] = (short)((1<<15)*strtod(input_val_str2,NULL));
	    if ((i/4)<100)
	      printf("sample %d => %e + j%e (%d +j%d)\n",i/4,strtod(input_val_str,NULL),strtod(input_val_str2,NULL),((short*)txdata[0])[i/4],((short*)txdata[0])[(i/4)+1]);//1,input_val2,);
	  }
	  i++;
	  if (i>(FRAME_LENGTH_SAMPLES))
	    break;
	}
	printf("Read in %d samples\n",i/4);
	//      write_output("txsig0UL.m","txs0", txdata[0],2*frame_parms->samples_per_tti,1,1);
	//    write_output("txsig1.m","txs1", txdata[1],FRAME_LENGTH_COMPLEX_SAMPLES,1,1);
	tx_lev = signal_energy(&txdata[0][0],
			       OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES);
	tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
      
      }

      avg_iter = 0; iter_trials=0;
883
      reset_meas(&PHY_vars_UE->phy_proc_tx);
884
885
886
887
888
889
890
891
      reset_meas(&PHY_vars_UE->ofdm_mod_stats);
      reset_meas(&PHY_vars_UE->ulsch_modulation_stats);
      reset_meas(&PHY_vars_UE->ulsch_encoding_stats);
      reset_meas(&PHY_vars_UE->ulsch_interleaving_stats);
      reset_meas(&PHY_vars_UE->ulsch_rate_matching_stats);
      reset_meas(&PHY_vars_UE->ulsch_turbo_encoding_stats);
      reset_meas(&PHY_vars_UE->ulsch_segmentation_stats);
      reset_meas(&PHY_vars_UE->ulsch_multiplexing_stats);
892
893
      
      reset_meas(&PHY_vars_eNB->phy_proc_rx);
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
      reset_meas(&PHY_vars_eNB->ofdm_demod_stats);
      reset_meas(&PHY_vars_eNB->ulsch_channel_estimation_stats);
      reset_meas(&PHY_vars_eNB->ulsch_freq_offset_estimation_stats);
      reset_meas(&PHY_vars_eNB->rx_dft_stats);
      reset_meas(&PHY_vars_eNB->ulsch_decoding_stats);
      reset_meas(&PHY_vars_eNB->ulsch_turbo_decoding_stats);
      reset_meas(&PHY_vars_eNB->ulsch_deinterleaving_stats);
      reset_meas(&PHY_vars_eNB->ulsch_demultiplexing_stats);
      reset_meas(&PHY_vars_eNB->ulsch_rate_unmatching_stats);
      reset_meas(&PHY_vars_eNB->ulsch_tc_init_stats);    
      reset_meas(&PHY_vars_eNB->ulsch_tc_alpha_stats);
      reset_meas(&PHY_vars_eNB->ulsch_tc_beta_stats);
      reset_meas(&PHY_vars_eNB->ulsch_tc_gamma_stats);
      reset_meas(&PHY_vars_eNB->ulsch_tc_ext_stats);
      reset_meas(&PHY_vars_eNB->ulsch_tc_intl1_stats);
      reset_meas(&PHY_vars_eNB->ulsch_tc_intl2_stats);

911
912
913
      // initialization
      struct list time_vector_tx;
      initialize(&time_vector_tx);
914
915
916
917
918
919
920
      struct list time_vector_tx_ifft;
      initialize(&time_vector_tx_ifft);
      struct list time_vector_tx_mod;
      initialize(&time_vector_tx_mod);
      struct list time_vector_tx_enc;
      initialize(&time_vector_tx_enc);

921
922
      struct list time_vector_rx;
      initialize(&time_vector_rx);
923
924
925
926
927
928
      struct list time_vector_rx_fft;
      initialize(&time_vector_rx_fft);
      struct list time_vector_rx_demod;
      initialize(&time_vector_rx_demod);
      struct list time_vector_rx_dec;
      initialize(&time_vector_rx_dec);
929
      
930
931
932
933
934
935
936
937
      for (trials = 0;trials<n_frames;trials++) {
	//      printf("*");
	//        PHY_vars_UE->frame++;
	//        PHY_vars_eNB->frame++;
      
	fflush(stdout);
	round=0;
	while (round < 4) {
knopp's avatar
   
knopp committed
938
939
	  PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->round=round;
	  PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->round=round;
940
941
942
	  //	printf("Trial %d : Round %d ",trials,round);
	  round_trials[round]++;
	  if (round == 0) {
943
	    //PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->Ndi = 1;
944
	    PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->rvidx = round>>1;
945
	    //PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->Ndi = 1;
946
947
948
	    PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->rvidx = round>>1;
	  }
	  else {
949
	    //PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->Ndi = 0;
950
	    PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->rvidx = round>>1;
951
	    //PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->Ndi = 0;
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
	    PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->rvidx = round>>1;
	  }
	
	
	  /////////////////////
	  if (abstx) {
	    if (trials==0 && round==0 && SNR==snr0){  //generate a new channel
	      hold_channel = 0;
	      flagMag=0;
	    }
	    else{
	      hold_channel = 1;
	      flagMag = 1;
	    }
	  }
	  else
	    {
	      hold_channel = 0;
	      flagMag=1;
	    }
	  ///////////////////////////////////////
	
	  if (input_fdUL == NULL) {
975
976
977

	    start_meas(&PHY_vars_UE->phy_proc_tx);

978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
#ifdef OFDMA_ULSCH
	    if (srs_flag)
	      generate_srs_tx(PHY_vars_UE,0,AMP,subframe);
	    generate_drs_pusch(PHY_vars_UE,0,AMP,subframe,first_rb,nb_rb,0);
	  
#else
	    if (srs_flag)
	      generate_srs_tx(PHY_vars_UE,0,AMP,subframe);
	    generate_drs_pusch(PHY_vars_UE,0,
			       AMP,subframe,
			       PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->first_rb,
			       PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->nb_rb,
			       0);
#endif	

	    if ((cqi_flag == 1) && (n_frames == 1) ) {
	      printf("CQI information (O %d) %d %d\n",PHY_vars_UE->ulsch_ue[0]->O,
		     PHY_vars_UE->ulsch_ue[0]->o[0],PHY_vars_UE->ulsch_ue[0]->o[1]);
knopp's avatar
   
knopp committed
996
	      print_CQI(PHY_vars_UE->ulsch_ue[0]->o,PHY_vars_UE->ulsch_ue[0]->uci_format,PHY_vars_UE->lte_frame_parms.N_RB_DL,0);
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
	    }

	    PHY_vars_UE->ulsch_ue[0]->o_ACK[0] = taus()&1;

	    start_meas(&PHY_vars_UE->ulsch_encoding_stats);	      
	    if (ulsch_encoding(input_buffer,
			       PHY_vars_UE,
			       harq_pid,
			       eNB_id,
			       2, // transmission mode
			       control_only_flag,
			       1// Nbundled
			       )==-1) {
	      printf("ulsim.c Problem with ulsch_encoding\n");
	      exit(-1);
	    }
	    stop_meas(&PHY_vars_UE->ulsch_encoding_stats);

	    start_meas(&PHY_vars_UE->ulsch_modulation_stats);	      	      	  
#ifdef OFDMA_ULSCH
	    ulsch_modulation(PHY_vars_UE->lte_ue_common_vars.txdataF,AMP,
knopp's avatar
   
knopp committed
1018
			     PHY_vars_UE->frame_tx,subframe,&PHY_vars_UE->lte_frame_parms,PHY_vars_UE->ulsch_ue[0]);
1019
1020
1021
#else  
	    //	  printf("Generating PUSCH in subframe %d with amp %d, nb_rb %d\n",subframe,AMP,nb_rb);
	    ulsch_modulation(PHY_vars_UE->lte_ue_common_vars.txdataF,AMP,
knopp's avatar
   
knopp committed
1022
			     PHY_vars_UE->frame_tx,subframe,&PHY_vars_UE->lte_frame_parms,
1023
1024
1025
			     PHY_vars_UE->ulsch_ue[0]);
#endif
	    stop_meas(&PHY_vars_UE->ulsch_modulation_stats);	      	      	  
1026
	    
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
	    if (n_frames==1) {
	      write_output("txsigF0UL.m","txsF0", &PHY_vars_UE->lte_ue_common_vars.txdataF[0][PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size*nsymb*subframe],PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size*nsymb,1,1);
	      //write_output("txsigF1.m","txsF1", PHY_vars_UE->lte_ue_common_vars.txdataF[0],FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX,1,1);          
	    }
	    tx_lev=0;
	    start_meas(&PHY_vars_UE->ofdm_mod_stats);	      	      	  
	    for (aa=0; aa<1; aa++) {
	      if (frame_parms->Ncp == 1) 
		PHY_ofdm_mod(&PHY_vars_UE->lte_ue_common_vars.txdataF[aa][subframe*nsymb*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES_NO_PREFIX],        // input
			     &txdata[aa][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],         // output
			     PHY_vars_UE->lte_frame_parms.log2_symbol_size,                // log2_fft_size
			     nsymb,                 // number of symbols
			     PHY_vars_UE->lte_frame_parms.nb_prefix_samples,               // number of prefix samples
			     PHY_vars_UE->lte_frame_parms.twiddle_ifft,  // IFFT twiddle factors
			     PHY_vars_UE->lte_frame_parms.rev,           // bit-reversal permutation
			     CYCLIC_PREFIX);
	      else
		normal_prefix_mod(&PHY_vars_UE->lte_ue_common_vars.txdataF[aa][subframe*nsymb*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES_NO_PREFIX],
				  &txdata[aa][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],
				  nsymb,
				  frame_parms);
	    
#ifndef OFDMA_ULSCH
	      apply_7_5_kHz(PHY_vars_UE,PHY_vars_UE->lte_ue_common_vars.txdata[aa],subframe<<1);
	      apply_7_5_kHz(PHY_vars_UE,PHY_vars_UE->lte_ue_common_vars.txdata[aa],1+(subframe<<1));
#endif
	    
	      stop_meas(&PHY_vars_UE->ofdm_mod_stats);	      	      
1055
	      stop_meas(&PHY_vars_UE->phy_proc_tx); 
1056
1057
1058
1059
1060
1061
1062
	      tx_lev += signal_energy(&txdata[aa][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],
				      PHY_vars_eNB->lte_frame_parms.samples_per_tti);
	
	    }
	  }  // input_fd == NULL 


knopp's avatar
   
knopp committed
1063
	  tx_lev_dB = (unsigned int) dB_fixed_times10(tx_lev);
1064
1065
1066
1067
1068
1069
	
	  if (n_frames==1) {	
	    write_output("txsig0UL.m","txs0", &txdata[0][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],2*frame_parms->samples_per_tti,1,1);
	    //        write_output("txsig1UL.m","txs1", &txdata[1][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],2*frame_parms->samples_per_tti,1,1);
	  }
		
1070
	  //AWGN
1071
1072
	  //Set target wideband RX noise level to N0
	  sigma2_dB = N0;//10*log10((double)tx_lev)  +10*log10(PHY_vars_UE->lte_frame_parms.ofdm_symbol_size/(PHY_vars_UE->lte_frame_parms.N_RB_DL*12)) - SNR;
1073
1074
	  sigma2 = pow(10,sigma2_dB/10);

1075
	  // compute tx_gain to achieve target SNR (per resource element!)
1076
	  tx_gain = sqrt(pow(10.0,.1*(N0+SNR))*(nb_rb*12/(double)PHY_vars_UE->lte_frame_parms.ofdm_symbol_size)/(double)tx_lev);
knopp's avatar
   
knopp committed
1077
1078
	  if (n_frames==1)
	    printf("tx_lev = %d (%d.%d dB,%f), gain %f\n",tx_lev,tx_lev_dB/10,tx_lev_dB,10*log10((double)tx_lev),10*log10(tx_gain));
1079
1080
  

1081
	  // fill measurement symbol (19) with noise      
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
	  for (i=0;i<OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES;i++) {
	    for (aa=0;aa<PHY_vars_eNB->lte_frame_parms.nb_antennas_rx;aa++) {
	    
	      ((short*) &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
	      ((short*) &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][aa][(frame_parms->samples_per_tti<<1) -frame_parms->ofdm_symbol_size])[2*i+1] = (short) ((sqrt(sigma2/2)*gaussdouble(0.0,1.0)));
	    }
	  }

	  // multipath channel
      
	  for (i=0;i<PHY_vars_eNB->lte_frame_parms.samples_per_tti;i++) {
	    for (aa=0;aa<1;aa++) {
	      s_re[aa][i] = ((double)(((short *)&txdata[aa][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe]))[(i<<1)]);
	      s_im[aa][i] = ((double)(((short *)&txdata[aa][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe]))[(i<<1)+1]);
	    }
	  }
      
    	  if (awgn_flag == 0) {	
	    if (UE2eNB->max_Doppler == 0) {
	      multipath_channel(UE2eNB,s_re,s_im,r_re,r_im,
				PHY_vars_eNB->lte_frame_parms.samples_per_tti,hold_channel);
	    } else {
	      multipath_tv_channel(UE2eNB,s_re,s_im,r_re,r_im,
				   2*PHY_vars_eNB->lte_frame_parms.samples_per_tti,hold_channel);
	    }
	  }
		  
	  if(abstx){
	    if(saving_bler==0)
	      if (trials==0 && round==0) {
		// calculate freq domain representation to compute SINR
		freq_channel(UE2eNB, N_RB_DL,12*N_RB_DL + 1);
	     
		// snr=pow(10.0,.1*SNR);
		fprintf(csv_fdUL,"%f,%d,%d,%f,%f,%f,",SNR,tx_lev,tx_lev_dB,sigma2_dB,tx_gain,SNR2);
		//fprintf(csv_fdUL,"%f,",SNR);
		for (u=0;u<12*nb_rb;u++){
		  for (aarx=0;aarx<UE2eNB->nb_rx;aarx++) {
		    for (aatx=0;aatx<UE2eNB->nb_tx;aatx++) {
		      // abs_channel = (eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].x*eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].x + eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].y*eNB2UE->chF[aarx+(aatx*eNB2UE->nb_rx)][u].y);
		      channelx = UE2eNB->chF[aarx+(aatx*UE2eNB->nb_rx)][u].x;
		      channely = UE2eNB->chF[aarx+(aatx*UE2eNB->nb_rx)][u].y;
		      // if(transmission_mode==5){
		      fprintf(csv_fdUL,"%e+i*(%e),",channelx,channely);
		      // }
		      // else{
		      //	pilot_sinr = 10*log10(snr*abs_channel);
		      //	fprintf(csv_fd,"%e,",pilot_sinr);
		      // }
		    }
		  }
		}
	      }
	  }
	
	  if (n_frames==1)
	    printf("Sigma2 %f (sigma2_dB %f), tx_gain %f (%f dB)\n",sigma2,sigma2_dB,tx_gain,20*log10(tx_gain));

	  for (i=0; i<PHY_vars_eNB->lte_frame_parms.samples_per_tti; i++) {
	    for (aa=0;aa<PHY_vars_eNB->lte_frame_parms.nb_antennas_rx;aa++) {
	      ((short*) &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][aa][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe])[2*i] = (short) ((tx_gain*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
	      ((short*) &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][aa][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe])[2*i+1] = (short) ((tx_gain*r_im[aa][i]) + (iqim*tx_gain*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
	    }
	  }    

	  if (n_frames==1) {
	    printf("rx_level Null symbol %f\n",10*log10((double)signal_energy((int*)&PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][(PHY_vars_eNB->lte_frame_parms.samples_per_tti<<1) -PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
	    printf("rx_level data symbol %f\n",10*log10(signal_energy((int*)&PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][160+(PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe)],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
	  }

	  SNRmeas = 10*log10(((double)signal_energy((int*)&PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][160+(PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe)],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2))/((double)signal_energy((int*)&PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][(PHY_vars_eNB->lte_frame_parms.samples_per_tti<<1) -PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)) - 1)+10*log10(PHY_vars_eNB->lte_frame_parms.N_RB_UL/nb_rb);
      
	  if (n_frames==1) {
	    printf("SNRmeas %f\n",SNRmeas);
      
	    //	  write_output("rxsig0UL.m","rxs0", &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1);
	    //write_output("rxsig1UL.m","rxs1", &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1);
	  }
#ifndef OFDMA_ULSCH
	  remove_7_5_kHz(PHY_vars_eNB,subframe<<1);
	  remove_7_5_kHz(PHY_vars_eNB,1+(subframe<<1));
	  //	write_output("rxsig0_75.m","rxs0_75", &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1);
	  //	write_output("rxsig1_75.m","rxs1_75", &PHY_vars_eNB->lte_eNB_common_vars.rxdata[0][0][PHY_vars_eNB->lte_frame_parms.samples_per_tti*subframe],PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1);

#endif      

1168
	  start_meas(&PHY_vars_eNB->phy_proc_rx);
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
	  start_meas(&PHY_vars_eNB->ofdm_demod_stats);	      	      	  
	  lte_eNB_I0_measurements(PHY_vars_eNB,
				  0,
				  1);

	  for (l=subframe*PHY_vars_UE->lte_frame_parms.symbols_per_tti;l<((1+subframe)*PHY_vars_UE->lte_frame_parms.symbols_per_tti);l++) {
	
	    slot_fep_ul(&PHY_vars_eNB->lte_frame_parms,
			&PHY_vars_eNB->lte_eNB_common_vars,
			l%(PHY_vars_eNB->lte_frame_parms.symbols_per_tti/2),
			l/(PHY_vars_eNB->lte_frame_parms.symbols_per_tti/2),
			0,
			0);
	  }
	  stop_meas(&PHY_vars_eNB->ofdm_demod_stats);	      
	      	  
	  PHY_vars_eNB->ulsch_eNB[0]->cyclicShift = cyclic_shift;// cyclic shift for DMRS
	  if(abstx){
	    namepointer_log2 = &flogeren_name;
	    namepointer_chMag = &fmageren_name;
	    //namepointer_txlev = &ftxlev;
	  }

	  start_meas(&PHY_vars_eNB->ulsch_demodulation_stats);	      	      	  
	  rx_ulsch(PHY_vars_eNB,
		   subframe,
		   0,  // this is the effective sector id
		   0,  // this is the UE_id
		   PHY_vars_eNB->ulsch_eNB,
		   cooperation_flag);
	  stop_meas(&PHY_vars_eNB->ulsch_demodulation_stats);	      	      	  
	
	  if(abstx){
	    namepointer_chMag = NULL;
	
	    if(trials==0 && round==0 && SNR==snr0)
	      {
		char* namepointer ;
		namepointer = &fperen_name;
		write_output(namepointer, "xxx" ,PHY_vars_eNB->lte_eNB_pusch_vars[0]->drs_ch_estimates[0][0],300,1,10);
		namepointer = NULL ;
		// flagMag = 1;
	      }
	  }
1213

1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
	  ///////
	
	  start_meas(&PHY_vars_eNB->ulsch_decoding_stats);
	  ret= ulsch_decoding(PHY_vars_eNB,
			      0, // UE_id
			      subframe,
			      control_only_flag,
			      1,  // Nbundled 
			      llr8_flag);
	  stop_meas(&PHY_vars_eNB->ulsch_decoding_stats);
1224
	  stop_meas(&PHY_vars_eNB->phy_proc_rx);
1225
1226
	  if (cqi_flag > 0) {
	    cqi_error = 0;
knopp's avatar
   
knopp committed
1227
	    if (PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->Or1 < 32) {
1228
1229
	      for (i=2;i<4;i++) {
		//	      	      printf("cqi %d : %d (%d)\n",i,PHY_vars_eNB->ulsch_eNB[0]->o[i],PHY_vars_UE->ulsch_ue[0]->o[i]);
knopp's avatar
   
knopp committed
1230
		if (PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->o[i] != PHY_vars_UE->ulsch_ue[0]->o[i])
1231
1232
1233
1234
1235
1236
1237
1238
		  cqi_error = 1;
	      }
	    }
	    else {

	    }
	    if (cqi_error == 1) {
	      cqi_errors++;
knopp's avatar
   
knopp committed
1239
	      if (PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->cqi_crc_status == 1)
1240
1241
1242
		cqi_crc_falsepositives++;
	    }
	    else {
knopp's avatar
   
knopp committed
1243
	      if (PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->cqi_crc_status == 0)
1244
1245
1246
		cqi_crc_falsenegatives++;
	    }
	  }
knopp's avatar
   
knopp committed
1247
	  if (PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->o_ACK[0] != PHY_vars_UE->ulsch_ue[0]->o_ACK[0])
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
	    ack_errors++;
	  //    msg("ulsch_coding: O[%d] %d\n",i,o_flip[i]);
      
	
	  if (ret <= PHY_vars_eNB->ulsch_eNB[0]->max_turbo_iterations) {

	    avg_iter += ret;
	    iter_trials++;

	    if (n_frames==1) {
knopp's avatar
   
knopp committed
1258
1259
1260
	      printf("No ULSCH errors found, o_ACK[0]= %d, cqi_crc_status=%d\n",PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->o_ACK[0],PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->cqi_crc_status);
	      if (PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->cqi_crc_status==1)
		print_CQI(PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->o,
knopp's avatar
   
knopp committed
1261
			  PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->uci_format,0,PHY_vars_eNB->lte_frame_parms.N_RB_DL);
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
	      dump_ulsch(PHY_vars_eNB,subframe,0);
	      exit(-1);
	    }
	    round=5;
	  }	
	  else {
	    avg_iter += ret-1;
	    iter_trials++;

	    errs[round]++;
	    if (n_frames==1) {
knopp's avatar
   
knopp committed
1273
	      printf("ULSCH errors found o_ACK[0]= %d\n",PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->o_ACK[0]);
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304

	      for (s=0;s<PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->C;s++) {
		if (s<PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->Cminus)
		  Kr = PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->Kminus;
		else
		  Kr = PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->Kplus;
	      
		Kr_bytes = Kr>>3;
	      
		printf("Decoded_output (Segment %d):\n",s);
		for (i=0;i<Kr_bytes;i++)
		  printf("%d : %x (%x)\n",i,PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->c[s][i],PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->c[s][i]^PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->c[s][i]);
	      }
	      dump_ulsch(PHY_vars_eNB,subframe,0);	    
	      exit(-1);
	    }
	    //	    printf("round %d errors %d/%d\n",round,errs[round],trials);
	    round++;
	
	    if (n_frames==1) {
	      printf("ULSCH in error in round %d\n",round);
	    }
	  }  // ulsch error
	} // round
          
	//      printf("\n");
	if ((errs[0]>=100) && (trials>(n_frames/2)))
	  break;
#ifdef XFORMS
	phy_scope_eNB(form_enb,PHY_vars_eNB,0);
#endif       
1305
        /*calculate the total processing time for each packet, get the max, min, and number of packets that exceed t>3000us*/
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
        
	    double t_tx = (double)PHY_vars_UE->phy_proc_tx.p_time/cpu_freq_GHz/1000.0;        
        double t_tx_ifft = (double)PHY_vars_UE->ofdm_mod_stats.p_time/cpu_freq_GHz/1000.0;        
        double t_tx_mod = (double)PHY_vars_UE->ulsch_modulation_stats.p_time/cpu_freq_GHz/1000.0;        
        double t_tx_enc = (double)PHY_vars_UE->ulsch_encoding_stats.p_time/cpu_freq_GHz/1000.0;        


        double t_rx = (double)PHY_vars_eNB->phy_proc_rx.p_time/cpu_freq_GHz/1000.0;        
        double t_rx_fft = (double)PHY_vars_eNB->ofdm_demod_stats.p_time/cpu_freq_GHz/1000.0;        
        double t_rx_demod = (double)PHY_vars_eNB->ulsch_demodulation_stats.p_time/cpu_freq_GHz/1000.0;        
        double t_rx_dec = (double)PHY_vars_eNB->ulsch_decoding_stats.p_time/cpu_freq_GHz/1000.0;    
            
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
        if (t_tx > t_tx_max)
            t_tx_max = t_tx;
        if (t_tx < t_tx_min)
            t_tx_min = t_tx;
        if (t_rx > t_rx_max)
            t_rx_max = t_rx;
        if (t_rx < t_rx_min)
            t_rx_min = t_rx;
        if (t_tx > 2000)
            n_tx_dropped++;
        if (t_rx > 2000)
            n_rx_dropped++;
        
        push_front(&time_vector_tx, t_tx);
1332
1333
1334
1335
        push_front(&time_vector_tx_ifft, t_tx_ifft);
        push_front(&time_vector_tx_mod, t_tx_mod);
        push_front(&time_vector_tx_enc, t_tx_enc);

1336
        push_front(&time_vector_rx, t_rx);
1337
1338
1339
1340
1341
        push_front(&time_vector_rx_fft, t_rx_fft);
        push_front(&time_vector_rx_demod, t_rx_demod);
        push_front(&time_vector_rx_dec, t_rx_dec);
        
        
1342
      }   //trials
1343
      
1344
1345
      double table_tx[time_vector_tx.size];
      totable(table_tx, &time_vector_tx);
1346
1347
1348
1349
1350
1351
1352
      double table_tx_ifft[time_vector_tx_ifft.size];
      totable(table_tx_ifft, &time_vector_tx_ifft);
      double table_tx_mod[time_vector_tx_mod.size];
      totable(table_tx_mod, &time_vector_tx_mod);
      double table_tx_enc[time_vector_tx_enc.size];
      totable(table_tx_enc, &time_vector_tx_enc);
      
1353
1354
      double table_rx[time_vector_rx.size];
      totable(table_rx, &time_vector_rx);
1355
1356
1357
1358
1359
1360
      double table_rx_fft[time_vector_rx_fft.size];
      totable(table_rx_fft, &time_vector_rx_fft);
      double table_rx_demod[time_vector_rx_demod.size];
      totable(table_rx_demod, &time_vector_rx_demod);
      double table_rx_dec[time_vector_rx_dec.size];
      totable(table_rx_dec, &time_vector_rx_dec);               
1361
1362
1363
1364
      
      // sort table
      qsort (table_tx, time_vector_tx.size, sizeof(double), &compare);
      qsort (table_rx, time_vector_rx.size, sizeof(double), &compare);
nikaeinn's avatar
nikaeinn committed
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
      if (dump_table == 1 ) {
	int n;
	set_component_filelog(USIM); // file located in /tmp/usim.txt
	LOG_F(USIM,"The transmitter raw data: \n");
	for (n=0; n< time_vector_tx.size; n++){
	  //   printf("%f ", table_tx[n]);
	  LOG_F(USIM,"%f ", table_tx[n]);
	}
	LOG_F(USIM,"\n");
	LOG_F(USIM,"The receiver raw data: \n");
	for (n=0; n< time_vector_rx.size; n++){
	  // printf("%f ", table_rx[n]);
	  LOG_F(USIM,"%f ", table_rx[n]);
	}
     	LOG_F(USIM,"\n");
      }       
1381
      
1382
1383
1384
      double tx_median = table_tx[time_vector_tx.size/2];
      double tx_q1 = table_tx[time_vector_tx.size/4];
      double tx_q3 = table_tx[3*time_vector_tx.size/4];
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
     
      double tx_ifft_median = table_tx_ifft[time_vector_tx_ifft.size/2];
      double tx_ifft_q1 = table_tx_ifft[time_vector_tx_ifft.size/4];
      double tx_ifft_q3 = table_tx_ifft[3*time_vector_tx_ifft.size/4];

      double tx_mod_median = table_tx_mod[time_vector_tx_mod.size/2];
      double tx_mod_q1 = table_tx_mod[time_vector_tx_mod.size/4];
      double tx_mod_q3 = table_tx_mod[3*time_vector_tx_mod.size/4];

      double tx_enc_median = table_tx_enc[time_vector_tx_enc.size/2];
      double tx_enc_q1 = table_tx_enc[time_vector_tx_enc.size/4];
      double tx_enc_q3 = table_tx_enc[3*time_vector_tx_enc.size/4];

1398
1399
1400
      double rx_median = table_rx[time_vector_rx.size/2];
      double rx_q1 = table_rx[time_vector_rx.size/4];
      double rx_q3 = table_rx[3*time_vector_rx.size/4];
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413

      double rx_fft_median = table_rx_fft[time_vector_rx_fft.size/2];
      double rx_fft_q1 = table_rx_fft[time_vector_rx_fft.size/4];
      double rx_fft_q3 = table_rx_fft[3*time_vector_rx_fft.size/4];

      double rx_demod_median = table_rx_demod[time_vector_rx_demod.size/2];
      double rx_demod_q1 = table_rx_demod[time_vector_rx_demod.size/4];
      double rx_demod_q3 = table_rx_demod[3*time_vector_rx_demod.size/4];

      double rx_dec_median = table_rx_dec[time_vector_rx_dec.size/2];
      double rx_dec_q1 = table_rx_dec[time_vector_rx_dec.size/4];
      double rx_dec_q3 = table_rx_dec[3*time_vector_rx_dec.size/4];

1414
      double std_phy_proc_tx=0;
1415
1416
1417
1418
      double std_phy_proc_tx_ifft=0;
      double std_phy_proc_tx_mod=0;
      double std_phy_proc_tx_enc=0;

1419
      double std_phy_proc_rx=0;
1420
1421
1422
1423
      double std_phy_proc_rx_fft=0;
      double std_phy_proc_rx_demod=0;
      double std_phy_proc_rx_dec=0;
      
Florian Kaltenberger's avatar
Florian Kaltenberger committed
1424
      printf("\n**********rb: %d ***mcs : %d  *********SNR = %f dB (%f): TX %d dB (gain %f dB), N0W %f dB, I0 %d dB, delta_IF %d [ (%d,%d) dB / (%d,%d) dB ]**************************\n",
1425
1426
1427
1428
1429
	     nb_rb,mcs,SNR,SNR2,
	     tx_lev_dB,
	     20*log10(tx_gain),
	     (double)N0,
	     PHY_vars_eNB->PHY_measurements_eNB[0].n0_power_tot_dB,
Florian Kaltenberger's avatar
Florian Kaltenberger committed
1430
	     get_hundred_times_delta_IF(PHY_vars_UE,eNB_id,harq_pid) ,
1431
1432
1433
1434
	     dB_fixed(PHY_vars_eNB->lte_eNB_pusch_vars[0]->ulsch_power[0]),
	     dB_fixed(PHY_vars_eNB->lte_eNB_pusch_vars[0]->ulsch_power[1]),
	     PHY_vars_eNB->PHY_measurements_eNB->n0_power_dB[0],
	     PHY_vars_eNB->PHY_measurements_eNB->n0_power_dB[1]);
1435
1436
1437

      effective_rate = ((double)(round_trials[0])/((double)round_trials[0] + round_trials[1] + round_trials[2] + round_trials[3]));
  
1438
      printf("Errors (%d/%d %d/%d %d/%d %d/%d), Pe = (%e,%e,%e,%e) => effective rate %f (%3.1f%%,%f,%f), normalized delay %f (%f)\n",
1439
1440
1441
	     errs[0],
	     round_trials[0],
	     errs[1],
1442
	     round_trials[1],
1443
	     errs[2],
1444
	     round_trials[2],
1445
	     errs[3],
1446
	     round_trials[3],
1447
	     (double)errs[0]/(round_trials[0]),
knopp's avatar
   
knopp committed
1448
1449
1450
	     (double)errs[1]/(round_trials[0]),
	     (double)errs[2]/(round_trials[0]),
	     (double)errs[3]/(round_trials[0]),
1451
1452
	     rate*effective_rate,
	     100*effective_rate,
1453
	     rate,
1454
	     rate*get_Qm(mcs),
1455
1456
1457
1458
1459
1460
1461
1462
1463
	     (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0])/(double)PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->TBS,
	     (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0]));
    
      if (cqi_flag >0) {
	printf("CQI errors %d/%d,false positives %d/%d, CQI false negatives %d/%d\n",
	       cqi_errors,round_trials[0]+round_trials[1]+round_trials[2]+round_trials[3],
	       cqi_crc_falsepositives,round_trials[0]+round_trials[1]+round_trials[2]+round_trials[3],
	       cqi_crc_falsenegatives,round_trials[0]+round_trials[1]+round_trials[2]+round_trials[3]);
      }
knopp's avatar
   
knopp committed
1464
      if (PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->o_ACK[0] > 0) 
1465
1466
	printf("ACK/NAK errors %d/%d\n",ack_errors,round_trials[0]+round_trials[1]+round_trials[2]+round_trials[3]);

1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482

      fprintf(bler_fd,"%f;%d;%d;%d;%f;%d;%d;%d;%d;%d;%d;%d;%d\n",
	      SNR,
	      mcs,
	      nb_rb,
	      PHY_vars_eNB->ulsch_eNB[0]->harq_processes[harq_pid]->TBS,
	      rate,
	      errs[0],
	      round_trials[0],
	      errs[1],
	      round_trials[1],
	      errs[2],
	      round_trials[2],
	      errs[3],
	      round_trials[3]);

1483
1484
1485

      if (dump_perf==1) {
	printf("UE TX function statistics (per 1ms subframe)\n\n");
1486
        std_phy_proc_tx = sqrt((double)PHY_vars_UE->phy_proc_tx.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_UE->phy_proc_tx.trials - pow((double)PHY_vars_UE->phy_proc_tx.diff/PHY_vars_UE->phy_proc_tx.trials/cpu_freq_GHz/1000,2));
1487
	printf("Total PHY proc tx                 :%f us (%d trials)\n",(double)PHY_vars_UE->phy_proc_tx.diff/PHY_vars_UE->phy_proc_tx.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->phy_proc_tx.trials);
1488
	printf("|__ Statistics                         std: %f us max: %fus min: %fus median %fus q1 %fus q3 %fus n_dropped: %d packet \n",std_phy_proc_tx, t_tx_max, t_tx_min, tx_median, tx_q1, tx_q3, n_tx_dropped);
1489
	std_phy_proc_tx_ifft = sqrt((double)PHY_vars_UE->ofdm_mod_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_UE->ofdm_mod_stats.trials - pow((double)PHY_vars_UE->ofdm_mod_stats.diff/PHY_vars_UE->ofdm_mod_stats.trials/cpu_freq_GHz/1000,2));
1490
	printf("OFDM_mod time                     :%f us (%d trials)\n",(double)PHY_vars_UE->ofdm_mod_stats.diff/PHY_vars_UE->ofdm_mod_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ofdm_mod_stats.trials);
1491
1492
    printf("|__ Statistics                         std: %f us median %fus q1 %fus q3 %fus \n",std_phy_proc_tx_ifft, tx_ifft_median, tx_ifft_q1, tx_ifft_q3);
	std_phy_proc_tx_mod = sqrt((double)PHY_vars_UE->ulsch_modulation_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_UE->ulsch_modulation_stats.trials - pow((double)PHY_vars_UE->ulsch_modulation_stats.diff/PHY_vars_UE->ulsch_modulation_stats.trials/cpu_freq_GHz/1000,2));
1493
	printf("ULSCH modulation time             :%f us (%d trials)\n",(double)PHY_vars_UE->ulsch_modulation_stats.diff/PHY_vars_UE->ulsch_modulation_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ulsch_modulation_stats.trials);
1494
1495
		printf("|__ Statistics                         std: %f us median %fus q1 %fus q3 %fus \n",std_phy_proc_tx_mod, tx_mod_median, tx_mod_q1, tx_mod_q3);
	    std_phy_proc_tx_enc = sqrt((double)PHY_vars_UE->ulsch_encoding_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_UE->ulsch_encoding_stats.trials - pow((double)PHY_vars_UE->ulsch_encoding_stats.diff/PHY_vars_UE->ulsch_encoding_stats.trials/cpu_freq_GHz/1000,2));
1496
	printf("ULSCH encoding time               :%f us (%d trials)\n",(double)PHY_vars_UE->ulsch_encoding_stats.diff/PHY_vars_UE->ulsch_encoding_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ulsch_encoding_stats.trials);
1497
	printf("|__ Statistics                         std: %f us median %fus q1 %fus q3 %fus \n",std_phy_proc_tx_enc, tx_enc_median, tx_enc_q1, tx_enc_q3);
1498
1499
1500
1501
1502
1503
1504
	printf("|__ ULSCH segmentation time           :%f us (%d trials)\n",(double)PHY_vars_UE->ulsch_segmentation_stats.diff/PHY_vars_UE->ulsch_segmentation_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ulsch_segmentation_stats.trials);
	printf("|__ ULSCH turbo encoding time         :%f us (%d trials)\n",((double)PHY_vars_UE->ulsch_turbo_encoding_stats.trials/PHY_vars_UE->ulsch_encoding_stats.trials)*(double)PHY_vars_UE->ulsch_turbo_encoding_stats.diff/PHY_vars_UE->ulsch_turbo_encoding_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ulsch_turbo_encoding_stats.trials);
	printf("|__ ULSCH rate-matching time          :%f us (%d trials)\n",((double)PHY_vars_UE->ulsch_rate_matching_stats.trials/PHY_vars_UE->ulsch_encoding_stats.trials)*(double)PHY_vars_UE->ulsch_rate_matching_stats.diff/PHY_vars_UE->ulsch_rate_matching_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ulsch_rate_matching_stats.trials);
	printf("|__ ULSCH sub-block interleaving time :%f us (%d trials)\n",((double)PHY_vars_UE->ulsch_interleaving_stats.trials/PHY_vars_UE->ulsch_encoding_stats.trials)*(double)PHY_vars_UE->ulsch_interleaving_stats.diff/PHY_vars_UE->ulsch_interleaving_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ulsch_interleaving_stats.trials);
	printf("|__ ULSCH multiplexing time           :%f us (%d trials)\n",((double)PHY_vars_UE->ulsch_multiplexing_stats.trials/PHY_vars_UE->ulsch_encoding_stats.trials)*(double)PHY_vars_UE->ulsch_multiplexing_stats.diff/PHY_vars_UE->ulsch_multiplexing_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_UE->ulsch_multiplexing_stats.trials);

	printf("\n\neNB RX function statistics (per 1ms subframe)\n\n");
1505
        std_phy_proc_rx = sqrt((double)PHY_vars_eNB->phy_proc_rx.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_eNB->phy_proc_rx.trials - pow((double)PHY_vars_eNB->phy_proc_rx.diff/PHY_vars_eNB->phy_proc_rx.trials/cpu_freq_GHz/1000,2));
1506
1507
        printf("Total PHY proc rx                  :%f us (%d trials)\n",(double)PHY_vars_eNB->phy_proc_rx.diff/PHY_vars_eNB->phy_proc_rx.trials/cpu_freq_GHz/1000.0,PHY_vars_eNB->phy_proc_rx.trials);
	printf("|__ Statistcs                           std: %fus max: %fus min: %fus median %fus q1 %fus q3 %fus n_dropped: %d packet \n", std_phy_proc_rx, t_rx_max, t_rx_min, rx_median, rx_q1, rx_q3, n_rx_dropped);
1508
    std_phy_proc_rx_fft = sqrt((double)PHY_vars_eNB->ofdm_demod_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_eNB->ofdm_demod_stats.trials - pow((double)PHY_vars_eNB->ofdm_demod_stats.diff/PHY_vars_eNB->ofdm_demod_stats.trials/cpu_freq_GHz/1000,2));	
1509
	printf("OFDM_demod time                   :%f us (%d trials)\n",(double)PHY_vars_eNB->ofdm_demod_stats.diff/PHY_vars_eNB->ofdm_demod_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_eNB->ofdm_demod_stats.trials);
1510
1511
	printf("|__ Statistcs                           std: %fus median %fus q1 %fus q3 %fus \n", std_phy_proc_rx_fft, rx_fft_median, rx_fft_q1, rx_fft_q3);
	std_phy_proc_rx_demod = sqrt((double)PHY_vars_eNB->ulsch_demodulation_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_eNB->ulsch_demodulation_stats.trials - pow((double)PHY_vars_eNB->ulsch_demodulation_stats.diff/PHY_vars_eNB->ulsch_demodulation_stats.trials/cpu_freq_GHz/1000,2));
1512
	printf("ULSCH demodulation time           :%f us (%d trials)\n",(double)PHY_vars_eNB->ulsch_demodulation_stats.diff/PHY_vars_eNB->ulsch_demodulation_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_eNB->ulsch_demodulation_stats.trials);
1513
1514
	printf("|__ Statistcs                           std: %fus median %fus q1 %fus q3 %fus \n", std_phy_proc_rx_demod, rx_demod_median, rx_demod_q1, rx_demod_q3);
	std_phy_proc_rx_dec = sqrt((double)PHY_vars_eNB->ulsch_decoding_stats.diff_square/pow(cpu_freq_GHz,2)/pow(1000,2)/PHY_vars_eNB->ulsch_decoding_stats.trials - pow((double)PHY_vars_eNB->ulsch_decoding_stats.diff/PHY_vars_eNB->ulsch_decoding_stats.trials/cpu_freq_GHz/1000,2));
1515
1516
1517
1518
	printf("ULSCH Decoding time (%.2f Mbit/s, avg iter %f)      :%f us (%d trials, max %f)\n",
	       PHY_vars_UE->ulsch_ue[0]->harq_processes[harq_pid]->TBS/1000.0,(double)avg_iter/iter_trials,
	       (double)PHY_vars_eNB->ulsch_decoding_stats.diff/PHY_vars_eNB->ulsch_decoding_stats.trials/cpu_freq_GHz/1000.0,PHY_vars_eNB->ulsch_decoding_stats.trials, 
	       (double)PHY_vars_eNB->ulsch_decoding_stats.max/cpu_freq_GHz/1000.0);
1519
	       	printf("|__ Statistcs                           std: %fus median %fus q1 %fus q3 %fus \n", std_phy_proc_rx_dec, rx_dec_median, rx_dec_q1, rx_dec_q3);
1520
1521
1522
1523
1524
1525
1526