diff --git a/openair1/PHY/LTE_TRANSPORT/dci_tools.c b/openair1/PHY/LTE_TRANSPORT/dci_tools.c
index e685ca3da6644d8d9f3b3ff68815b9e48fb5145c..0da47dbdfff85c86fa9ebc056f55a8c040e626c4 100755
--- a/openair1/PHY/LTE_TRANSPORT/dci_tools.c
+++ b/openair1/PHY/LTE_TRANSPORT/dci_tools.c
@@ -404,7 +404,7 @@ uint16_t computeRIV(uint16_t N_RB_DL,uint16_t RBstart,uint16_t Lcrbs)
 }
 
 // Convert a DCI Format 1C RIV to a Format 1A RIV
-// This extracts the start and length in PRBs from the 1C rballoc and 
+// This extracts the start and length in PRBs from the 1C rballoc and
 // recomputes the RIV as if it were the 1A rballoc
 
 uint32_t conv_1C_RIV(int32_t rballoc,uint32_t N_RB_DL) {
@@ -448,7 +448,7 @@ uint32_t conv_1C_RIV(int32_t rballoc,uint32_t N_RB_DL) {
   }
   //  printf("RBpstart %d\n",RBpstart);
   return(computeRIV(N_RB_DL,N_RB_step*RBpstart,N_RB_step*(LpCRBsm1+1)));
-   
+
 }
 
 uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap) {
@@ -456,11 +456,11 @@ uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap) {
   int offset;
 
   switch (N_RB_DL) {
-    
+
   case 6:
   // N_RB_DL = tildeN_RB_DL = 6
   // Ngap = 4 , P=1, Nrow = 2, Nnull = 2
-  
+
     switch (vrb) {
     case 0:  // even: 0->0, 1->2, odd: 0->3, 1->5
     case 1:
@@ -471,13 +471,13 @@ uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap) {
       return ((3*odd_slot) + 2*(vrb&3) + 5)%6;
       break;
     case 4:  // even: 4->1, odd: 4->4
-      return ((3*odd_slot) + 1)%6; 
+      return ((3*odd_slot) + 1)%6;
     case 5:  // even: 5->4, odd: 5->1
       return ((3*odd_slot) + 4)%6;
       break;
     }
     break;
-    
+
   case 15:
     if (vrb<12) {
       if ((vrb&3) < 2)     // even: 0->0, 1->4, 4->1, 5->5, 8->2, 9->6 odd: 0->7, 1->11
@@ -491,11 +491,11 @@ uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap) {
       return (10+(7*odd_slot)) % 14;
     return 14;
     break;
-    
+
   case 25:
     return (((12*odd_slot) + 6*(vrb&3) + (vrb>>2))%24) + 24*(vrb/24);
     break;
-    
+
   case 50: // P=3
     if (Ngap==0) {
       // Nrow=12,Nnull=2,NVRBDL=46,Ngap1= 27
@@ -528,7 +528,7 @@ uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap) {
   offset=18;
       else
   offset=0;
-      
+
       if (vrb<12) {
   if ((vrb&3)>=2)
     return offset+((9*odd_slot) + 6*(vrb&3) + (vrb>>2) + 17)%18;
@@ -543,19 +543,19 @@ uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap) {
   case 75:
     // Ngap1 = 32, NVRBRL=64, P=4, Nrow= 16, Nnull=0
     if (Ngap ==0) {
-      return ((32*odd_slot) + 16*(vrb&3) + (vrb>>2))%64 + (vrb/64); 
+      return ((32*odd_slot) + 16*(vrb&3) + (vrb>>2))%64 + (vrb/64);
     } else {
       // Ngap2 = 16, NVRBDL=32, Nrow=8, Nnull=0
-      return ((16*odd_slot) + 8*(vrb&3) + (vrb>>2))%32 + (vrb/32); 
+      return ((16*odd_slot) + 8*(vrb&3) + (vrb>>2))%32 + (vrb/32);
     }
     break;
   case 100:
     // Ngap1 = 48, NVRBDL=96, Nrow=24, Nnull=0
     if (Ngap ==0) {
-      return ((48*odd_slot) + 24*(vrb&3) + (vrb>>2))%96 + (vrb/96); 
+      return ((48*odd_slot) + 24*(vrb&3) + (vrb>>2))%96 + (vrb/96);
     } else {
       // Ngap2 = 16, NVRBDL=32, Nrow=8, Nnull=0
-      return ((16*odd_slot) + 8*(vrb&3) + (vrb>>2))%32 + (vrb/32); 
+      return ((16*odd_slot) + 8*(vrb&3) + (vrb>>2))%32 + (vrb/32);
     }
     break;
   default:
@@ -563,7 +563,7 @@ uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap) {
     return 0;
   }
   return 0;
-  
+
 }
 
 
@@ -878,7 +878,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
   uint32_t rballoc = UINT32_MAX;
   uint32_t RIV_max = 0;
   uint8_t NPRB,tbswap,tpmi=0;
-  LTE_eNB_DLSCH_t *dlsch0=NULL,*dlsch1;
+  LTE_eNB_DLSCH_t *dlsch0=NULL,*dlsch1=NULL;
   uint8_t frame_type=frame_parms->frame_type;
   uint8_t vrb_type=0;
   uint8_t mcs=0,mcs1=0,mcs2=0;
@@ -886,6 +886,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
   uint8_t rv=0,rv1=0,rv2=0;
   uint8_t rah=0;
   uint8_t TPC=0;
+  uint8_t TB0_active=0,TB1_active=0;
   LTE_DL_eNB_HARQ_t *dlsch0_harq=NULL,*dlsch1_harq=NULL;
 
   //   printf("Generate eNB DCI, format %d, rnti %x (pdu %p)\n",dci_format,rnti,dci_pdu);
@@ -926,6 +927,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
       }
 
       dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
+      dlsch0_harq->codeword=0;
 
       if (vrb_type==LOCALIZED) {
   dlsch0_harq->rb_alloc[0]    = localRIV2alloc_LUT6[rballoc];
@@ -964,7 +966,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
 
       dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
 
-      
+
       if (vrb_type==LOCALIZED) {
   dlsch0_harq->rb_alloc[0]    = localRIV2alloc_LUT25[rballoc];
       }
@@ -1216,6 +1218,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
     }
 
     dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
+    dlsch0_harq->codeword=0;
 
     // msg("DCI: Setting subframe_tx for subframe %d\n",subframe);
     dlsch[0]->subframe_tx[subframe] = 1;
@@ -1497,66 +1500,128 @@ int generate_eNB_dlsch_params_from_dci(int frame,
 
     // Flip the TB to codeword mapping as described in 5.3.3.1.5 of 36-212 V11.3.0
     // note that we must set tbswap=0 in eNB scheduler if one TB is deactivated
-    if (tbswap == 0) {
-      dlsch0 = dlsch[0];
-      dlsch1 = dlsch[1];
-    } else {
-      dlsch0 = dlsch[1];
-      dlsch1 = dlsch[0];
+    TB0_active = 1;
+    TB1_active = 1;
+
+    if ((rv1 == 1) && (mcs1 == 0)) {
+      TB0_active=0;
+    }
+    if ((rv2 == 1) && (mcs2 == 0)) {
+      TB1_active=0;
     }
 
-    dlsch0_harq = dlsch0->harq_processes[harq_pid];
-    dlsch1_harq = dlsch1->harq_processes[harq_pid];
+    if (TB0_active && TB1_active && tbswap==0) {
+      dlsch0=dlsch[0];
+      dlsch1=dlsch[1];
+      dlsch0->active = 1;
+      dlsch1->active = 1;
+      dlsch0_harq = dlsch0->harq_processes[harq_pid];
+      dlsch1_harq = dlsch1->harq_processes[harq_pid];
+      dlsch0_harq->mcs = mcs1;
+      dlsch1_harq->mcs = mcs2;
+      dlsch0_harq->rvidx = rv1;
+      dlsch1_harq->rvidx = rv2;
+      dlsch0_harq->status = ACTIVE;
+      dlsch1_harq->status = ACTIVE;
+      dlsch0_harq->codeword=0;
+      dlsch1_harq->codeword=1;
+      printf("\n ENB: BOTH ACTIVE\n");
+    }
+    else if (TB0_active && TB1_active && tbswap==1) {
+      dlsch0=dlsch[0];
+      dlsch1=dlsch[1];
+      dlsch0->active = 1;
+      dlsch1->active = 1;
+      dlsch0_harq = dlsch0->harq_processes[harq_pid];
+      dlsch1_harq = dlsch1->harq_processes[harq_pid];
+      dlsch0_harq->mcs = mcs1;
+      dlsch1_harq->mcs = mcs2;
+      dlsch0_harq->rvidx = rv1;
+      dlsch1_harq->rvidx = rv2;
+      dlsch0_harq->status = ACTIVE;
+      dlsch1_harq->status = ACTIVE;
+      dlsch0_harq->codeword=1;
+      dlsch1_harq->codeword=0;
+    }
+    else if (TB0_active && (TB1_active==0)) {
+      dlsch0=dlsch[0];
+      dlsch0->active = 1;
+      dlsch0_harq = dlsch0->harq_processes[harq_pid];
+      dlsch0_harq->mcs = mcs1;
+      dlsch0_harq->rvidx = rv1;
+      dlsch0_harq->status = ACTIVE;
+      dlsch0_harq->codeword = 0;
+      dlsch1=NULL;
+      dlsch1_harq = NULL;
+    }
+    else if ((TB0_active==0) && TB1_active) {
+      dlsch1=dlsch[1];
+      dlsch1->active = 1;
+      dlsch1_harq = dlsch1->harq_processes[harq_pid];
+      dlsch1_harq->mcs = mcs2;
+      dlsch1_harq->rvidx = rv2;
+      dlsch1_harq->status = ACTIVE;
+      dlsch1_harq->codeword = 0;
+      dlsch0=NULL;
+      dlsch0_harq = NULL;
+      printf("\n ENB: TB0 is deactivated, retransmit TB1 transmit in TM6\n");
+    }
 
-    dlsch0->subframe_tx[subframe] = 1;
+    if (dlsch0 != NULL){
+      dlsch0->subframe_tx[subframe] = 1;
 
-    dlsch0->current_harq_pid = harq_pid;
-    dlsch1->current_harq_pid = harq_pid;
-    dlsch0->harq_ids[subframe] = harq_pid;
-    dlsch1->harq_ids[subframe] = harq_pid;
-    //    printf("Setting DLSCH harq id %d to subframe %d\n",harq_pid,subframe);
+      dlsch0->current_harq_pid = harq_pid;
+      dlsch0->harq_ids[subframe] = harq_pid;
+    }
 
+    if (dlsch1_harq != NULL){
+      dlsch1->current_harq_pid = harq_pid;
+      dlsch1->harq_ids[subframe] = harq_pid;
+    }
 
-    conv_rballoc(rah,
-                 rballoc,
-                 frame_parms->N_RB_DL,
-                 dlsch0_harq->rb_alloc);
 
-    dlsch1_harq->rb_alloc[0] = dlsch0_harq->rb_alloc[0];
-    dlsch0_harq->nb_rb = conv_nprb(rah, rballoc, frame_parms->N_RB_DL);
-    dlsch1_harq->nb_rb = dlsch0_harq->nb_rb;
+    if (dlsch0 != NULL ){
+      conv_rballoc(rah,
+                   rballoc,
+                   frame_parms->N_RB_DL,
+                   dlsch0_harq->rb_alloc);
 
-    if (dlsch0_harq->nb_rb == 0)
-      return(-1);
+      dlsch0_harq->nb_rb = conv_nprb(rah, rballoc, frame_parms->N_RB_DL);
+
+      if (dlsch1 != NULL){
+        dlsch1_harq->rb_alloc[0] = dlsch0_harq->rb_alloc[0];
+        dlsch1_harq->nb_rb = dlsch0_harq->nb_rb;
+      }
+    } else if ((dlsch0 == NULL ) && (dlsch1 != NULL )){
+        conv_rballoc(rah,
+                     rballoc,
+                     frame_parms->N_RB_DL,
+                     dlsch1_harq->rb_alloc);
+
+        dlsch1_harq->nb_rb = conv_nprb(rah, rballoc, frame_parms->N_RB_DL);
+    }
+
+
+    /*if (dlsch0_harq->nb_rb == 0)
+      return(-1);*/
 
-    dlsch0_harq->mcs       = mcs1;
-    dlsch1_harq->mcs       = mcs2;
-    dlsch0_harq->rvidx     = rv1;
-    dlsch1_harq->rvidx     = rv2;
 
     // assume both TBs are active
-    dlsch0_harq->Nl        = 1;
-    dlsch1_harq->Nl        = 1;
-    dlsch0->active = 1;
-    dlsch1->active = 1;
+    if (dlsch0_harq != NULL)
+      dlsch0_harq->Nl        = 1;
+    if (dlsch1_harq != NULL)
+      dlsch1_harq->Nl        = 1;
 
 
     // check if either TB is disabled (see 36-213 V11.3 Section )
-    if ((dlsch0_harq->rvidx == 1) && (dlsch0_harq->mcs == 0)) {
-      dlsch0->active = 0;
-    }
-
-    if ((dlsch1_harq->rvidx == 1) && (dlsch1_harq->mcs == 0)) {
-      dlsch1->active = 0;
-    }
 
     if (frame_parms->nb_antennas_tx == 2) {
-      if (dlsch0->active == 1 && dlsch1->active == 1) { // both TBs are active
+      if ((dlsch0 != NULL) && (dlsch1 != NULL)) {  //two CW active
 
-        dlsch0_harq->dl_power_off = 1; 
-        dlsch1_harq->dl_power_off = 1; 
+        dlsch0_harq->dl_power_off = 1;
+        dlsch1_harq->dl_power_off = 1;
         dlsch0_harq->TBS = TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
-        dlsch1_harq->TBS = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch0_harq->nb_rb-1];
+        dlsch1_harq->TBS = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
         switch (tpmi) {
         case 0:
           dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
@@ -1575,13 +1640,12 @@ int generate_eNB_dlsch_params_from_dci(int frame,
           dlsch0_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
           dlsch0_harq->pmi_alloc   = DL_pmi_single;
           dlsch1_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
-          dlsch1_harq->pmi_alloc   = DL_pmi_single; 
+          dlsch1_harq->pmi_alloc   = DL_pmi_single;
           break;
         default:
           break;
         }
-      }
-      else if (dlsch1->active == 0) { // only one is active
+      } else if ((dlsch0 != NULL) && (dlsch1 == NULL))  { // only CW 0 active
         dlsch0_harq->dl_power_off = 1;
         dlsch0_harq->TBS= TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
         switch (tpmi) {
@@ -1613,53 +1677,54 @@ int generate_eNB_dlsch_params_from_dci(int frame,
           dlsch0_harq->pmi_alloc   = DL_pmi_single;
           break;
         }
-      }
-      else if (dlsch0->active == 0) { // only one is active
-        dlsch1_harq->dl_power_off = 1;
-        dlsch1_harq->TBS= TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
-        switch (tpmi) {
-        case 0 :
-          dlsch1_harq->mimo_mode   = ALAMOUTI;
-          break;
-        case 1:
-          dlsch1_harq->mimo_mode   = UNIFORM_PRECODING11;
-          dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,0,0);
-          break;
-        case 2:
-          dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1m1;
-          dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1,0);
-          break;
-        case 3:
-          dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1j;
-          dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,2,0);
-          break;
-        case 4:
-          dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1mj;
-          dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,3,0);
-          break;
-        case 5:
-          dlsch1_harq->mimo_mode   = PUSCH_PRECODING0;
-          dlsch1_harq->pmi_alloc   = DL_pmi_single;
-          break;
-        case 6:
-          dlsch1_harq->mimo_mode   = PUSCH_PRECODING1;
-          dlsch1_harq->pmi_alloc   = DL_pmi_single;
-          break;
+      } else if ((dlsch0 == NULL) && (dlsch1 != NULL))  {
+          dlsch1_harq->dl_power_off = 1;
+          dlsch1_harq->TBS= TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
+          switch (tpmi) {
+          case 0 :
+            dlsch1_harq->mimo_mode   = ALAMOUTI;
+            break;
+          case 1:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING11;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,0,0);
+            break;
+          case 2:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1m1;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1,0);
+            break;
+          case 3:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1j;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,2,0);
+            break;
+          case 4:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1mj;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,3,0);
+            break;
+          case 5:
+            dlsch1_harq->mimo_mode   = PUSCH_PRECODING0;
+            dlsch1_harq->pmi_alloc   = DL_pmi_single;
+            break;
+          case 6:
+            dlsch1_harq->mimo_mode   = PUSCH_PRECODING1;
+            dlsch1_harq->pmi_alloc   = DL_pmi_single;
+            break;
+          }
         }
-      }
+
     } else if (frame_parms->nb_antennas_tx == 4) {
       // fill in later
     }
 
     // reset HARQ process if this is the first transmission
-    if (dlsch0_harq->round == 0)
+   /* if (dlsch0_harq->round == 0)
       dlsch0_harq->status = ACTIVE;
 
     if (dlsch1_harq->round == 0)
-      dlsch1_harq->status = ACTIVE;
-
-    dlsch0->rnti = rnti;
-    dlsch1->rnti = rnti;
+      dlsch1_harq->status = ACTIVE;*/
+    if (dlsch0_harq != NULL)
+      dlsch0->rnti = rnti;
+    if (dlsch1 != NULL)
+      dlsch1->rnti = rnti;
 
     break;
 
@@ -1869,7 +1934,8 @@ int generate_eNB_dlsch_params_from_dci(int frame,
 
     // Flip the TB to codeword mapping as described in 5.3.3.1.5 of 36-212 V11.3.0
     // note that we must set tbswap=0 in eNB scheduler if one TB is deactivated
-    if (tbswap == 0) { 
+    // This must be set as in TM4, does not work properly now.
+    if (tbswap == 0) {
       dlsch0 = dlsch[0];
       dlsch1 = dlsch[1];
     } else {
@@ -1933,7 +1999,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
       dlsch1_harq->TBS         = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch0_harq->nb_rb-1];
 
       if ((dlsch0->active==1) && (dlsch1->active==1)) {
-  
+
         dlsch0_harq->mimo_mode = LARGE_CDD;
         dlsch1_harq->mimo_mode = LARGE_CDD;
         dlsch0_harq->dl_power_off = 1;
@@ -2154,11 +2220,15 @@ int generate_eNB_dlsch_params_from_dci(int frame,
     dlsch0_harq = dlsch0->harq_processes[harq_pid];
     dlsch1_harq = dlsch1->harq_processes[harq_pid];
 
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
+    dlsch1_harq->codeword=1;
+
     conv_rballoc(rah,
                  rballoc,
                  frame_parms->N_RB_DL,
                  dlsch0_harq->rb_alloc);
-    
+
     dlsch1_harq->rb_alloc[0]     = dlsch0_harq->rb_alloc[0];
 
     dlsch0_harq->nb_rb           = conv_nprb(rah,
@@ -2315,6 +2385,10 @@ int generate_eNB_dlsch_params_from_dci(int frame,
     dlsch0_harq = dlsch0->harq_processes[harq_pid];
     dlsch1_harq = dlsch1->harq_processes[harq_pid];
 
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
+    dlsch1_harq->codeword=1;
+
     conv_rballoc(rah,
                  rballoc,
                  frame_parms->N_RB_DL,
@@ -2487,6 +2561,10 @@ int generate_eNB_dlsch_params_from_dci(int frame,
     dlsch0_harq = dlsch0->harq_processes[harq_pid];
     dlsch1_harq = dlsch1->harq_processes[harq_pid];
 
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
+    dlsch1_harq->codeword=1;
+
     conv_rballoc(rah,
                  rballoc,
                  frame_parms->N_RB_DL,
@@ -2568,6 +2646,8 @@ int generate_eNB_dlsch_params_from_dci(int frame,
     //dlsch1->harq_ids[subframe] = harq_pid;
     //    printf("Setting DLSCH harq id %d to subframe %d\n",harq_pid,subframe);
     dlsch0_harq = dlsch0->harq_processes[harq_pid];
+       // Needs to be checked
+    dlsch0_harq->codeword=0;
 
     conv_rballoc(((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->rah,
                  ((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->rballoc,frame_parms->N_RB_DL,
@@ -2677,7 +2757,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
     break;
   }
 
-  
+
   if (dlsch0_harq) {
     dlsch0_harq->frame   = frame;
     dlsch0_harq->subframe = subframe;
@@ -2719,7 +2799,7 @@ int generate_eNB_dlsch_params_from_dci(int frame,
 
 #endif
 
-  // compute DL power control parameters   
+  // compute DL power control parameters
   computeRhoA_eNB(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB);
   computeRhoB_eNB(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off);
 
@@ -3115,37 +3195,37 @@ int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci)
       ((DCI1C_1_5MHz_t *)&dci->dci_pdu[0])->rballoc,RIV2nb_rb_LUT6[conv_1C_RIV(((DCI1C_1_5MHz_t *)&dci->dci_pdu[0])->rballoc,6)]);
       LOG_D(PHY,"MCS %d\n",((DCI1C_1_5MHz_t *)&dci->dci_pdu[0])->mcs);
       break;
-      
+
     case 25:
       LOG_D(PHY,"DCI format1C (5MHz), rnti %x (%x)\n",dci->rnti,((uint32_t*)&dci->dci_pdu[0])[0]);
       LOG_D(PHY,"RB_ALLOC %x (NB_RB %d)\n",((DCI1C_5MHz_t *)&dci->dci_pdu[0])->rballoc,RIV2nb_rb_LUT25[conv_1C_RIV(((DCI1C_5MHz_t *)&dci->dci_pdu[0])->rballoc,25)]);
       LOG_D(PHY,"MCS %d\n",((DCI1C_5MHz_t *)&dci->dci_pdu[0])->mcs);
       break;
-      
+
     case 50:
       LOG_D(PHY,"DCI format1C (10MHz), rnti %x (%x)\n",dci->rnti,((uint32_t*)&dci->dci_pdu[0])[0]);
       LOG_D(PHY,"Ngap %d\n",((DCI1C_10MHz_t *)&dci->dci_pdu[0])->Ngap);
       LOG_D(PHY,"RB_ALLOC %x (NB_RB %d)\n",((DCI1C_10MHz_t *)&dci->dci_pdu[0])->rballoc,RIV2nb_rb_LUT50[conv_1C_RIV(((DCI1C_10MHz_t *)&dci->dci_pdu[0])->rballoc,50)]);
       LOG_D(PHY,"MCS %d\n",((DCI1C_10MHz_t *)&dci->dci_pdu[0])->mcs);
       break;
-      
+
     case 100:
       LOG_D(PHY,"DCI format1C (20MHz), rnti %x (%x)\n",dci->rnti,((uint32_t*)&dci->dci_pdu[0])[0]);
       LOG_D(PHY,"Ngap %d\n",((DCI1C_20MHz_t *)&dci->dci_pdu[0])->Ngap);
       LOG_D(PHY,"RB_ALLOC %x (NB_RB %d)\n",((DCI1C_20MHz_t *)&dci->dci_pdu[0])->rballoc,RIV2nb_rb_LUT50[conv_1C_RIV(((DCI1C_20MHz_t *)&dci->dci_pdu[0])->rballoc,100)]);
       LOG_D(PHY,"MCS %d\n",((DCI1C_20MHz_t *)&dci->dci_pdu[0])->mcs);
       break;
-      
-      
+
+
     default:
       LOG_E(PHY,"Invalid N_RB_DL %d\n", frame_parms->N_RB_DL);
         DevParam (frame_parms->N_RB_DL, 0, 0);
         break;
     }
-    
+
 
     break;
-    
+
   case format2:
 
     if ((frame_parms->frame_type == TDD) &&
@@ -3859,13 +3939,14 @@ int generate_ue_dlsch_params_from_dci(int frame,
   uint8_t vrb_type=0;
   uint8_t mcs=0,mcs1=0,mcs2=0;
   uint8_t rv=0,rv1=0,rv2=0;
+  uint8_t TB0_active=0,TB1_active=0;
   uint8_t ndi=0,ndi1=0,ndi2=0;
   uint8_t rah=0;
   uint8_t TPC=0;
   uint8_t NPRB=0,tbswap=0,tpmi=0;
   uint8_t Ngap;
   LTE_UE_DLSCH_t *dlsch0=NULL,*dlsch1=NULL;
-  LTE_DL_UE_HARQ_t *dlsch0_harq,*dlsch1_harq;
+  LTE_DL_UE_HARQ_t *dlsch0_harq=NULL,*dlsch1_harq=NULL;
 
 #ifdef DEBUG_DCI
   LOG_D(PHY,"dci_tools.c: Filling ue dlsch params -> rnti %x, dci_format %d\n",rnti,dci_format);
@@ -3915,6 +3996,8 @@ int generate_ue_dlsch_params_from_dci(int frame,
         }
 
         dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
+
+
         NPRB = RIV2nb_rb_LUT6[rballoc];
         dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3];
   dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3];
@@ -4170,6 +4253,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
     dlsch0_harq->mimo_mode = frame_parms->mode1_flag == 1 ?SISO : ALAMOUTI;
     dlsch0_harq->dl_power_off = 1; //no power offset
 
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
+
     LOG_D(PHY,"UE (%x/%d): Subframe %d Format1A DCI: ndi %d, old_ndi %d (first tx %d) harq_status %d, round %d\n",
     dlsch[0]->rnti,
     harq_pid,
@@ -4210,7 +4296,7 @@ int generate_ue_dlsch_params_from_dci(int frame,
 
     harq_pid = 0;
     dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
- 
+
     switch (frame_parms->N_RB_DL) {
     case 6:
       mcs                           = ((DCI1C_1_5MHz_t *)dci_pdu)->mcs;
@@ -4230,7 +4316,7 @@ int generate_ue_dlsch_params_from_dci(int frame,
       dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_odd_LUT25[rballoc];
       RIV_max                       = RIV_max25;
 
-      //      printf("Format1C : %x : mcs %d, rballoc %d=>%d=>%x\n",((uint32_t*)dci_pdu)[0], 
+      //      printf("Format1C : %x : mcs %d, rballoc %d=>%d=>%x\n",((uint32_t*)dci_pdu)[0],
       //       mcs,((DCI1C_5MHz_t *)dci_pdu)->rballoc,rballoc,dlsch0_harq->rb_alloc_even[0]);
       break;
 
@@ -4240,16 +4326,16 @@ int generate_ue_dlsch_params_from_dci(int frame,
       Ngap                          = ((DCI1C_10MHz_t *)dci_pdu)->Ngap;
       dlsch0_harq->nb_rb            = RIV2nb_rb_LUT50[rballoc];
       if (Ngap == 0) {
-  dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap0_even_LUT50_0[rballoc];
-  dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap0_odd_LUT50_0[rballoc];
-  dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap0_even_LUT50_1[rballoc];
-  dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap0_odd_LUT50_1[rballoc];
+        dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap0_even_LUT50_0[rballoc];
+        dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap0_odd_LUT50_0[rballoc];
+        dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap0_even_LUT50_1[rballoc];
+        dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap0_odd_LUT50_1[rballoc];
       }
       else {
-  dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap1_even_LUT50_0[rballoc];
-  dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap1_odd_LUT50_0[rballoc];
-  dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap1_even_LUT50_1[rballoc];
-  dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap1_odd_LUT50_1[rballoc];
+        dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap1_even_LUT50_0[rballoc];
+        dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap1_odd_LUT50_0[rballoc];
+        dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap1_even_LUT50_1[rballoc];
+        dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap1_odd_LUT50_1[rballoc];
       }
       RIV_max                       = RIV_max50;
 
@@ -4261,28 +4347,28 @@ int generate_ue_dlsch_params_from_dci(int frame,
       Ngap                     = ((DCI1C_20MHz_t *)dci_pdu)->Ngap;
       dlsch0_harq->nb_rb       = RIV2nb_rb_LUT100[rballoc];
       if (Ngap==0) {
-  dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap0_even_LUT100_0[rballoc];
-  dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap0_odd_LUT100_0[rballoc];
-  dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap0_even_LUT100_1[rballoc];
-  dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap0_odd_LUT100_1[rballoc];
-  dlsch0_harq->rb_alloc_even[2] = distRIV2alloc_gap0_even_LUT100_2[rballoc];
-  dlsch0_harq->rb_alloc_odd[2]  = distRIV2alloc_gap0_odd_LUT100_2[rballoc];
-  dlsch0_harq->rb_alloc_even[3] = distRIV2alloc_gap0_even_LUT100_3[rballoc];
-  dlsch0_harq->rb_alloc_odd[3]  = distRIV2alloc_gap0_odd_LUT100_3[rballoc];
+        dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap0_even_LUT100_0[rballoc];
+        dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap0_odd_LUT100_0[rballoc];
+        dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap0_even_LUT100_1[rballoc];
+        dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap0_odd_LUT100_1[rballoc];
+        dlsch0_harq->rb_alloc_even[2] = distRIV2alloc_gap0_even_LUT100_2[rballoc];
+        dlsch0_harq->rb_alloc_odd[2]  = distRIV2alloc_gap0_odd_LUT100_2[rballoc];
+        dlsch0_harq->rb_alloc_even[3] = distRIV2alloc_gap0_even_LUT100_3[rballoc];
+        dlsch0_harq->rb_alloc_odd[3]  = distRIV2alloc_gap0_odd_LUT100_3[rballoc];
       }
       else {
-  dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap1_even_LUT100_0[rballoc];
-  dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap1_odd_LUT100_0[rballoc];
-  dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap1_even_LUT100_1[rballoc];
-  dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap1_odd_LUT100_1[rballoc];
-  dlsch0_harq->rb_alloc_even[2] = distRIV2alloc_gap1_even_LUT100_2[rballoc];
-  dlsch0_harq->rb_alloc_odd[2]  = distRIV2alloc_gap1_odd_LUT100_2[rballoc];
-  dlsch0_harq->rb_alloc_even[3] = distRIV2alloc_gap1_even_LUT100_3[rballoc];
-  dlsch0_harq->rb_alloc_odd[3]  = distRIV2alloc_gap1_odd_LUT100_3[rballoc];
+        dlsch0_harq->rb_alloc_even[0] = distRIV2alloc_gap1_even_LUT100_0[rballoc];
+        dlsch0_harq->rb_alloc_odd[0]  = distRIV2alloc_gap1_odd_LUT100_0[rballoc];
+        dlsch0_harq->rb_alloc_even[1] = distRIV2alloc_gap1_even_LUT100_1[rballoc];
+        dlsch0_harq->rb_alloc_odd[1]  = distRIV2alloc_gap1_odd_LUT100_1[rballoc];
+        dlsch0_harq->rb_alloc_even[2] = distRIV2alloc_gap1_even_LUT100_2[rballoc];
+        dlsch0_harq->rb_alloc_odd[2]  = distRIV2alloc_gap1_odd_LUT100_2[rballoc];
+        dlsch0_harq->rb_alloc_even[3] = distRIV2alloc_gap1_even_LUT100_3[rballoc];
+        dlsch0_harq->rb_alloc_odd[3]  = distRIV2alloc_gap1_odd_LUT100_3[rballoc];
       }
       RIV_max                  = RIV_max100;
       /*
-      printf("Format1C : %x : mcs %d, rballoc %d=>%d=>(%08x.%08x.%08x.%08x), Ngap %d\n",((uint32_t*)dci_pdu)[0], 
+      printf("Format1C : %x : mcs %d, rballoc %d=>%d=>(%08x.%08x.%08x.%08x), Ngap %d\n",((uint32_t*)dci_pdu)[0],
        mcs,((DCI1C_20MHz_t *)dci_pdu)->rballoc,rballoc,
        dlsch0_harq->rb_alloc_even[0],
        dlsch0_harq->rb_alloc_even[1],
@@ -4291,8 +4377,8 @@ int generate_ue_dlsch_params_from_dci(int frame,
        Ngap
        );
       */
-      break;     
-    
+      break;
+
     default:
       LOG_E(PHY,"Format 1C: Unknown N_RB_DL %d\n",frame_parms->N_RB_DL);
       return(-1);
@@ -4309,9 +4395,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
     dlsch[0]->current_harq_pid = harq_pid;
 
     if (rnti==si_rnti) { // rule from Section 5.3.1 of 36.321
-      if (((frame&1) == 0) && (subframe == 5)) 
+      if (((frame&1) == 0) && (subframe == 5))
   dlsch0_harq->rvidx = (((3*((frame>>1)&3))+1)>>1)&3;  // SIB1
-      else 
+      else
   dlsch0_harq->rvidx = (((3*(subframe&3))+1)>>1)&3;  // other SIBs
     }
     else if ((rnti==p_rnti) || (rnti==ra_rnti)) { // Section 7.1.7.3
@@ -4323,6 +4409,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
     dlsch0_harq->mimo_mode = frame_parms->mode1_flag == 1 ?SISO : ALAMOUTI;
     dlsch0_harq->dl_power_off = 1; //no power offset
 
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
+
     LOG_D(PHY,"UE (%x/%d): Subframe %d Format1C DCI: harq_status %d, round %d\n",
     dlsch[0]->rnti,
     harq_pid,
@@ -4472,6 +4561,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
 
     dlsch0_harq->dl_power_off = 1; //no power offset
 
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
+
     LOG_D(PHY,"UE (%x/%d): Subframe %d Format1 DCI: ndi %d, old_ndi %d (first tx %d) harq_status %d\n",dlsch[0]->rnti,harq_pid,subframe,ndi,dlsch0_harq->DCINdi,
 
           dlsch0_harq->first_tx,dlsch0_harq->status);
@@ -4777,210 +4869,269 @@ int generate_ue_dlsch_params_from_dci(int frame,
       return(-1);
     }
 
-    /*if (frame_type == TDD)
-      tbswap = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->tb_swap;
-    else
-      tbswap = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->tb_swap;*/
+    // check if either TB is disabled (see 36-213 V8.6 p. 26)
+    TB0_active = 1;
+    TB1_active = 1;
 
+    if ((rv1 == 1) && (mcs1 == 0)) {
+      TB0_active=0;
+    }
+    if ((rv2 == 1) && (mcs2 == 0)) {
+      TB1_active=0;
+    }
 
-    if (tbswap == 0) {
-      dlsch0 = dlsch[0];
-      dlsch1 = dlsch[1];
-    } else {
-      dlsch0 = dlsch[1];
-      dlsch1 = dlsch[0];
+    //printf("RV TB0 = %d\n", rv1);
+
+
+    if (TB0_active && TB1_active && tbswap==0) { //dlsch0, dlsch0_harq are at the TB level
+      dlsch0=dlsch[0];
+      dlsch1=dlsch[1];
+      dlsch0->active = 1;
+      dlsch1->active = 1;
+      dlsch0_harq = dlsch0->harq_processes[harq_pid];
+      dlsch1_harq = dlsch1->harq_processes[harq_pid];
+      dlsch0_harq->mcs = mcs1;
+      dlsch1_harq->mcs = mcs2;
+      dlsch0_harq->rvidx = rv1;
+      dlsch1_harq->rvidx = rv2;
+      dlsch0_harq->status = ACTIVE;
+      dlsch1_harq->status = ACTIVE;
+      dlsch0_harq->codeword=0;
+      dlsch1_harq->codeword=1;
+      //printf("\n UE: BOTH ACTIVE\n");
+    }
+    else if (TB0_active && TB1_active && tbswap==1) {
+      dlsch0=dlsch[0];
+      dlsch1=dlsch[1];
+      dlsch0->active = 1;
+      dlsch1->active = 1;
+      dlsch0_harq = dlsch0->harq_processes[harq_pid];
+      dlsch1_harq = dlsch1->harq_processes[harq_pid];
+      dlsch0_harq->mcs = mcs1;
+      dlsch1_harq->mcs = mcs2;
+      dlsch0_harq->rvidx = rv1;
+      dlsch1_harq->rvidx = rv2;
+      dlsch0_harq->status = ACTIVE;
+      dlsch1_harq->status = ACTIVE;
+      dlsch0_harq->codeword=1;
+      dlsch1_harq->codeword=0;
+    }
+    else if (TB0_active && (TB1_active==0)) {
+      dlsch0=dlsch[0];
+      dlsch0->active = 1;
+      dlsch0_harq = dlsch0->harq_processes[harq_pid];
+      dlsch0_harq->mcs = mcs1;
+      dlsch0_harq->rvidx = rv1;
+      dlsch0_harq->status = ACTIVE;
+      dlsch0_harq->codeword = 0;
+      dlsch1=NULL;
+      dlsch1_harq = NULL;
+    }
+    else if ((TB0_active==0) && TB1_active) {
+      dlsch1=dlsch[1];
+      dlsch1->active = 1;
+      dlsch1_harq = dlsch1->harq_processes[harq_pid];
+      dlsch1_harq->mcs = mcs2;
+      dlsch1_harq->rvidx = rv2;
+      dlsch1_harq->status = ACTIVE;
+      dlsch1_harq->codeword = 0;
+      dlsch0=NULL;
+      dlsch0_harq = NULL;
+      //printf("\n UE: TB0 is deactivated, retransmit TB1 transmit in TM6\n");
     }
 
-    dlsch0_harq = dlsch0->harq_processes[harq_pid];
-    dlsch1_harq = dlsch1->harq_processes[harq_pid];
-    dlsch0->current_harq_pid = harq_pid;
-    dlsch1->current_harq_pid = harq_pid;
-    dlsch0->harq_ack[subframe].harq_id = harq_pid;
-    dlsch1->harq_ack[subframe].harq_id = harq_pid;
 
-    conv_rballoc(rah,
-                 rballoc,
-                 frame_parms->N_RB_DL,
-                 dlsch0_harq->rb_alloc_even);
+    if (dlsch0 != NULL){
+      dlsch0->current_harq_pid = harq_pid;
+      dlsch0->harq_ack[subframe].harq_id = harq_pid;
+    }
 
-    dlsch0_harq->rb_alloc_odd[0]= dlsch0_harq->rb_alloc_even[0];
-    dlsch0_harq->rb_alloc_odd[1]= dlsch0_harq->rb_alloc_even[1];
-    dlsch0_harq->rb_alloc_odd[2]= dlsch0_harq->rb_alloc_even[2];
-    dlsch0_harq->rb_alloc_odd[3]= dlsch0_harq->rb_alloc_even[3];
+    if (dlsch1 != NULL){
+      dlsch1->current_harq_pid = harq_pid;
+      dlsch1->harq_ack[subframe].harq_id = harq_pid;
+    }
 
-    dlsch1_harq->rb_alloc_even[0]= dlsch0_harq->rb_alloc_even[0];
-    dlsch1_harq->rb_alloc_even[1]= dlsch0_harq->rb_alloc_even[1];
-    dlsch1_harq->rb_alloc_even[2]= dlsch0_harq->rb_alloc_even[2];
-    dlsch1_harq->rb_alloc_even[3]= dlsch0_harq->rb_alloc_even[3];
-    dlsch1_harq->rb_alloc_odd[0] = dlsch0_harq->rb_alloc_odd[0];
-    dlsch1_harq->rb_alloc_odd[1] = dlsch0_harq->rb_alloc_odd[1];
-    dlsch1_harq->rb_alloc_odd[2] = dlsch0_harq->rb_alloc_odd[2];
-    dlsch1_harq->rb_alloc_odd[3] = dlsch0_harq->rb_alloc_odd[3];
+    if (dlsch0_harq != NULL){
+      conv_rballoc(rah,
+                   rballoc,
+                   frame_parms->N_RB_DL,
+                   dlsch0_harq->rb_alloc_even);
 
-    dlsch0_harq->nb_rb = conv_nprb(rah,
-                                   rballoc,
-                                   frame_parms->N_RB_DL);
-    dlsch1_harq->nb_rb = dlsch0_harq->nb_rb;
+      dlsch0_harq->rb_alloc_odd[0]= dlsch0_harq->rb_alloc_even[0];
+      dlsch0_harq->rb_alloc_odd[1]= dlsch0_harq->rb_alloc_even[1];
+      dlsch0_harq->rb_alloc_odd[2]= dlsch0_harq->rb_alloc_even[2];
+      dlsch0_harq->rb_alloc_odd[3]= dlsch0_harq->rb_alloc_even[3];
 
-    dlsch0_harq->mcs       = mcs1;
-    dlsch1_harq->mcs       = mcs2;
+      if (dlsch1_harq != NULL){
+        dlsch1_harq->rb_alloc_even[0]= dlsch0_harq->rb_alloc_even[0];
+        dlsch1_harq->rb_alloc_even[1]= dlsch0_harq->rb_alloc_even[1];
+        dlsch1_harq->rb_alloc_even[2]= dlsch0_harq->rb_alloc_even[2];
+        dlsch1_harq->rb_alloc_even[3]= dlsch0_harq->rb_alloc_even[3];
+        dlsch1_harq->rb_alloc_odd[0] = dlsch0_harq->rb_alloc_odd[0];
+        dlsch1_harq->rb_alloc_odd[1] = dlsch0_harq->rb_alloc_odd[1];
+        dlsch1_harq->rb_alloc_odd[2] = dlsch0_harq->rb_alloc_odd[2];
+        dlsch1_harq->rb_alloc_odd[3] = dlsch0_harq->rb_alloc_odd[3];
 
-    dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3];      
-    dlsch1_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3];      
-    dlsch[0]->g_pucch += delta_PUCCH_lut[TPC&3];
-    dlsch[1]->g_pucch += delta_PUCCH_lut[TPC&3];
-    /*
-      if (dlsch0_harq->mcs>20) {
-      msg("dci_tools.c: mcs > 20 disabled for now (asked %d)\n",dlsch0_harq->mcs);
-      return(-1);
+        dlsch1_harq->nb_rb = dlsch0_harq->nb_rb;
       }
-    */
 
+      dlsch0_harq->nb_rb = conv_nprb(rah,
+                                   rballoc,
+                                   frame_parms->N_RB_DL);
+
+    } else if ((dlsch0_harq == NULL) && (dlsch1_harq != NULL)){
 
-    dlsch0_harq->rvidx = rv1;
-    dlsch1_harq->rvidx = rv2;
+        conv_rballoc(rah,
+                     rballoc,
+                     frame_parms->N_RB_DL,
+                     dlsch1_harq->rb_alloc_even);
 
-    // assume both TBs are active
-    dlsch0_harq->Nl        = 1;
-    dlsch1_harq->Nl        = 1;
-    dlsch0->active = 1;
-    dlsch1->active = 1;
+        dlsch1_harq->rb_alloc_odd[0]= dlsch1_harq->rb_alloc_even[0];
+        dlsch1_harq->rb_alloc_odd[1]= dlsch1_harq->rb_alloc_even[1];
+        dlsch1_harq->rb_alloc_odd[2]= dlsch1_harq->rb_alloc_even[2];
+        dlsch1_harq->rb_alloc_odd[3]= dlsch1_harq->rb_alloc_even[3];
+        dlsch1_harq->nb_rb = dlsch0_harq->nb_rb;
+      }
 
-    
-    // check if either TB is disabled (see 36-213 V8.6 p. 26)
 
-    if ((dlsch0_harq->rvidx == 1) && (dlsch0_harq->mcs == 0)) {
-      
-      dlsch0_harq->status = DISABLED;
-      dlsch0->active = 0; 
+    if (dlsch0_harq != NULL) {
+      dlsch0_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3];
+      dlsch0->g_pucch += delta_PUCCH_lut[TPC&3];
     }
 
-    if ((dlsch1_harq->rvidx == 1) && (dlsch1_harq->mcs == 0)) {
-      dlsch1_harq->status = DISABLED;
-      dlsch1->active = 0;
+    if (dlsch1_harq != NULL) {
+      dlsch1_harq->delta_PUCCH = delta_PUCCH_lut[TPC&3];
+      dlsch1->g_pucch += delta_PUCCH_lut[TPC&3];
     }
 
-    dlsch0_harq->Nl        = 1;
-    dlsch1_harq->Nl        = 1;
+    // assume one layer per codeword (2 antenna port case)
+    if (dlsch0_harq != NULL)
+      dlsch0_harq->Nl = 1;
 
-    //    dlsch0->layer_index                         = tbswap;
-    //    dlsch1->layer_index                         = 1-tbswap;
+    if (dlsch1_harq != NULL)
+      dlsch1_harq->Nl = 1;
 
-    if (dlsch0->active==1 && dlsch1->active==1) {  //two TB
-      dlsch0_harq->dl_power_off = 1;
-      dlsch1_harq->dl_power_off = 1; 
-      switch (tpmi) {
-      case 0:
-        dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
-        dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
-        dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,0, 1);
-        dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,0, 1);
-      break;
-      case 1:
-        dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
-        dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
-        dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,1,1);
-        dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1, 1);
-      break;
-      case 2: // PUSCH precoding
-        dlsch0_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
-        dlsch0_harq->pmi_alloc   = dlsch0->pmi_alloc;
-        dlsch1_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
-        dlsch1_harq->pmi_alloc   = dlsch0->pmi_alloc^0x1555;
-      break;
-      default:
-      break;
-      }
-    } else if (dlsch1_harq->status == DISABLED) {
+
+    if ((dlsch0 != NULL) && (dlsch1 != NULL)){  //two CW active
       dlsch0_harq->dl_power_off = 1;
-      switch (tpmi) {
-      case 0 :
-        dlsch0_harq->mimo_mode   = ALAMOUTI;
-      break;
-      case 1:
-        dlsch0_harq->mimo_mode   = UNIFORM_PRECODING11;
-        dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,0, 0);
-      break;
-      case 2:
-        dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1m1;
-        dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,1, 0);
-      break;
-      case 3:
-        dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1j;
-        dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,2, 0);
-      break;
-      case 4:
-        dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1mj;
-        dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,3, 0);
-      break;
-      case 5:
-        dlsch0_harq->mimo_mode   = PUSCH_PRECODING0;
-        // pmi stored from ulsch allocation routine
-        dlsch0_harq->pmi_alloc   = dlsch0->pmi_alloc;
-        //LOG_I(PHY,"XXX using PMI %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc));
-      break;
-      case 6:
-        dlsch0_harq->mimo_mode   = PUSCH_PRECODING1;
-        LOG_E(PHY,"Unsupported TPMI\n");
-      return(-1);
-      break;
-      }
-    } else if (dlsch0_harq->status == DISABLED) {
       dlsch1_harq->dl_power_off = 1;
       switch (tpmi) {
-      case 0 :
-        dlsch1_harq->mimo_mode   = ALAMOUTI;
-      break;
-      case 1:
-        dlsch1_harq->mimo_mode   = UNIFORM_PRECODING11;
-        dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,0, 0);
-      break;
-      case 2:
-        dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1m1;
-        dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1, 0);
-      break;
-      case 3:
-        dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1j;
-        dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,2, 0);
-      break;
-      case 4:
-        dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1mj;
-        dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,3, 0);
-      break;
-      case 5:
-        dlsch1_harq->mimo_mode   = PUSCH_PRECODING0;
-        // pmi stored from ulsch allocation routine
-        dlsch1_harq->pmi_alloc   = dlsch0->pmi_alloc;
-        //LOG_I(PHY,"XXX using PMI %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc));
-      break;
-      case 6:
-        dlsch1_harq->mimo_mode   = PUSCH_PRECODING1;
-        LOG_E(PHY,"Unsupported TPMI\n");
-      return(-1);
-      break;
+        case 0:
+          dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
+          dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
+          dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,0, 1);
+          dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,0, 1);
+        break;
+        case 1:
+          dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
+          dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
+          dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,1, 1);
+          dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1, 1);
+        break;
+        case 2: // PUSCH precoding
+          dlsch0_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
+          dlsch1_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
+          if (tbswap==0){
+            dlsch0_harq->pmi_alloc   = dlsch0->pmi_alloc;
+            dlsch1_harq->pmi_alloc   = dlsch0->pmi_alloc^0x1555;
+          } else {
+              dlsch1_harq->pmi_alloc   = dlsch0->pmi_alloc;
+              dlsch0_harq->pmi_alloc   = dlsch0->pmi_alloc^0x1555;
+          }
+        break;
+        default:
+        break;
       }
+    } else if ((dlsch0 != NULL) && (dlsch1 == NULL))  { // only CW 0 active
+        dlsch0_harq->dl_power_off = 1;
+        switch (tpmi) {
+          case 0 :
+            dlsch0_harq->mimo_mode   = ALAMOUTI;
+          break;
+          case 1:
+            dlsch0_harq->mimo_mode   = UNIFORM_PRECODING11;
+            dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,0, 0);
+          break;
+          case 2:
+            dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1m1;
+            dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,1, 0);
+          break;
+          case 3:
+            dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1j;
+            dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,2, 0);
+          break;
+          case 4:
+            dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1mj;
+            dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,3, 0);
+          break;
+          case 5:
+            dlsch0_harq->mimo_mode   = PUSCH_PRECODING0;
+            // pmi stored from ulsch allocation routine
+            // we need to extract the first column of precoding matrix (which was computed assuming rank==2)
+            dlsch0_harq->pmi_alloc   = 0;//pmi_convert(frame_parms,dlsch0->pmi_alloc,0);
+            //LOG_I(PHY,"XXX using PMI %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc));
+          break;
+          case 6:
+            dlsch0_harq->mimo_mode   = PUSCH_PRECODING1;
+            // we need to extract the second column of precoding matrix (which was computed assuming rank==2)
+            dlsch0_harq->pmi_alloc   = 0;//pmi_convert(frame_parms,dlsch0->pmi_alloc,1);
+          break;
+          }
+    } else {
+        dlsch1_harq->dl_power_off = 1;
+        switch (tpmi) {
+          case 0 :
+            dlsch1_harq->mimo_mode   = ALAMOUTI;
+          break;
+          case 1:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING11;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,0, 0);
+          break;
+          case 2:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1m1;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1, 0);
+          break;
+          case 3:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1j;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,2, 0);
+          break;
+          case 4:
+            dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1mj;
+            dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,3, 0);
+          break;
+          case 5:
+            dlsch1_harq->mimo_mode   = PUSCH_PRECODING0;
+            // pmi stored from ulsch allocation routine
+            dlsch1_harq->pmi_alloc   = dlsch0->pmi_alloc;
+            //LOG_I(PHY,"XXX using PMI %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc));
+          break;
+          case 6:
+            dlsch1_harq->mimo_mode   = PUSCH_PRECODING1;
+            dlsch1_harq->pmi_alloc   = dlsch0->pmi_alloc;
+          return(-1);
+          break;
+        }
     }
 
-    if (frame_parms->mode1_flag == 1)
+    if ((frame_parms->mode1_flag == 1) && (dlsch0_harq != NULL))
       dlsch0_harq->mimo_mode   = SISO;
 
 
-    if (dlsch0->active == 1) {
+    if (dlsch0 != NULL) {
       if ((ndi1!=dlsch0_harq->DCINdi) || (dlsch0_harq->first_tx==1))  {
         dlsch0_harq->round = 0;
         dlsch0_harq->status = ACTIVE;
         dlsch0_harq->DCINdi = ndi1;
 
-        if (dlsch0_harq->first_tx==1) {
+        if ( dlsch0_harq->first_tx==1) {
           LOG_D(PHY,"Format 2 DCI First TX0: Clearing flag\n");
           dlsch0_harq->first_tx = 0;
         }
-      }      
-      else if (dlsch0_harq->status == SCH_IDLE) {  // we got an Ndi = 0 for a previously decoded process,
+      } else if (dlsch0_harq->status == SCH_IDLE) {  // we got an Ndi = 0 for a previously decoded process,
 
       // this happens if either another harq process in the same
       // is NAK or an ACK was not received
-  
+
         dlsch0->harq_ack[subframe].ack = 1;
         dlsch0->harq_ack[subframe].harq_id = harq_pid;
         dlsch0->harq_ack[subframe].send_harq_status = 1;
@@ -4988,7 +5139,7 @@ int generate_ue_dlsch_params_from_dci(int frame,
       }
     }
 
-    if (dlsch1->active == 1) {
+    if ((dlsch1 != NULL) && (dlsch1->active == 1 )) {
       if ((ndi2!=dlsch1_harq->DCINdi) || (dlsch1_harq->first_tx==1)) {
         dlsch1_harq->round = 0;
         dlsch1_harq->status = ACTIVE;
@@ -4998,10 +5149,10 @@ int generate_ue_dlsch_params_from_dci(int frame,
           dlsch1_harq->first_tx = 0;
         }
       }
-      else if (dlsch1_harq->status == SCH_IDLE) {  // we got an Ndi = 0 for a previously decoded process,
+      else if ((dlsch1 != NULL) && (dlsch1_harq->status == SCH_IDLE)) {  // we got an Ndi = 0 for a previously decoded process,
       // this happens if either another harq process in the same
       // is NAK or an ACK was not received
-  
+
         dlsch1->harq_ack[subframe].ack = 1;
         dlsch1->harq_ack[subframe].harq_id = harq_pid;
         dlsch1->harq_ack[subframe].send_harq_status = 1;
@@ -5009,47 +5160,42 @@ int generate_ue_dlsch_params_from_dci(int frame,
       }
     }
 
-   // dlsch0_harq->mcs         = mcs1;
-
-    if (dlsch0_harq->nb_rb>1) {
-      dlsch0_harq->TBS = TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
-      if (mcs1 <= 28)
-        dlsch0_harq->Qm = get_Qm(mcs1);
-      else if (mcs1<=31)
-        dlsch0_harq->Qm = (mcs1-28)<<1;
-      else
-        LOG_E(PHY,"invalid mcs1 %d\n",mcs1);
-    } else
-      dlsch0_harq->TBS         =0;
-
-
-    /*
-      if (dlsch0_harq->mcs > 18)
-      printf("mcs %d, TBS %d\n",dlsch0_harq->mcs,dlsch0_harq->TBS);
-    */
+    if (dlsch0 != NULL){
+      if (dlsch0_harq->nb_rb>1) {
+        dlsch0_harq->TBS = TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
+        if (mcs1 <= 28)
+          dlsch0_harq->Qm = get_Qm(mcs1);
+        else if (mcs1<=31)
+          dlsch0_harq->Qm = (mcs1-28)<<1;
+        else
+          LOG_E(PHY,"invalid mcs1 %d\n",mcs1);
+      } else
+        dlsch0_harq->TBS         =0;
 
-    if (dlsch1_harq->DCINdi != ndi2) {
-      dlsch1_harq->round=0;
-      dlsch1_harq->status = ACTIVE;
+        dlsch0->rnti = rnti;
     }
 
-    dlsch1_harq->DCINdi      = ndi2;
-   // dlsch1_harq->mcs         = mcs2;
+    if (dlsch1 != NULL) {
+      if (dlsch1_harq->DCINdi != ndi2) {
+        dlsch1_harq->round=0;
+        dlsch1_harq->status = ACTIVE;
+        }
 
-    if (dlsch1_harq->nb_rb>1) {
-      dlsch1_harq->TBS = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
-      if (mcs2 <= 28)
-        dlsch1_harq->Qm = get_Qm(mcs2);
-      else if (mcs1<=31)
-        dlsch1_harq->Qm = (mcs2-28)<<1;
-      else
-      LOG_E(PHY,"invalid mcs2 %d\n",mcs2);
-    } else
-      dlsch1_harq->TBS       = 0;
+      dlsch1_harq->DCINdi      = ndi2;
 
+      if (dlsch1_harq->nb_rb>1) {
+        dlsch1_harq->TBS = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
+        if (mcs2 <= 28)
+          dlsch1_harq->Qm = get_Qm(mcs2);
+        else if (mcs1<=31)
+          dlsch1_harq->Qm = (mcs2-28)<<1;
+        else
+          LOG_E(PHY,"invalid mcs2 %d\n",mcs2);
+        } else
+          dlsch1_harq->TBS       = 0;
 
-    dlsch0->rnti = rnti;
-    dlsch1->rnti = rnti;
+          dlsch1->rnti = rnti;
+    }
 
    break;
 
@@ -5292,6 +5438,7 @@ int generate_ue_dlsch_params_from_dci(int frame,
 
     // Flip the TB to codeword mapping as described in 5.3.3.1.5 of 36-212 V11.3.0
     // note that we must set tbswap=0 in eNB scheduler if one TB is deactivated
+    //Needs to be done in the same manner as TM$.
     if (tbswap == 0) {
       dlsch0 = dlsch[0];
       dlsch1 = dlsch[1];
@@ -5302,6 +5449,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
 
     dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
     dlsch1_harq = dlsch[1]->harq_processes[harq_pid];
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
+    dlsch1_harq->codeword=1;
     dlsch0->current_harq_pid = harq_pid;
     dlsch1->current_harq_pid = harq_pid;
     dlsch0->harq_ack[subframe].harq_id = harq_pid;
@@ -5425,7 +5575,7 @@ int generate_ue_dlsch_params_from_dci(int frame,
       dlsch1_harq->TBS         = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch0_harq->nb_rb-1];
 
 
-      
+
       if ((dlsch0->active==1) && (dlsch1->active==1)) {
         dlsch0_harq->mimo_mode = LARGE_CDD;
         dlsch1_harq->mimo_mode = LARGE_CDD;
@@ -5518,14 +5668,14 @@ int generate_ue_dlsch_params_from_dci(int frame,
       dlsch0_harq->Qm          = (mcs1-28)<<1;
     else
       LOG_E(PHY,"invalid mcs1 %d\n",mcs1);
-    
+
     if (mcs2 <= 28)
       dlsch1_harq->Qm          = get_Qm(mcs2);
     else if (mcs2<=31)
       dlsch1_harq->Qm          = (mcs2-28)<<1;
     else
       LOG_E(PHY,"invalid mcs2 %d\n",mcs2);
-    
+
     //    printf("Format 2A: NPRB=%d (rballoc %x,mcs1 %d, mcs2 %d, frame_type %d N_RB_DL %d,active %d/%d)\n",NPRB,rballoc,mcs1,mcs2,frame_parms->frame_type,frame_parms->N_RB_DL,dlsch0->active,dlsch1->active);
     //printf("UE (%x/%d): Subframe %d Format2A DCI: ndi1 %d, old_ndi1 %d, ndi2 %d, old_ndi2 %d (first tx1 %d, first tx2 %d) harq_status1 %d, harq_status2 %d\n",dlsch0->rnti,harq_pid,subframe,ndi,dlsch0_harq->DCINdi,
     //    dlsch0_harq->first_tx,dlsch1_harq->first_tx,dlsch0_harq->status,dlsch1_harq->status);
@@ -5560,10 +5710,12 @@ int generate_ue_dlsch_params_from_dci(int frame,
     dlsch0 = dlsch[0];
 
     dlsch0_harq = dlsch[0]->harq_processes[harq_pid];
+    // Needs to be checked
+    dlsch0_harq->codeword=0;
     conv_rballoc(((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->rah,
                  ((DCI1E_5MHz_2A_M10PRB_TDD_t *)dci_pdu)->rballoc,frame_parms->N_RB_DL,
                  dlsch0_harq->rb_alloc_even);
-    
+
     dlsch0_harq->rb_alloc_odd[0]                         = dlsch0_harq->rb_alloc_even[0];
     dlsch0_harq->rb_alloc_odd[1]                         = dlsch0_harq->rb_alloc_even[1];
     dlsch0_harq->rb_alloc_odd[2]                         = dlsch0_harq->rb_alloc_even[2];
@@ -5719,7 +5871,7 @@ int generate_ue_dlsch_params_from_dci(int frame,
 #endif
   dlsch[0]->active=1;
 
-  // compute DL power control parameters   
+  // compute DL power control parameters
   computeRhoA_UE(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB);
   computeRhoB_UE(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off);
 
@@ -5883,8 +6035,8 @@ uint16_t quantize_subband_pmi(PHY_MEASUREMENTS *meas,uint8_t eNB_id,int nb_rb)
   uint8_t rank = meas->rank[eNB_id];
   int pmi_re,pmi_im;
   int  nb_subbands=0;
-  
-  
+
+
   switch (nb_rb) {
     case 6:
       nb_subbands = 6;
@@ -5900,7 +6052,7 @@ uint16_t quantize_subband_pmi(PHY_MEASUREMENTS *meas,uint8_t eNB_id,int nb_rb)
       nb_subbands = 13;
       break;
     }
-  
+
 
   for (i=0; i<nb_subbands; i++) {
     pmi_re = 0;
@@ -5927,8 +6079,8 @@ uint16_t quantize_subband_pmi(PHY_MEASUREMENTS *meas,uint8_t eNB_id,int nb_rb)
 
       //      printf("subband %d, pmi%d \n",i,pmiq);
       pmivect |= (pmiq<<(2*i));
-    } 
-    
+    }
+
     else if (rank==1) {
       for (aarx=0; aarx<meas->nb_antennas_rx; aarx++) {
         pmi_re += meas->subband_pmi_re[eNB_id][i][aarx];
@@ -5940,20 +6092,20 @@ uint16_t quantize_subband_pmi(PHY_MEASUREMENTS *meas,uint8_t eNB_id,int nb_rb)
      // this is orthogonal
      //if (((pmi_re >= pmi_im) && (pmi_re >= -pmi_im)) || ((pmi_re <= pmi_im) && (pmi_re >= -pmi_im)))
        pmiq = PMI_2A_R1_11;
-     else 
+     else
        pmiq = PMI_2A_R1_1j;
-      
+
      // printf("subband %d, pmi_re %d, pmi_im %d, pmiq %d \n",i,pmi_re,pmi_im,pmiq);
      // printf("subband %d, pmi%d \n",i,pmiq);
       //According to Section 7.2.4 of 36.213
-      
-      pmivect |= ((pmiq-1)<<(i)); //shift 1 since only one bit  
+
+      pmivect |= ((pmiq-1)<<(i)); //shift 1 since only one bit
     }
     else {
       LOG_E(PHY,"PMI feedback for rank>1 not supported!\n");
       pmivect = 0;
-    } 
-   
+    }
+
   }
      // printf( "pmivect %d \n", pmivect);
 
@@ -7322,7 +7474,7 @@ int generate_eNB_ulsch_params_from_dci(void *dci_pdu,
                                  phy_vars_eNB->proc[sched_subframe].frame_tx,
                                  subframe),
                                  pdcch_alloc2ul_subframe(frame_parms,subframe));
-    
+
     //    printf("eNB: sched_subframe %d, subframe %d, frame_tx %d\n",sched_subframe,subframe,phy_vars_eNB->proc[sched_subframe].frame_tx);
 
     switch (frame_parms->N_RB_DL) {
diff --git a/openair1/PHY/LTE_TRANSPORT/defs.h b/openair1/PHY/LTE_TRANSPORT/defs.h
old mode 100644
new mode 100755
index a7a3143f1d5a83a06d948a97b8b26e06c41edf47..3f20cacf63cc41a51161f5bc58b443ed48889709
--- a/openair1/PHY/LTE_TRANSPORT/defs.h
+++ b/openair1/PHY/LTE_TRANSPORT/defs.h
@@ -94,7 +94,7 @@
 #define PMI_2A_1j  2
 #define PMI_2A_1mj 3
 //2 layers
-#define PMI_2A_R1_10 0 
+#define PMI_2A_R1_10 0
 #define PMI_2A_R1_11 1
 #define PMI_2A_R1_1j 2
 
@@ -172,6 +172,8 @@ typedef struct {
   uint8_t Nlayers;
   /// First layer for this PSCH transmission
   uint8_t first_layer;
+   /// codeword this transport block is mapped to
+  uint8_t codeword;
 } LTE_DL_eNB_HARQ_t;
 
 typedef struct {
@@ -575,6 +577,8 @@ typedef struct {
   uint32_t trials[8];
   /// error statistics per round
   uint32_t errors[8];
+  /// codeword this transport block is mapped to
+  uint8_t codeword;
 } LTE_DL_UE_HARQ_t;
 
 typedef struct {
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
index b3bbbda114717ac18b2d642e4e50a4ef2898ddf0..59e988861b5bc2f4621d3969480894ab3312d23c 100755
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
@@ -57,7 +57,7 @@
 //#define DEBUG_PHY 1
 //#define DEBUG_DLSCH_DEMOD 1
 
-int avg[4]; 
+int avg[4];
 int avg_0[2];
 int avg_1[2];
 
@@ -67,9 +67,9 @@ uint8_t interf_unaw_shift0=0;
 uint8_t interf_unaw_shift1=0;
 uint8_t interf_unaw_shift=0;
 //inferference-free case
-unsigned char interf_unaw_shift_tm4_mcs[29]={5, 3, 4, 3, 3, 2, 1, 1, 2, 0, 1, 1, 1, 1, 0, 0, 
+unsigned char interf_unaw_shift_tm4_mcs[29]={5, 3, 4, 3, 3, 2, 1, 1, 2, 0, 1, 1, 1, 1, 0, 0,
 					     1, 1, 1, 1, 0, 2, 1, 0, 1, 0, 1, 0, 0} ;
-unsigned char interf_unaw_shift_tm1_mcs[29]={5, 5, 4, 3, 3, 3, 2, 2, 4, 4, 2, 3, 3, 3, 1, 1, 
+unsigned char interf_unaw_shift_tm1_mcs[29]={5, 5, 4, 3, 3, 3, 2, 2, 4, 4, 2, 3, 3, 3, 1, 1,
 					     0, 1, 1, 2, 5, 4, 4, 6, 5, 1, 0, 5, 6} ; // mcs 21, 26, 28 seem to be errorneous
 
 /*
@@ -111,18 +111,20 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   LTE_UE_DLSCH_t   **dlsch_ue;
 
 
-  unsigned char aatx,aarx;    
+  unsigned char aatx,aarx;
   unsigned short nb_rb, round;
-  int avgs, rb;  
+  int avgs, rb;
 
  LTE_DL_UE_HARQ_t *dlsch0_harq,*dlsch1_harq = 0;
   uint32_t *rballoc;
 
   int32_t **rxdataF_comp_ptr;
   int32_t **dl_ch_mag_ptr;
+  int32_t codeword_TB0;
+  int32_t codeword_TB1;
+
+
 
-  
-  
   switch (type) {
   case SI_PDSCH:
     lte_ue_pdsch_vars = &phy_vars_ue->lte_ue_pdsch_vars_SI[eNB_id];
@@ -139,8 +141,10 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   case PDSCH:
     lte_ue_pdsch_vars = &phy_vars_ue->lte_ue_pdsch_vars[eNB_id];
     dlsch_ue          = phy_vars_ue->dlsch_ue[eNB_id];
-    dlsch0_harq       = dlsch_ue[0]->harq_processes[harq_pid];
-    dlsch1_harq       = dlsch_ue[1]->harq_processes[harq_pid];
+    codeword_TB0      = dlsch_ue[0]->harq_processes[harq_pid]->codeword;
+    codeword_TB1      = dlsch_ue[1]->harq_processes[harq_pid]->codeword;
+    dlsch0_harq       = dlsch_ue[codeword_TB0]->harq_processes[harq_pid];
+    dlsch1_harq       = dlsch_ue[codeword_TB1]->harq_processes[harq_pid];
     break;
 
   default:
@@ -176,7 +180,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     LOG_W(PHY,"dlsch_demodulation.c: Null lte_frame_parms\n");
     return(-1);
   }
-  
+
   if (((frame_parms->Ncp == NORMAL) && (symbol>=7)) ||
       ((frame_parms->Ncp == EXTENDED) && (symbol>=6)))
     rballoc = dlsch0_harq->rb_alloc_odd;
@@ -187,9 +191,9 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     LOG_E(PHY,"This transmission mode is not yet supported!\n");
     return(-1);
   }
-  
-  
-  
+
+
+
   if ((dlsch0_harq->mimo_mode==LARGE_CDD) || ((dlsch0_harq->mimo_mode>=DUALSTREAM_UNIFORM_PRECODING1) && (dlsch0_harq->mimo_mode<=DUALSTREAM_PUSCH_PRECODING)))  {
     DevAssert(dlsch1_harq);
     if (eNB_id!=eNB_id_i) {
@@ -234,7 +238,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                        phy_vars_ue->high_speed_flag,
                                        frame_parms,
 				                               dlsch0_harq->mimo_mode);
-     else 
+     else
        nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF,
                                        lte_ue_common_vars->dl_ch_estimates[eNB_id],
                                        lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
@@ -266,7 +270,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
         nb_rb = dlsch_extract_rbs_single(lte_ue_common_vars->rxdataF,
                                          lte_ue_common_vars->dl_ch_estimates[eNB_id_i],
                                          lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
-                                         lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,    
+                                         lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
                                          dlsch0_harq->pmi_alloc,
                                          lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
                                          rballoc,
@@ -275,11 +279,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                          phy_vars_ue->high_speed_flag,
                                          frame_parms);
 
-      else 
+      else
         nb_rb = dlsch_extract_rbs_single(lte_ue_common_vars->rxdataF,
                                          lte_ue_common_vars->dl_ch_estimates[eNB_id],
                                          lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
-                                         lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,    
+                                         lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
                                          dlsch0_harq->pmi_alloc,
                                          lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
                                          rballoc,
@@ -306,13 +310,13 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   aarx = frame_parms->nb_antennas_rx;
 
   if (dlsch0_harq->mimo_mode<LARGE_CDD) {// SISO or ALAMOUTI
-    
+
      dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
 			  frame_parms,
 			  dlsch_ue,
 			  symbol,
 			  nb_rb);
-  
+
       if (first_symbol_flag==1) {
 	dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                         frame_parms,
@@ -333,8 +337,8 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
      lte_ue_pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2)+1; //+ interf_unaw_shift_tm1_mcs[dlsch0_harq->mcs];
    // printf("TM4 I-A log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh);
       }
-    
-    
+
+
     	dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
                                lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
@@ -348,13 +352,13 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                nb_rb,
                                lte_ue_pdsch_vars[eNB_id]->log2_maxh,
                                phy_measurements); // log2_maxh+I0_shift
- 
+
  /*if (symbol == 5) {
      write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
  } */
-    if ((rx_type==rx_IC_single_stream) && 
+    if ((rx_type==rx_IC_single_stream) &&
         (eNB_id_i<phy_vars_ue->n_connected_eNB)) {
-         
+
 	 dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
                                  lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
                                  lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
@@ -373,9 +377,9 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
       if (symbol == 5) {
         write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
 
-        write_output("rxF_comp_i.m","rxF_c_i",&lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);     
+        write_output("rxF_comp_i.m","rxF_c_i",&lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
       }
-#endif 
+#endif
      // compute correlation between signal and interference channels
       dlsch_dual_stream_correlation(frame_parms,
                                     symbol,
@@ -385,27 +389,27 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                     lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
                                     lte_ue_pdsch_vars[eNB_id]->log2_maxh);
     }
-    
+
   }
-  else if ((dlsch0_harq->mimo_mode == LARGE_CDD) || 
-           ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && 
+  else if ((dlsch0_harq->mimo_mode == LARGE_CDD) ||
+           ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
             (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){  // TM3 or TM4
     //   LOG_I(PHY,"Running PDSCH RX for TM3\n");
-	      
+
     if (frame_parms->nb_antennas_tx_eNB == 2) {
-       
-	 
+
+
 	 // scaling interfering channel (following for TM56)
 	dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
 			    frame_parms,
 			    dlsch_ue,
 			    symbol,
 			    nb_rb);
-	
-	        
+
+
       if (first_symbol_flag==1) {
         // effective channel of desired user is always stronger than interfering eff. channel
-        dlsch_channel_level_TM34(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, 
+        dlsch_channel_level_TM34(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                  frame_parms,
 				 lte_ue_pdsch_vars[eNB_id]->pmi_ext,
                                  avg_0,
@@ -413,12 +417,12 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 				 symbol,
 				 nb_rb,
                                  dlsch0_harq->mimo_mode);
-	
-	  
+
+
 
  //  write_output("dlsch0_r0_aver_chan_1.m","dl_aver_ch1_r0_0",&avg_1[0],1,1,2);
-	    
-	
+
+
 	if (rx_type>rx_standard) {
 	// Shifts are needed to avoid tails in SNR/BLER curves.
 	// LUT will be introduced with mcs-dependent shift
@@ -426,10 +430,10 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 	avg_1[0] = (log2_approx(avg_1[0])/2) -13 + interf_unaw_shift;
 	lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0);
 	lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0);
-	
+
 	//printf("TM4 I-A log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0);
 	//printf("TM4 I-A log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
-	  
+
 	 }
 	else {
 	// Shifts are needed to avoid tails in SNR/BLER curves.
@@ -443,40 +447,40 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
         }
       }
 
-      dlsch_channel_compensation_TM34(frame_parms, 
+      dlsch_channel_compensation_TM34(frame_parms,
                                      lte_ue_pdsch_vars[eNB_id],
-                                     phy_measurements, 
-                                     eNB_id, 
-                                     symbol, 
-                                     dlsch0_harq->Qm, 
+                                     phy_measurements,
+                                     eNB_id,
+                                     symbol,
+                                     dlsch0_harq->Qm,
                                      dlsch1_harq->Qm,
                                      harq_pid,
                                      dlsch0_harq->round,
                                      dlsch0_harq->mimo_mode,
-                                     nb_rb, 
+                                     nb_rb,
                                      lte_ue_pdsch_vars[eNB_id]->log2_maxh0,
-				     lte_ue_pdsch_vars[eNB_id]->log2_maxh1); 
-   	   
+				     lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
+
   /*   if (symbol == 5) {
-   
+
      write_output("rxF_comp_d00.m","rxF_c_d00",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM
      write_output("rxF_comp_d01.m","rxF_c_d01",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
      write_output("rxF_comp_d10.m","rxF_c_d10",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round][0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
      write_output("rxF_comp_d11.m","rxF_c_d11",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round][1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM
 
-   
+
 	} */
 
       // compute correlation between signal and interference channels (rho12 and rho21)
-      
+
 	dlsch_dual_stream_correlation(frame_parms, // this is doing h11'*h12 and h21'*h22
                                     symbol,
                                     nb_rb,
                                     lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                     &(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
-                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext, 
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
                                     lte_ue_pdsch_vars[eNB_id]->log2_maxh0);
-	
+
 	//printf("rho stream1 =%d\n", &lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round] );
 
       //to be optimized (just take complex conjugate)
@@ -490,15 +494,15 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 				    lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
     //  printf("rho stream2 =%d\n",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext );
       //printf("TM3 log2_maxh : %d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh);
-      
+
   /*     if (symbol == 5) {
-   
+
      write_output("rho0_0.m","rho0_0",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round][0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM
      write_output("rho2_0.m","rho2_0",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
      write_output("rho0_1.m.m","rho0_1",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round][1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
      write_output("rho2_1.m","rho2_1",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM
 
-   
+
 	} */
 
    }
@@ -512,7 +516,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     if ((rx_type==rx_IC_single_stream) && (eNB_id_i==phy_vars_ue->n_connected_eNB) && (dlsch0_harq->dl_power_off==0)) {  // TM5 two-user
 
       // Scale the channel estimates for interfering stream
-      
+
        dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                           frame_parms,
                           dlsch_ue,
@@ -542,7 +546,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
         lte_ue_pdsch_vars[eNB_id]->log2_maxh = cmax(avg[0],0);
         //printf("log1_maxh =%d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh);
       }
-   
+
       dlsch_channel_compensation_TM56(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
                                       lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                       lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
@@ -582,8 +586,8 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
         //    printf("pmi %d, pmi_i %d\n",lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb],lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]);
 
       }
-    
-  
+
+
       dlsch_channel_compensation_TM56(lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
                                       lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
                                       lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
@@ -607,23 +611,23 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
        write_output("rxF_comp_i.m","rxF_c_i",&lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
       }
 #endif
-      dlsch_dual_stream_correlation(frame_parms, 
-                                    symbol, 
-                                    nb_rb, 
-                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, 
-                                    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, 
-                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], 
+      dlsch_dual_stream_correlation(frame_parms,
+                                    symbol,
+                                    nb_rb,
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+                                    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
                                     lte_ue_pdsch_vars[eNB_id]->log2_maxh);
 
-    } 
+    }
     else if (dlsch0_harq->dl_power_off==1)  {
-      
+
         dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
 			  frame_parms,
 			  dlsch_ue,
 			  symbol,
 			  nb_rb);
-  
+
       if (first_symbol_flag==1) {
 	      dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                             frame_parms,
@@ -642,11 +646,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     //  avgs = cmax(avgs,avg[(aarx<<1)+aatx]);
 
    lte_ue_pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) + interf_unaw_shift_tm1_mcs[dlsch0_harq->mcs];
-    
+
       }
-      
-      
-      
+
+
+
       dlsch_channel_compensation_TM56(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
                                       lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                       lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
@@ -668,26 +672,26 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   //  printf("MRC\n");
   if (frame_parms->nb_antennas_rx > 1) {
     if ((dlsch0_harq->mimo_mode == LARGE_CDD) ||
-        ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && 
+        ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
          (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){  // TM3 or TM4
       if (frame_parms->nb_antennas_tx_eNB == 2) {
 
-	dlsch_detection_mrc_TM34(frame_parms, 
+	dlsch_detection_mrc_TM34(frame_parms,
                                  lte_ue_pdsch_vars[eNB_id],
 				 harq_pid,
                                  dlsch0_harq->round,
 				 symbol,
 				 nb_rb,
 				 1);
-	
-	 
+
+
     /*   if (symbol == 5) {
-   
+
      write_output("rho0_mrc.m","rho0_0",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round][0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM
      write_output("rho2_mrc.m","rho2_0",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
     	} */
-	
-	
+
+
       }
     } else {
 
@@ -702,7 +706,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                           lte_ue_pdsch_vars[eNB_id_i]->dl_ch_magb0,
                           symbol,
                           nb_rb,
-                          rx_type==rx_IC_single_stream); 
+                          rx_type==rx_IC_single_stream);
     }
   }
 
@@ -726,12 +730,12 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                    lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
                    symbol,
                    nb_rb);
-        
-  } 
-          
+
+  }
+
   //    printf("LLR");
-  if ((dlsch0_harq->mimo_mode == LARGE_CDD) || 
-      ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && 
+  if ((dlsch0_harq->mimo_mode == LARGE_CDD) ||
+      ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
        (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING)))  {
     rxdataF_comp_ptr = lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round];
     dl_ch_mag_ptr = lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[harq_pid][round];
@@ -743,7 +747,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   }
 
   switch (dlsch0_harq->Qm) {
-  case 2 : 
+  case 2 :
     if (rx_type==rx_standard) {
         dlsch_qpsk_llr(frame_parms,
                        lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
@@ -773,7 +777,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                 lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
           }
         }
-        else if (dlsch1_harq->Qm == 4) { 
+        else if (dlsch1_harq->Qm == 4) {
           dlsch_qpsk_16qam_llr(frame_parms,
                                lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
                                rxdataF_comp_ptr,//i
@@ -816,7 +820,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                  adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol),
                                  lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
           }
-        }          
+        }
       }
     break;
   case 4 :
@@ -914,7 +918,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                       lte_ue_pdsch_vars[eNB_id]->llr128);
     }
     else if (rx_type >= rx_IC_single_stream) {
-      if (dlsch1_harq->Qm == 2) {              
+      if (dlsch1_harq->Qm == 2) {
 	dlsch_64qam_qpsk_llr(frame_parms,
 			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
 			     rxdataF_comp_ptr,//i
@@ -960,7 +964,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
 	}
       }
-      else {	  
+      else {
 	dlsch_64qam_64qam_llr(frame_parms,
 			      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
 			      rxdataF_comp_ptr,//i
@@ -996,7 +1000,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 
   if (dlsch1_harq) {
   switch (get_Qm(dlsch1_harq->mcs)) {
-  case 2 : 
+  case 2 :
     if (rx_type==rx_standard) {
         dlsch_qpsk_llr(frame_parms,
                        rxdataF_comp_ptr,
@@ -1037,7 +1041,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     LOG_W(PHY,"rx_dlsch.c : Unknown mod_order!!!!\n");
     return(-1);
     break;
-  } 
+  }
   }
 
   return(0);
@@ -1070,23 +1074,23 @@ void dlsch_channel_compensation(int **rxdataF_ext,
   symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
 
   if ((symbol_mod == 0) || (symbol_mod == (4-frame_parms->Ncp))) {
-      
-    if (frame_parms->mode1_flag==1) // 10 out of 12 so don't reduce size    
+
+    if (frame_parms->mode1_flag==1) // 10 out of 12 so don't reduce size
       nb_rb=1+(5*nb_rb/6);
-    else  
-      pilots=1;    
+    else
+      pilots=1;
   }
 
   for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++) {
     if (mod_order == 4) {
       QAM_amp128 = _mm_set1_epi16(QAM16_n1);  // 2/sqrt(10)
       QAM_amp128b = _mm_setzero_si128();
-    }    
+    }
     else if (mod_order == 6) {
-      QAM_amp128  = _mm_set1_epi16(QAM64_n1); 
+      QAM_amp128  = _mm_set1_epi16(QAM64_n1);
       QAM_amp128b = _mm_set1_epi16(QAM64_n2);
     }
-    
+
     //    printf("comp: rxdataF_comp %p, symbol %d\n",rxdataF_comp[0],symbol);
 
     for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
@@ -1099,58 +1103,58 @@ void dlsch_channel_compensation(int **rxdataF_ext,
 
 
       for (rb=0;rb<nb_rb;rb++) {
-        if (mod_order>2) {  
+        if (mod_order>2) {
           // get channel amplitude if not QPSK
-                
+
           mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128[0]);
           mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-                
+
           mmtmpD1 = _mm_madd_epi16(dl_ch128[1],dl_ch128[1]);
           mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-                
+
           mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
-                
+
           // store channel magnitude here in a new field of dlsch
-                
+
           dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
           dl_ch_mag128b[0] = dl_ch_mag128[0];
           dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
           dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
-                
+
           dl_ch_mag128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
           dl_ch_mag128b[1] = dl_ch_mag128[1];
           dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
           dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
-                
+
           if (pilots==0) {
             mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128[2]);
             mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
             mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
-                    
+
             dl_ch_mag128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
             dl_ch_mag128b[2] = dl_ch_mag128[2];
-                    
+
             dl_ch_mag128[2] = _mm_mulhi_epi16(dl_ch_mag128[2],QAM_amp128);
-            dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);          
+            dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);
           }
-                
+
           dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
           dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
-                
-                
+
+
           dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
           dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
-                
+
           if (pilots==0) {
             dl_ch_mag128b[2] = _mm_mulhi_epi16(dl_ch_mag128b[2],QAM_amp128b);
-            dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);        
+            dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);
           }
         }
-        
+
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
         //      print_ints("re",&mmtmpD0);
-            
+
         // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
         mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
         mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
@@ -1170,7 +1174,7 @@ void dlsch_channel_compensation(int **rxdataF_ext,
         //      print_shorts("rx:",rxdataF128);
         //      print_shorts("ch:",dl_ch128);
         //      print_shorts("pack:",rxdataF_comp128);
-            
+
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
         // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
@@ -1183,12 +1187,12 @@ void dlsch_channel_compensation(int **rxdataF_ext,
         mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
         mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
         mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-            
+
         rxdataF_comp128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
         //      print_shorts("rx:",rxdataF128+1);
         //      print_shorts("ch:",dl_ch128+1);
-        //      print_shorts("pack:",rxdataF_comp128+1);        
-            
+        //      print_shorts("pack:",rxdataF_comp128+1);
+
         if (pilots==0) {
           // multiply by conjugated channel
           mmtmpD0 = _mm_madd_epi16(dl_ch128[2],rxdataF128[2]);
@@ -1202,12 +1206,12 @@ void dlsch_channel_compensation(int **rxdataF_ext,
           mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
           mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
           mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-                
+
           rxdataF_comp128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
           //    print_shorts("rx:",rxdataF128+2);
           //    print_shorts("ch:",dl_ch128+2);
           //            print_shorts("pack:",rxdataF_comp128+2);
-                
+
           dl_ch128+=3;
           dl_ch_mag128+=3;
           dl_ch_mag128b+=3;
@@ -1221,24 +1225,24 @@ void dlsch_channel_compensation(int **rxdataF_ext,
           rxdataF128+=2;
           rxdataF_comp128+=2;
         }
-            
+
       }
     }
   }
-  
+
   if (rho) {
-      
-      
+
+
     for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
       rho128        = (__m128i *)&rho[aarx][symbol*frame_parms->N_RB_DL*12];
       dl_ch128      = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
       dl_ch128_2    = (__m128i *)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12];
-          
+
       for (rb=0;rb<nb_rb;rb++) {
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128_2[0]);
         //      print_ints("re",&mmtmpD0);
-              
+
         // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
         mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
         mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
@@ -1255,11 +1259,11 @@ void dlsch_channel_compensation(int **rxdataF_ext,
         //              print_ints("c0",&mmtmpD2);
         //      print_ints("c1",&mmtmpD3);
         rho128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-              
+
         //print_shorts("rx:",dl_ch128_2);
         //print_shorts("ch:",dl_ch128);
         //print_shorts("pack:",rho128);
-              
+
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch128[1],dl_ch128_2[1]);
         // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
@@ -1273,11 +1277,11 @@ void dlsch_channel_compensation(int **rxdataF_ext,
         mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
         mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
 
-        
+
         rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
         //print_shorts("rx:",dl_ch128_2+1);
         //print_shorts("ch:",dl_ch128+1);
-        //print_shorts("pack:",rho128+1);       
+        //print_shorts("pack:",rho128+1);
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128_2[2]);
         // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
@@ -1290,27 +1294,27 @@ void dlsch_channel_compensation(int **rxdataF_ext,
         mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
         mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
         mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-              
+
         rho128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
         //print_shorts("rx:",dl_ch128_2+2);
         //print_shorts("ch:",dl_ch128+2);
         //print_shorts("pack:",rho128+2);
-              
+
         dl_ch128+=3;
         dl_ch128_2+=3;
         rho128+=3;
-              
-      } 
-          
+
+      }
+
       if (first_symbol_flag==1) {
         phy_measurements->rx_correlation[0][aarx] = signal_energy(&rho[aarx][symbol*frame_parms->N_RB_DL*12],rb*12);
-      }           
-    }      
+      }
+    }
   }
 
   _mm_empty();
   _m_empty();
-}  
+}
 
 
 
@@ -1361,16 +1365,16 @@ void prec2A_TM56_128(unsigned char pmi,__m128i *ch0,__m128i *ch1)
 }
 #elif defined(__arm__)
 void prec2A_TM56_128(unsigned char pmi,__m128i *ch0,__m128i *ch1) {
-  
+
   __m128i amp;
   amp = _mm_set1_epi16(ONE_OVER_SQRT2_Q15);
 
   switch (pmi) {
-        
+
   case 0 :   // +1 +1
     //    print_shorts("phase 0 :ch0",ch0);
     //    print_shorts("phase 0 :ch1",ch1);
-    ch0[0] = _mm_adds_epi16(ch0[0],ch1[0]);   
+    ch0[0] = _mm_adds_epi16(ch0[0],ch1[0]);
     break;
   case 1 :   // +1 -1
     //    print_shorts("phase 1 :ch0",ch0);
@@ -1383,7 +1387,7 @@ void prec2A_TM56_128(unsigned char pmi,__m128i *ch0,__m128i *ch1) {
     ch1[0] = _mm_shufflelo_epi16(ch1[0],_MM_SHUFFLE(2,3,0,1));
     ch1[0] = _mm_shufflehi_epi16(ch1[0],_MM_SHUFFLE(2,3,0,1));
     ch0[0] = _mm_subs_epi16(ch0[0],ch1[0]);
-        
+
     break;   // +1 -j
   case 3 :
     ch1[0] = _mm_sign_epi16(ch1[0],*(__m128i*)&conjugate[0]);
@@ -1395,7 +1399,7 @@ void prec2A_TM56_128(unsigned char pmi,__m128i *ch0,__m128i *ch1) {
 
   ch0[0] = _mm_mulhi_epi16(ch0[0],amp);
   ch0[0] = _mm_slli_epi16(ch0[0],1);
-    
+
   _mm_empty();
   _m_empty();
 }
@@ -1407,11 +1411,11 @@ void prec2A_TM56_128(unsigned char pmi,__m128i *ch0,__m128i *ch1) {
 short TM3_prec[8]__attribute__((aligned(16))) = {1,1,-1,-1,1,1,-1,-1} ;
 
 void prec2A_TM3_128(__m128i *ch0,__m128i *ch1) {
-  
+
   //  __m128i amp = _mm_set1_epi16(ONE_OVER_SQRT2_Q15);
-  
+
   __m128i tmp0,tmp1;
-  
+
 
   //  print_shorts("prec2A_TM3 ch0 (before):",ch0);
   //  print_shorts("prec2A_TM3 ch1 (before):",ch1);
@@ -1433,7 +1437,7 @@ void prec2A_TM3_128(__m128i *ch0,__m128i *ch1) {
 
   //  print_shorts("prec2A_TM3 ch0 (after):",ch0);
   //  print_shorts("prec2A_TM3 ch1 (after):",ch1);
-    
+
   _mm_empty();
   _m_empty();
 }
@@ -1442,12 +1446,12 @@ void prec2A_TM3_128(__m128i *ch0,__m128i *ch1) {
 // pmi = 1 => stream 0 (1,j), stream 2 (1,-j)
 
 void prec2A_TM4_128(int pmi,__m128i *ch0,__m128i *ch1) {
-  
+
  // printf ("demod pmi=%d\n", pmi);
   // __m128i amp;
   // amp = _mm_set1_epi16(ONE_OVER_SQRT2_Q15);
   __m128i tmp0,tmp1;
-  
+
  // print_shorts("prec2A_TM4 ch0 (before):",ch0);
  // print_shorts("prec2A_TM4 ch1 (before):",ch1);
 
@@ -1474,7 +1478,7 @@ void prec2A_TM4_128(int pmi,__m128i *ch0,__m128i *ch1) {
   //ch1[0] = _mm_mulhi_epi16(ch1[0],amp);
   //ch1[0] = _mm_slli_epi16(ch1[0],1);
 
- 
+
   ch0[0] = _mm_srai_epi16(ch0[0],1); //divide by 2
   ch1[0] = _mm_srai_epi16(ch1[0],1); //divide by 2
   //print_shorts("prec2A_TM4 ch0 (end):",ch0);
@@ -1547,26 +1551,26 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 
       if (pilots==0) {
 
-        prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128[2],&dl_ch1_128[2]); 
+        prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128[2],&dl_ch1_128[2]);
       }
 
-      if (mod_order>2) {  
+      if (mod_order>2) {
         // get channel amplitude if not QPSK
-        
-        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);  
+
+        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);
         mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-                
+
         mmtmpD1 = _mm_madd_epi16(dl_ch0_128[1],dl_ch0_128[1]);
         mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-                
+
         mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
-                
+
         dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
         dl_ch_mag128b[0] = dl_ch_mag128[0];
         dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
         dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
 
-                
+
         //print_shorts("dl_ch_mag128[0]=",&dl_ch_mag128[0]);
 
         //print_shorts("dl_ch_mag128[0]=",&dl_ch_mag128[0]);
@@ -1575,31 +1579,31 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
         dl_ch_mag128b[1] = dl_ch_mag128[1];
         dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
         dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
-                
+
         if (pilots==0) {
           mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],dl_ch0_128[2]);
           mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-                    
+
           mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
-                    
+
           dl_ch_mag128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
           dl_ch_mag128b[2] = dl_ch_mag128[2];
-                    
+
           dl_ch_mag128[2] = _mm_mulhi_epi16(dl_ch_mag128[2],QAM_amp128);
-          dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);    
+          dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);
         }
-                
+
         dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
         dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
-                
+
         //print_shorts("dl_ch_mag128b[0]=",&dl_ch_mag128b[0]);
-                
+
         dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
         dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
-                
+
         if (pilots==0) {
           dl_ch_mag128b[2] = _mm_mulhi_epi16(dl_ch_mag128b[2],QAM_amp128b);
-          dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);          
+          dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);
 
         }
       }
@@ -1628,7 +1632,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
       //        print_shorts("rx:",rxdataF128);
       //        print_shorts("ch:",dl_ch128);
       //        print_shorts("pack:",rxdataF_comp128);
-            
+
       // multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch0_128[1],rxdataF128[1]);
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
@@ -1697,42 +1701,42 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 
   uint32_t rb,Nre;
   uint32_t aarx,symbol_mod,pilots=0;
-  
+
   int16x4_t *dl_ch0_128,*dl_ch1_128,*rxdataF128;
   int16x8_t *dl_ch0_128b,*dl_ch1_128b;
   int32x4_t mmtmpD0,mmtmpD1,mmtmpD0b,mmtmpD1b;
   int16x8_t *dl_ch_mag128,*dl_ch_mag128b,mmtmpD2,mmtmpD3,mmtmpD4,*rxdataF_comp128;
   int16x8_t QAM_amp128,QAM_amp128b;
-  
+
   int16_t conj[4]__attribute__((aligned(16))) = {1,-1,1,-1};
   int32x4_t output_shift128 = vmovq_n_s32(-(int32_t)output_shift);
   int32_t precoded_signal_strength=0;
-  
-  symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;  
+
+  symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
   if ((symbol_mod == 0) || (symbol_mod == (4-frame_parms->Ncp))) {
     if (frame_parms->mode1_flag==1) // 10 out of 12 so don't reduce size
       { nb_rb=1+(5*nb_rb/6); }
-    
+
     else
       { pilots=1; }
   }
-  
-  
+
+
   if (mod_order == 4) {
     QAM_amp128  = vmovq_n_s16(QAM16_n1);  // 2/sqrt(10)
     QAM_amp128b = vmovq_n_s16(0);
-    
+
   } else if (mod_order == 6) {
     QAM_amp128  = vmovq_n_s16(QAM64_n1); //
     QAM_amp128b = vmovq_n_s16(QAM64_n2);
   }
-  
+
   //    printf("comp: rxdataF_comp %p, symbol %d\n",rxdataF_comp[0],symbol);
-  
+
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-    
-    
-    
+
+
+
     dl_ch0_128          = (int16x4_t*)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
     dl_ch1_128          = (int16x4_t*)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12];
     dl_ch0_128b         = (int16x8_t*)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
@@ -1741,18 +1745,18 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
     dl_ch_mag128b       = (int16x8_t*)&dl_ch_magb[aarx][symbol*frame_parms->N_RB_DL*12];
     rxdataF128          = (int16x4_t*)&rxdataF_ext[aarx][symbol*frame_parms->N_RB_DL*12];
     rxdataF_comp128     = (int16x8_t*)&rxdataF_comp[aarx][symbol*frame_parms->N_RB_DL*12];
-    
+
     for (rb=0; rb<nb_rb; rb++) {
 #ifdef DEBUG_DLSCH_DEMOD
       printf("mode 6 prec: rb %d, pmi->%d\n",rb,pmi_ext[rb]);
 #endif
       prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[0],&dl_ch1_128b[0]);
       prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[1],&dl_ch1_128b[1]);
-      
+
       if (pilots==0) {
 	prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[2],&dl_ch1_128b[2]);
       }
-      
+
       if (mod_order>2) {
 	// get channel amplitude if not QPSK
 	mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]);
@@ -1762,7 +1766,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 	mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]);
 	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits 
+	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
 	mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]);
 	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
 	mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]);
@@ -1774,29 +1778,29 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 	  mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]);
 	  mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	  mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	  
-	  
+
+
 	}
-	
+
 	dl_ch_mag128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128b);
 	dl_ch_mag128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128b);
 	dl_ch_mag128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128);
 	dl_ch_mag128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128);
-	
-	
+
+
 	if (pilots==0) {
 	  dl_ch_mag128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp128b);
 	  dl_ch_mag128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp128);
 	}
       }
       mmtmpD0 = vmull_s16(dl_ch0_128[0], rxdataF128[0]);
-      //mmtmpD0 = [Re(ch[0])Re(rx[0]) Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1]) Im(ch[1])Im(ch[1])] 
+      //mmtmpD0 = [Re(ch[0])Re(rx[0]) Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1]) Im(ch[1])Im(ch[1])]
       mmtmpD1 = vmull_s16(dl_ch0_128[1], rxdataF128[1]);
-      //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])] 
+      //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])]
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-      //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])] 
-      
+      //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])]
+
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]);
       //mmtmpD0 = [-Im(ch[0])Re(rx[0]) Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1]) Re(ch[1])Im(rx[1])]
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]);
@@ -1804,49 +1808,49 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
       //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
-      
+
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp128[0] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-      
+
       mmtmpD0 = vmull_s16(dl_ch0_128[2], rxdataF128[2]);
       mmtmpD1 = vmull_s16(dl_ch0_128[3], rxdataF128[3]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-      
+
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]);
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]);
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-      
+
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp128[1] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-      
+
       if (pilots==0) {
 	mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]);
 	mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]);
 	mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			       vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-	
+
 	mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
 	mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
 	mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			       vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-	
-	
+
+
 	mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
 	mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
 	rxdataF_comp128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	
-	
+
+
 	dl_ch0_128+=6;
 	dl_ch1_128+=6;
 	dl_ch_mag128+=3;
 	dl_ch_mag128b+=3;
 	rxdataF128+=6;
 	rxdataF_comp128+=3;
-	
+
       } else { // we have a smaller PDSCH in symbols with pilots so skip last group of 4 REs and increment less
 	dl_ch0_128+=4;
 	dl_ch1_128+=4;
@@ -1856,23 +1860,23 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 	rxdataF_comp128+=2;
       }
     }
-    
+
     Nre = (pilots==0) ? 12 : 8;
 
-    
+
     precoded_signal_strength += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre],
 						     (nb_rb*Nre))) - (phy_measurements->n0_power[aarx]));
     // rx_antennas
   }
   phy_measurements->precoded_cqi_dB[eNB_id][0] = dB_fixed2(precoded_signal_strength,phy_measurements->n0_power_tot);
-        
+
   //printf("eNB_id %d, symbol %d: precoded CQI %d dB\n",eNB_id,symbol,
   //     phy_measurements->precoded_cqi_dB[eNB_id][0]);
-     
-#endif 
+
+#endif
   _mm_empty();
-  _m_empty();  
-}    
+  _m_empty();
+}
 
 void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
                                     LTE_UE_PDSCH *lte_ue_pdsch_vars,
@@ -1906,15 +1910,15 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
   int **rxdataF_comp0         = lte_ue_pdsch_vars->rxdataF_comp0;
   int **rxdataF_comp1         = lte_ue_pdsch_vars->rxdataF_comp1[harq_pid][round];
   unsigned char *pmi_ext     = lte_ue_pdsch_vars->pmi_ext;
-  __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp0_128,QAM_amp0_128b,QAM_amp1_128,QAM_amp1_128b;   
-    
+  __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp0_128,QAM_amp0_128b,QAM_amp1_128,QAM_amp1_128b;
+
   symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
 
   if ((symbol_mod == 0) || (symbol_mod == (4-frame_parms->Ncp)))
     pilots=1;
 
   rx_power_correction = 1;
-    
+
  // printf("comp prec: symbol %d, pilots %d\n",symbol, pilots);
 
   if (mod_order0 == 4) {
@@ -1932,23 +1936,23 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
     QAM_amp1_128  = _mm_set1_epi16(QAM64_n1);
     QAM_amp1_128b = _mm_set1_epi16(QAM64_n2);
   }
-    
+
   for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
-    
+
    /* if (aarx==0) {
-      output_shift=output_shift0; 
+      output_shift=output_shift0;
     }
       else {
 	output_shift=output_shift1;
       } */
-     
-     // printf("antenna %d\n", aarx);  
+
+     // printf("antenna %d\n", aarx);
    // printf("symbol %d, rx antenna %d\n", symbol, aarx);
 
     dl_ch0_128          = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12]; // this is h11
     dl_ch1_128          = (__m128i *)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12]; // this is h12
-        
-        
+
+
     dl_ch_mag0_128      = (__m128i *)&dl_ch_mag0[aarx][symbol*frame_parms->N_RB_DL*12]; //responsible for x1
     dl_ch_mag0_128b     = (__m128i *)&dl_ch_magb0[aarx][symbol*frame_parms->N_RB_DL*12];//responsible for x1
     dl_ch_mag1_128      = (__m128i *)&dl_ch_mag1[aarx][symbol*frame_parms->N_RB_DL*12];   //responsible for x2. always coming from tx2
@@ -1958,156 +1962,156 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
     rxdataF_comp1_128   = (__m128i *)&rxdataF_comp1[aarx][symbol*frame_parms->N_RB_DL*12]; //result of multipl with MF x2 on antenna of interest
 
     for (rb=0; rb<nb_rb; rb++) {
-    
+
       // combine TX channels using precoder from pmi
       if (mimo_mode==LARGE_CDD) {
         prec2A_TM3_128(&dl_ch0_128[0],&dl_ch1_128[0]);
         prec2A_TM3_128(&dl_ch0_128[1],&dl_ch1_128[1]);
-        
-	
+
+
         if (pilots==0) {
-          prec2A_TM3_128(&dl_ch0_128[2],&dl_ch1_128[2]); 
+          prec2A_TM3_128(&dl_ch0_128[2],&dl_ch1_128[2]);
         }
       }
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1) {
-        prec2A_TM4_128(0,&dl_ch0_128[0],&dl_ch1_128[0]); 
-        prec2A_TM4_128(0,&dl_ch0_128[1],&dl_ch1_128[1]); 
-        
+        prec2A_TM4_128(0,&dl_ch0_128[0],&dl_ch1_128[0]);
+        prec2A_TM4_128(0,&dl_ch0_128[1],&dl_ch1_128[1]);
+
         if (pilots==0) {
-          prec2A_TM4_128(0,&dl_ch0_128[2],&dl_ch1_128[2]); 
+          prec2A_TM4_128(0,&dl_ch0_128[2],&dl_ch1_128[2]);
         }
       }
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODINGj) {
         prec2A_TM4_128(1,&dl_ch0_128[0],&dl_ch1_128[0]);
         prec2A_TM4_128(1,&dl_ch0_128[1],&dl_ch1_128[1]);
-        
+
         if (pilots==0) {
-          prec2A_TM4_128(1,&dl_ch0_128[2],&dl_ch1_128[2]); 
+          prec2A_TM4_128(1,&dl_ch0_128[2],&dl_ch1_128[2]);
         }
       }
-      
+
         else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING) {
         prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128[0],&dl_ch1_128[0]);
         prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128[1],&dl_ch1_128[1]);
-        
+
         if (pilots==0) {
-          prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128[2],&dl_ch1_128[2]); 
+          prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128[2],&dl_ch1_128[2]);
         }
       }
-      
-      
+
+
       else {
         LOG_E(PHY,"Unknown MIMO mode\n");
         return;
       }
- 
 
-      if (mod_order0>2) {  
+
+      if (mod_order0>2) {
         // get channel amplitude if not QPSK
-        
-        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);  
+
+        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);
         mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift0);
-                
+
         mmtmpD1 = _mm_madd_epi16(dl_ch0_128[1],dl_ch0_128[1]);
         mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift0);
-                
+
         mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
-                
+
         dl_ch_mag0_128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
         dl_ch_mag0_128b[0] = dl_ch_mag0_128[0];
         dl_ch_mag0_128[0] = _mm_mulhi_epi16(dl_ch_mag0_128[0],QAM_amp0_128);
         dl_ch_mag0_128[0] = _mm_slli_epi16(dl_ch_mag0_128[0],1);
-              
+
         //  print_shorts("dl_ch_mag0_128[0]=",&dl_ch_mag0_128[0]);
-                
+
 
         dl_ch_mag0_128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
         dl_ch_mag0_128b[1] = dl_ch_mag0_128[1];
         dl_ch_mag0_128[1] = _mm_mulhi_epi16(dl_ch_mag0_128[1],QAM_amp0_128);
         dl_ch_mag0_128[1] = _mm_slli_epi16(dl_ch_mag0_128[1],1);
-                
+
         if (pilots==0) {
           mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],dl_ch0_128[2]);
           mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift0);
-                    
+
           mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
-                    
+
           dl_ch_mag0_128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
           dl_ch_mag0_128b[2] = dl_ch_mag0_128[2];
-                    
+
           dl_ch_mag0_128[2] = _mm_mulhi_epi16(dl_ch_mag0_128[2],QAM_amp0_128);
-          dl_ch_mag0_128[2] = _mm_slli_epi16(dl_ch_mag0_128[2],1);        
+          dl_ch_mag0_128[2] = _mm_slli_epi16(dl_ch_mag0_128[2],1);
         }
-                
+
         dl_ch_mag0_128b[0] = _mm_mulhi_epi16(dl_ch_mag0_128b[0],QAM_amp0_128b);
         dl_ch_mag0_128b[0] = _mm_slli_epi16(dl_ch_mag0_128b[0],1);
-                
+
        // print_shorts("dl_ch_mag0_128b[0]=",&dl_ch_mag0_128b[0]);
-                
+
         dl_ch_mag0_128b[1] = _mm_mulhi_epi16(dl_ch_mag0_128b[1],QAM_amp0_128b);
         dl_ch_mag0_128b[1] = _mm_slli_epi16(dl_ch_mag0_128b[1],1);
-                
+
         if (pilots==0) {
           dl_ch_mag0_128b[2] = _mm_mulhi_epi16(dl_ch_mag0_128b[2],QAM_amp0_128b);
-          dl_ch_mag0_128b[2] = _mm_slli_epi16(dl_ch_mag0_128b[2],1);      
+          dl_ch_mag0_128b[2] = _mm_slli_epi16(dl_ch_mag0_128b[2],1);
         }
       }
 
-      if (mod_order1>2) {  
+      if (mod_order1>2) {
         // get channel amplitude if not QPSK
-        
-        mmtmpD0 = _mm_madd_epi16(dl_ch1_128[0],dl_ch1_128[0]);  
+
+        mmtmpD0 = _mm_madd_epi16(dl_ch1_128[0],dl_ch1_128[0]);
         mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift1);
-                
+
         mmtmpD1 = _mm_madd_epi16(dl_ch1_128[1],dl_ch1_128[1]);
         mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift1);
-                
+
         mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
-                
+
         dl_ch_mag1_128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
         dl_ch_mag1_128b[0] = dl_ch_mag1_128[0];
         dl_ch_mag1_128[0] = _mm_mulhi_epi16(dl_ch_mag1_128[0],QAM_amp1_128);
         dl_ch_mag1_128[0] = _mm_slli_epi16(dl_ch_mag1_128[0],1);
-                
+
        // print_shorts("dl_ch_mag1_128[0]=",&dl_ch_mag1_128[0]);
 
         dl_ch_mag1_128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
         dl_ch_mag1_128b[1] = dl_ch_mag1_128[1];
         dl_ch_mag1_128[1] = _mm_mulhi_epi16(dl_ch_mag1_128[1],QAM_amp1_128);
         dl_ch_mag1_128[1] = _mm_slli_epi16(dl_ch_mag1_128[1],1);
-                
+
         if (pilots==0) {
           mmtmpD0 = _mm_madd_epi16(dl_ch1_128[2],dl_ch1_128[2]);
           mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift1);
-                    
+
           mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
-                    
+
           dl_ch_mag1_128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
           dl_ch_mag1_128b[2] = dl_ch_mag1_128[2];
-                    
+
           dl_ch_mag1_128[2] = _mm_mulhi_epi16(dl_ch_mag1_128[2],QAM_amp1_128);
-          dl_ch_mag1_128[2] = _mm_slli_epi16(dl_ch_mag1_128[2],1);        
+          dl_ch_mag1_128[2] = _mm_slli_epi16(dl_ch_mag1_128[2],1);
         }
-                
+
         dl_ch_mag1_128b[0] = _mm_mulhi_epi16(dl_ch_mag1_128b[0],QAM_amp1_128b);
         dl_ch_mag1_128b[0] = _mm_slli_epi16(dl_ch_mag1_128b[0],1);
-                
+
        // print_shorts("dl_ch_mag1_128b[0]=",&dl_ch_mag1_128b[0]);
-                
+
         dl_ch_mag1_128b[1] = _mm_mulhi_epi16(dl_ch_mag1_128b[1],QAM_amp1_128b);
         dl_ch_mag1_128b[1] = _mm_slli_epi16(dl_ch_mag1_128b[1],1);
-                
+
         if (pilots==0) {
           dl_ch_mag1_128b[2] = _mm_mulhi_epi16(dl_ch_mag1_128b[2],QAM_amp1_128b);
-          dl_ch_mag1_128b[2] = _mm_slli_epi16(dl_ch_mag1_128b[2],1);      
+          dl_ch_mag1_128b[2] = _mm_slli_epi16(dl_ch_mag1_128b[2],1);
         }
       }
 
-      // layer 0 
+      // layer 0
       // MF multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],rxdataF128[0]);
-    //  print_ints("re",&mmtmpD0); 
-            
+    //  print_ints("re",&mmtmpD0);
+
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
       mmtmpD1 = _mm_shufflelo_epi16(dl_ch0_128[0],_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
@@ -2129,7 +2133,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
            // print_shorts("rx:",rxdataF128);
            // print_shorts("ch:",dl_ch0_128);
         // print_shorts("pack:",rxdataF_comp0_128);
-          
+
       // multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch0_128[1],rxdataF128[1]);
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
@@ -2146,8 +2150,8 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       rxdataF_comp0_128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
            //  print_shorts("rx:",rxdataF128+1);
             //  print_shorts("ch:",dl_ch0_128+1);
-            // print_shorts("pack:",rxdataF_comp0_128+1);        
-            
+            // print_shorts("pack:",rxdataF_comp0_128+1);
+
       if (pilots==0) {
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],rxdataF128[2]);
@@ -2161,20 +2165,20 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
         mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift0);
         mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
         mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-                
+
         rxdataF_comp0_128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
            //   print_shorts("rx:",rxdataF128+2);
            //   print_shorts("ch:",dl_ch0_128+2);
             //  print_shorts("pack:",rxdataF_comp0_128+2);
-	              
+
       }
-      
-      
+
+
       // layer 1
       // MF multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch1_128[0],rxdataF128[0]);
            //  print_ints("re",&mmtmpD0);
-      
+
      // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
       mmtmpD1 = _mm_shufflelo_epi16(dl_ch1_128[0],_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
@@ -2194,7 +2198,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
             // print_shorts("rx:",rxdataF128);
             //  print_shorts("ch:",dl_ch1_128);
             // print_shorts("pack:",rxdataF_comp1_128);
-      
+
      // multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch1_128[1],rxdataF128[1]);
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
@@ -2211,7 +2215,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       rxdataF_comp1_128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
             //  print_shorts("rx:",rxdataF128+1);
            // print_shorts("ch:",dl_ch1_128+1);
-            // print_shorts("pack:",rxdataF_comp1_128+1);        
+            // print_shorts("pack:",rxdataF_comp1_128+1);
 
       if (pilots==0) {
         // multiply by conjugated channel
@@ -2226,12 +2230,12 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
         mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift1);
         mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
         mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-        
+
         rxdataF_comp1_128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
           //   print_shorts("rx:",rxdataF128+2);
            //  print_shorts("ch:",dl_ch1_128+2);
              //         print_shorts("pack:",rxdataF_comp1_128+2);
-        
+
         dl_ch0_128+=3;
         dl_ch1_128+=3;
         dl_ch_mag0_128+=3;
@@ -2253,40 +2257,40 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
         rxdataF_comp0_128+=2;
         rxdataF_comp1_128+=2;
       }
-      
+
     } // rb loop
     Nre = (pilots==0) ? 12 : 8;
-      
+
     precoded_signal_strength0 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre],
                                                         (nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
-      
+
     precoded_signal_strength1 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx+2][symbol*frame_parms->N_RB_DL*Nre],
                                                         (nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
   } // rx_antennas
-      
+
   phy_measurements->precoded_cqi_dB[eNB_id][0] = dB_fixed2(precoded_signal_strength0,phy_measurements->n0_power_tot);
   phy_measurements->precoded_cqi_dB[eNB_id][1] = dB_fixed2(precoded_signal_strength1,phy_measurements->n0_power_tot);
-        
+
  // printf("eNB_id %d, symbol %d: precoded CQI %d dB\n",eNB_id,symbol,
      //  phy_measurements->precoded_cqi_dB[eNB_id][0]);
-    
+
   _mm_empty();
   _m_empty();
-  
+
   #elif defined(__arm__)
 
   unsigned short rb,Nre;
   unsigned char aarx,symbol_mod,pilots=0;
-  int precoded_signal_strength0=0,precoded_signal_strength1=0, rx_power_correction;  
+  int precoded_signal_strength0=0,precoded_signal_strength1=0, rx_power_correction;
   int16x4_t *dl_ch0_128,*rxdataF128;
   int16x4_t *dl_ch1_128;
   int16x8_t *dl_ch0_128b,*dl_ch1_128b;
-  
+
   int32x4_t mmtmpD0,mmtmpD1,mmtmpD0b,mmtmpD1b;
   int16x8_t *dl_ch_mag0_128,*dl_ch_mag0_128b,*dl_ch_mag1_128,*dl_ch_mag1_128b,mmtmpD2,mmtmpD3,mmtmpD4,*rxdataF_comp0_128,*rxdataF_comp1_128;
   int16x8_t QAM_amp0_128,QAM_amp0_128b,QAM_amp1_128,QAM_amp1_128b;
   int32x4_t output_shift128 = vmovq_n_s32(-(int32_t)output_shift);
-  
+
   int **rxdataF_ext           = lte_ue_pdsch_vars->rxdataF_ext;
   int **dl_ch_estimates_ext   = lte_ue_pdsch_vars->dl_ch_estimates_ext;
   int **dl_ch_mag0            = lte_ue_pdsch_vars->dl_ch_mag0;
@@ -2295,45 +2299,45 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
   int **dl_ch_magb1           = lte_ue_pdsch_vars->dl_ch_magb1[harq_pid][round];
   int **rxdataF_comp0         = lte_ue_pdsch_vars->rxdataF_comp0;
   int **rxdataF_comp1         = lte_ue_pdsch_vars->rxdataF_comp1[harq_pid][round];
-  
+
   int16_t conj[4]__attribute__((aligned(16))) = {1,-1,1,-1};
-  
+
   symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
-  
+
   if ((symbol_mod == 0) || (symbol_mod == (4-frame_parms->Ncp))) {
     if (frame_parms->mode1_flag==1) // 10 out of 12 so don't reduce size
       { nb_rb=1+(5*nb_rb/6); }
-    
+
     else
       { pilots=1; }
   }
-  
+
   rx_power_correction=1;
-  
+
   if (mod_order0 == 4) {
     QAM_amp0_128  = vmovq_n_s16(QAM16_n1);  // 2/sqrt(10)
     QAM_amp0_128b = vmovq_n_s16(0);
-    
+
   } else if (mod_order0 == 6) {
     QAM_amp0_128  = vmovq_n_s16(QAM64_n1); //
     QAM_amp0_128b = vmovq_n_s16(QAM64_n2);
   }
-  
+
   if (mod_order1 == 4) {
     QAM_amp1_128  = vmovq_n_s16(QAM16_n1);  // 2/sqrt(10)
     QAM_amp1_128b = vmovq_n_s16(0);
-    
+
   } else if (mod_order1 == 6) {
     QAM_amp1_128  = vmovq_n_s16(QAM64_n1); //
     QAM_amp1_128b = vmovq_n_s16(QAM64_n2);
   }
-    
+
   //    printf("comp: rxdataF_comp %p, symbol %d\n",rxdataF_comp[0],symbol);
-    
+
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-      
-      
-      
+
+
+
     dl_ch0_128          = (int16x4_t*)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
     dl_ch1_128          = (int16x4_t*)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12];
     dl_ch0_128b          = (int16x8_t*)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
@@ -2345,32 +2349,32 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
     rxdataF128          = (int16x4_t*)&rxdataF_ext[aarx][symbol*frame_parms->N_RB_DL*12];
     rxdataF_comp0_128   = (int16x8_t*)&rxdataF_comp0[aarx][symbol*frame_parms->N_RB_DL*12];
     rxdataF_comp1_128   = (int16x8_t*)&rxdataF_comp1[aarx][symbol*frame_parms->N_RB_DL*12];
-      
+
     for (rb=0; rb<nb_rb; rb++) {
       // combine TX channels using precoder from pmi
       if (mimo_mode==LARGE_CDD) {
         prec2A_TM3_128(&dl_ch0_128[0],&dl_ch1_128[0]);
         prec2A_TM3_128(&dl_ch0_128[1],&dl_ch1_128[1]);
-        
-	
+
+
         if (pilots==0) {
-          prec2A_TM3_128(&dl_ch0_128[2],&dl_ch1_128[2]); 
+          prec2A_TM3_128(&dl_ch0_128[2],&dl_ch1_128[2]);
         }
       }
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1) {
-        prec2A_TM4_128(0,&dl_ch0_128[0],&dl_ch1_128[0]); 
-        prec2A_TM4_128(0,&dl_ch0_128[1],&dl_ch1_128[1]); 
-        
+        prec2A_TM4_128(0,&dl_ch0_128[0],&dl_ch1_128[0]);
+        prec2A_TM4_128(0,&dl_ch0_128[1],&dl_ch1_128[1]);
+
         if (pilots==0) {
-          prec2A_TM4_128(0,&dl_ch0_128[2],&dl_ch1_128[2]); 
+          prec2A_TM4_128(0,&dl_ch0_128[2],&dl_ch1_128[2]);
         }
       }
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODINGj) {
         prec2A_TM4_128(1,&dl_ch0_128[0],&dl_ch1_128[0]);
         prec2A_TM4_128(1,&dl_ch0_128[1],&dl_ch1_128[1]);
-        
+
         if (pilots==0) {
-          prec2A_TM4_128(1,&dl_ch0_128[2],&dl_ch1_128[2]); 
+          prec2A_TM4_128(1,&dl_ch0_128[2],&dl_ch1_128[2]);
         }
       }
       else {
@@ -2378,7 +2382,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
         return;
       }
 
-	
+
       if (mod_order0>2) {
 	// get channel amplitude if not QPSK
 	mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]);
@@ -2388,29 +2392,29 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
 	mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]);
 	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits 
+	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
 	mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]);
 	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
 	mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]);
 	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	  
+
 	if (pilots==0) {
 	  mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]);
 	  mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
 	  mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]);
 	  mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	  mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	    
-	    
+
+
 	}
-	  
+
 	dl_ch_mag0_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128b);
 	dl_ch_mag0_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128b);
 	dl_ch_mag0_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128);
 	dl_ch_mag0_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128);
-	  
-	  
+
+
 	if (pilots==0) {
 	  dl_ch_mag0_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp0_128b);
 	  dl_ch_mag0_128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp0_128);
@@ -2426,43 +2430,43 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
 	mmtmpD1 = vmull_s16(dl_ch1_128[1], dl_ch1_128[1]);
 	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits 
+	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
 	mmtmpD0 = vmull_s16(dl_ch1_128[2], dl_ch1_128[2]);
 	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
 	mmtmpD1 = vmull_s16(dl_ch1_128[3], dl_ch1_128[3]);
 	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	  
+
 	if (pilots==0) {
 	  mmtmpD0 = vmull_s16(dl_ch1_128[4], dl_ch1_128[4]);
 	  mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
 	  mmtmpD1 = vmull_s16(dl_ch1_128[5], dl_ch1_128[5]);
 	  mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
 	  mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	    
-	    
+
+
 	}
-	  
+
 	dl_ch_mag1_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128b);
 	dl_ch_mag1_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128b);
 	dl_ch_mag1_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128);
 	dl_ch_mag1_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128);
-	  
-	  
+
+
 	if (pilots==0) {
 	  dl_ch_mag1_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp1_128b);
 	  dl_ch_mag1_128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp1_128);
 	}
       }
-	
+
       mmtmpD0 = vmull_s16(dl_ch0_128[0], rxdataF128[0]);
-      //mmtmpD0 = [Re(ch[0])Re(rx[0]) Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1]) Im(ch[1])Im(ch[1])] 
+      //mmtmpD0 = [Re(ch[0])Re(rx[0]) Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1]) Im(ch[1])Im(ch[1])]
       mmtmpD1 = vmull_s16(dl_ch0_128[1], rxdataF128[1]);
-      //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])] 
+      //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])]
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-      //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])] 
-	
+      //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])]
+
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]);
       //mmtmpD0 = [-Im(ch[0])Re(rx[0]) Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1]) Re(ch[1])Im(rx[1])]
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]);
@@ -2470,68 +2474,68 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
       //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
-	
+
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp0_128[0] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	
+
       mmtmpD0 = vmull_s16(dl_ch0_128[2], rxdataF128[2]);
       mmtmpD1 = vmull_s16(dl_ch0_128[3], rxdataF128[3]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-      
+
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]);
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]);
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-	
+
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp0_128[1] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	
+
       // second stream
       mmtmpD0 = vmull_s16(dl_ch1_128[0], rxdataF128[0]);
       mmtmpD1 = vmull_s16(dl_ch1_128[1], rxdataF128[1]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]);
-	
+
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]);
       //mmtmpD0 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])]
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
       //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
-	
+
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp1_128[0] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	
+
       mmtmpD0 = vmull_s16(dl_ch1_128[2], rxdataF128[2]);
       mmtmpD1 = vmull_s16(dl_ch1_128[3], rxdataF128[3]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-	
+
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]);
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]);
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-	
+
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp1_128[1] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-     
+
       if (pilots==0) {
 	mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]);
 	mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]);
 	mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			       vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-	  
+
 	mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
 	mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
 	mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			       vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-	  
-	  
+
+
 	mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
 	mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
 	rxdataF_comp0_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
@@ -2539,21 +2543,21 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
 	mmtmpD1 = vmull_s16(dl_ch1_128[5], rxdataF128[5]);
 	mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
 			       vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-	  
+
 	mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
 	mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
 	mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
 			       vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-	  
-	  
+
+
 	mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
 	mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
 	rxdataF_comp1_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
       }
     }
-      
-      
-      
+
+
+
     Nre = (pilots==0) ? 12 : 8;
 
     // rx_antennas
@@ -2564,7 +2568,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
 
   precoded_signal_strength0 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre],
                                                         (nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
-      
+
   precoded_signal_strength1 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx+2][symbol*frame_parms->N_RB_DL*Nre],
                                                         (nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
 
@@ -2601,9 +2605,9 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
   //  printf("Dual stream correlation (%p)\n",dl_ch_estimates_ext_i);
 
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-    
-    
-    
+
+
+
  //printf ("antenna %d", aarx);
     dl_ch128          = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
 
@@ -2650,8 +2654,8 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
       dl_ch_rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
 
-            
-      if (pilots==0) {  
+
+      if (pilots==0) {
 
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128i[2]);
@@ -2666,7 +2670,7 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
         mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
         mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
         dl_ch_rho128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	
+
        dl_ch128+=3;
         dl_ch128i+=3;
         dl_ch_rho128+=3;
@@ -2676,10 +2680,10 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
         dl_ch128i+=2;
         dl_ch_rho128+=2;
       }
-    }           
+    }
 
   }
-    
+
   _mm_empty();
   _m_empty();
 
@@ -2717,14 +2721,14 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
   //  printf("Dual stream correlation (%p)\n",dl_ch_estimates_ext_i);
 
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-    
+
        if (aarx==0) {
-      output_shift=output_shift0; 
+      output_shift=output_shift0;
     }
       else {
 	output_shift=output_shift1;
       }
-    
+
  //printf ("antenna %d", aarx);
     dl_ch128          = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
 
@@ -2771,8 +2775,8 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
       dl_ch_rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
 
-            
-      if (pilots==0) {  
+
+      if (pilots==0) {
 
         // multiply by conjugated channel
         mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128i[2]);
@@ -2787,7 +2791,7 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
         mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
         mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
         dl_ch_rho128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	
+
        dl_ch128+=3;
         dl_ch128i+=3;
         dl_ch_rho128+=3;
@@ -2797,10 +2801,10 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
         dl_ch128i+=2;
         dl_ch_rho128+=2;
       }
-    }           
+    }
 
   }
-    
+
   _mm_empty();
   _m_empty();
 
@@ -2851,7 +2855,7 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
 	//	 print_shorts("mrc mag0:",&dl_ch_mag128_0[i]);
 	//	 print_shorts("mrc mag0b:",&dl_ch_mag128_0b[i]);
         //      print_shorts("mrc rho1:",&rho128_1[i]);
-	
+
       }
     }
 
@@ -2952,13 +2956,13 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
 
 
 void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms,
-			      LTE_UE_PDSCH *lte_ue_pdsch_vars, 
+			      LTE_UE_PDSCH *lte_ue_pdsch_vars,
 			      int harq_pid,
 			      int round,
 			      unsigned char symbol,
 			      unsigned short nb_rb,
 			      unsigned char dual_stream_UE) {
-    
+
   unsigned char aatx;
   int i;
   __m128i *rxdataF_comp128_0,*rxdataF_comp128_1,*rxdataF_comp128_i0,*rxdataF_comp128_i1,*dl_ch_mag128_0,*dl_ch_mag128_1,*dl_ch_mag128_0b,*dl_ch_mag128_1b,*rho128_0,*rho128_1,*rho128_i0,*rho128_i1,*dl_ch_mag128_i0,*dl_ch_mag128_i1,*dl_ch_mag128_i0b,*dl_ch_mag128_i1b;
@@ -2971,23 +2975,23 @@ void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms,
   int **dl_ch_mag1            	= lte_ue_pdsch_vars->dl_ch_mag1[harq_pid][round];
   int **dl_ch_magb0           	= lte_ue_pdsch_vars->dl_ch_magb0;
   int **dl_ch_magb1           	= lte_ue_pdsch_vars->dl_ch_magb1[harq_pid][round];
-  
-  
+
+
   if (frame_parms->nb_antennas_rx>1) {
-      
-      rxdataF_comp128_0   = (__m128i *)&rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12];  
-      rxdataF_comp128_1   = (__m128i *)&rxdataF_comp0[1][symbol*frame_parms->N_RB_DL*12];  
-      dl_ch_mag128_0      = (__m128i *)&dl_ch_mag0[0][symbol*frame_parms->N_RB_DL*12];  
-      dl_ch_mag128_1      = (__m128i *)&dl_ch_mag0[1][symbol*frame_parms->N_RB_DL*12];  
-      dl_ch_mag128_0b     = (__m128i *)&dl_ch_magb0[0][symbol*frame_parms->N_RB_DL*12];  
-      dl_ch_mag128_1b     = (__m128i *)&dl_ch_magb0[1][symbol*frame_parms->N_RB_DL*12];  
+
+      rxdataF_comp128_0   = (__m128i *)&rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12];
+      rxdataF_comp128_1   = (__m128i *)&rxdataF_comp0[1][symbol*frame_parms->N_RB_DL*12];
+      dl_ch_mag128_0      = (__m128i *)&dl_ch_mag0[0][symbol*frame_parms->N_RB_DL*12];
+      dl_ch_mag128_1      = (__m128i *)&dl_ch_mag0[1][symbol*frame_parms->N_RB_DL*12];
+      dl_ch_mag128_0b     = (__m128i *)&dl_ch_magb0[0][symbol*frame_parms->N_RB_DL*12];
+      dl_ch_mag128_1b     = (__m128i *)&dl_ch_magb0[1][symbol*frame_parms->N_RB_DL*12];
 
       // MRC on each re of rb, both on MF output and magnitude (for 16QAM/64QAM llr computation)
       for (i=0;i<nb_rb*3;i++) {
         rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
         dl_ch_mag128_0[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1));
         dl_ch_mag128_0b[i]   = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1));
-      
+
 	// print_shorts("mrc compens0:",&rxdataF_comp128_0[i]);
 	// print_shorts("mrc mag128_0:",&dl_ch_mag128_0[i]);
 	// print_shorts("mrc mag128_0b:",&dl_ch_mag128_0b[i]);
@@ -3007,25 +3011,25 @@ void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms,
     if (dual_stream_UE == 1) {
       rho128_i0 = (__m128i *) &dl_ch_rho_ext[0][symbol*frame_parms->N_RB_DL*12];
       rho128_i1 = (__m128i *) &dl_ch_rho_ext[1][symbol*frame_parms->N_RB_DL*12];
-      rxdataF_comp128_i0   = (__m128i *)&rxdataF_comp1[0][symbol*frame_parms->N_RB_DL*12];  
-      rxdataF_comp128_i1   = (__m128i *)&rxdataF_comp1[1][symbol*frame_parms->N_RB_DL*12];  
-      dl_ch_mag128_i0      = (__m128i *)&dl_ch_mag1[0][symbol*frame_parms->N_RB_DL*12];  
-      dl_ch_mag128_i1      = (__m128i *)&dl_ch_mag1[1][symbol*frame_parms->N_RB_DL*12]; 
-      dl_ch_mag128_i0b     = (__m128i *)&dl_ch_magb1[0][symbol*frame_parms->N_RB_DL*12];  
+      rxdataF_comp128_i0   = (__m128i *)&rxdataF_comp1[0][symbol*frame_parms->N_RB_DL*12];
+      rxdataF_comp128_i1   = (__m128i *)&rxdataF_comp1[1][symbol*frame_parms->N_RB_DL*12];
+      dl_ch_mag128_i0      = (__m128i *)&dl_ch_mag1[0][symbol*frame_parms->N_RB_DL*12];
+      dl_ch_mag128_i1      = (__m128i *)&dl_ch_mag1[1][symbol*frame_parms->N_RB_DL*12];
+      dl_ch_mag128_i0b     = (__m128i *)&dl_ch_magb1[0][symbol*frame_parms->N_RB_DL*12];
       dl_ch_mag128_i1b     = (__m128i *)&dl_ch_magb1[1][symbol*frame_parms->N_RB_DL*12];
       for (i=0;i<nb_rb*3;i++) {
         rxdataF_comp128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_i0[i],1),_mm_srai_epi16(rxdataF_comp128_i1[i],1));
         rho128_i0[i]           = _mm_adds_epi16(_mm_srai_epi16(rho128_i0[i],1),_mm_srai_epi16(rho128_i1[i],1));
-            
+
         dl_ch_mag128_i0[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_i0[i],1),_mm_srai_epi16(dl_ch_mag128_i1[i],1));
         dl_ch_mag128_i0b[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_i0b[i],1),_mm_srai_epi16(dl_ch_mag128_i1b[i],1));
-	
+
 	//print_shorts("mrc compens1:",&rxdataF_comp128_i0[i]);
 	//print_shorts("mrc mag128_i0:",&dl_ch_mag128_i0[i]);
 	//print_shorts("mrc mag128_i0b:",&dl_ch_mag128_i0b[i]);
       }
     }
- 
+
 
   _mm_empty();
   _m_empty();
@@ -3056,7 +3060,7 @@ void dlsch_scale_channel(int **dl_ch_estimates_ext,
   }
 
   // Determine scaling amplitude based the symbol
-  
+
 ch_amp = ((pilots) ? (dlsch_ue[0]->sqrt_rho_b) : (dlsch_ue[0]->sqrt_rho_a));
 
     LOG_D(PHY,"Scaling PDSCH Chest in OFDM symbol %d by %d\n",symbol_mod,ch_amp);
@@ -3068,7 +3072,7 @@ ch_amp = ((pilots) ? (dlsch_ue[0]->sqrt_rho_b) : (dlsch_ue[0]->sqrt_rho_a));
     for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
 
       dl_ch128=(__m128i *)&dl_ch_estimates_ext[(aatx<<1)+aarx][symbol*frame_parms->N_RB_DL*12];
-                
+
       for (rb=0;rb<nb_rb;rb++) {
 
         dl_ch128[0] = _mm_mulhi_epi16(dl_ch128[0],ch_amp128);
@@ -3084,8 +3088,8 @@ ch_amp = ((pilots) ? (dlsch_ue[0]->sqrt_rho_b) : (dlsch_ue[0]->sqrt_rho_a));
           dl_ch128[2] = _mm_slli_epi16(dl_ch128[2],3);
           dl_ch128+=3;
 
-        }       
-      }                
+        }
+      }
     }
   }
 
@@ -3125,11 +3129,11 @@ void dlsch_channel_level(int **dl_ch_estimates_ext,
         avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[0],dl_ch128[0]));
         avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[1],dl_ch128[1]));
         if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
-          dl_ch128+=2;  
+          dl_ch128+=2;
         }
         else {
           avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[2],dl_ch128[2]));
-          dl_ch128+=3;  
+          dl_ch128+=3;
         }
         /*
           if (rb==0) {
@@ -3147,9 +3151,9 @@ void dlsch_channel_level(int **dl_ch_estimates_ext,
       else
         nre=12;
 
-      avg[(aatx<<1)+aarx] = (((int*)&avg128D)[0] + 
-                             ((int*)&avg128D)[1] + 
-                             ((int*)&avg128D)[2] + 
+      avg[(aatx<<1)+aarx] = (((int*)&avg128D)[0] +
+                             ((int*)&avg128D)[1] +
+                             ((int*)&avg128D)[2] +
                              ((int*)&avg128D)[3])/(nb_rb*nre);
 
                 //  printf("Channel level : %d\n",avg[(aatx<<1)+aarx]);
@@ -3259,7 +3263,7 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
   for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
     dl_ch0_128 = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
     dl_ch1_128 = (__m128i *)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12];
-    
+
     avg_0_128D = _mm_setzero_si128();
     avg_1_128D = _mm_setzero_si128();
     for (rb=0; rb<nb_rb; rb++) {
@@ -3269,7 +3273,7 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
       dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[0]);
       dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[0]);
 
-      if (mimo_mode==LARGE_CDD) 
+      if (mimo_mode==LARGE_CDD)
         prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
         prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
@@ -3278,15 +3282,15 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
       else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING)
         prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
 
-      //      mmtmpD0 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);          
+      //      mmtmpD0 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
       avg_0_128D = _mm_add_epi32(avg_0_128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
-      
+
       avg_1_128D = _mm_add_epi32(avg_1_128D,_mm_madd_epi16(dl_ch1_128_tmp,dl_ch1_128_tmp));
-      
+
       dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[1]);
       dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[1]);
 
-      if (mimo_mode==LARGE_CDD) 
+      if (mimo_mode==LARGE_CDD)
         prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
         prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
@@ -3295,20 +3299,20 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
       else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING)
         prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
 
-      //      mmtmpD1 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);          
+      //      mmtmpD1 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
       avg_0_128D = _mm_add_epi32(avg_0_128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
-      
+
       avg_1_128D = _mm_add_epi32(avg_1_128D,_mm_madd_epi16(dl_ch1_128_tmp,dl_ch1_128_tmp));
 
       if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
-        dl_ch0_128+=2;  
+        dl_ch0_128+=2;
         dl_ch1_128+=2;
       }
       else {
         dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[2]);
-        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);          
+        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);
 
-        if (mimo_mode==LARGE_CDD) 
+        if (mimo_mode==LARGE_CDD)
           prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
         else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
           prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
@@ -3317,27 +3321,27 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
 	else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING)
 	  prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
         //      mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
-	
+
 	avg_1_128D = _mm_add_epi32(avg_1_128D,_mm_madd_epi16(dl_ch1_128_tmp,dl_ch1_128_tmp));
 	avg_0_128D = _mm_add_epi32(avg_0_128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
-	
-        dl_ch0_128+=3;  
+
+        dl_ch0_128+=3;
         dl_ch1_128+=3;
-      }          
+      }
     }
-       
-      
+
+
 
     avg_0[aarx] = (((int*)&avg_0_128D)[0])/(nb_rb*nre) +
       (((int*)&avg_0_128D)[1])/(nb_rb*nre) +
       (((int*)&avg_0_128D)[2])/(nb_rb*nre) +
       (((int*)&avg_0_128D)[3])/(nb_rb*nre);
     //  printf("From Chan_level aver stream 0 %d =%d\n", aarx, avg_0[aarx]);
-      
+
     avg_1[aarx] = (((int*)&avg_1_128D)[0])/(nb_rb*nre) +
       (((int*)&avg_1_128D)[1])/(nb_rb*nre) +
       (((int*)&avg_1_128D)[2])/(nb_rb*nre) +
-      (((int*)&avg_1_128D)[3])/(nb_rb*nre);   
+      (((int*)&avg_1_128D)[3])/(nb_rb*nre);
   //    printf("From Chan_level aver stream 1 %d =%d\n", aarx, avg_1[aarx]);
   }
 //avg_0[0] = max(avg_0[0],avg_0[1]);
@@ -3399,38 +3403,38 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
       dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[0]);
       dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[0]);
 
-      if (mimo_mode==LARGE_CDD) 
+      if (mimo_mode==LARGE_CDD)
         prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
         prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODINGj)
         prec2A_TM4_128(1,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
 
-      //      mmtmpD0 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);          
+      //      mmtmpD0 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
       avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
       dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[1]);
       dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[1]);
 
-      if (mimo_mode==LARGE_CDD) 
+      if (mimo_mode==LARGE_CDD)
         prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
         prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
       else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODINGj)
         prec2A_TM4_128(1,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
 
-      //      mmtmpD1 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);          
+      //      mmtmpD1 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
       avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
       if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
-        dl_ch0_128+=2;  
+        dl_ch0_128+=2;
         dl_ch1_128+=2;
       }
       else {
         dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[2]);
-        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);          
+        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);
 
-        if (mimo_mode==LARGE_CDD) 
+        if (mimo_mode==LARGE_CDD)
           prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
         else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
           prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
@@ -3440,9 +3444,9 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
         //      mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
         avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
-        dl_ch0_128+=3;  
+        dl_ch0_128+=3;
         dl_ch1_128+=3;
-      }          
+      }
     }
 
     avg[aarx] = (((int*)&avg128D)[0])/(nb_rb*nre) +
@@ -3513,20 +3517,20 @@ void dlsch_channel_level_TM56(int **dl_ch_estimates_ext,
       avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
       if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
-        dl_ch0_128+=2;  
+        dl_ch0_128+=2;
         dl_ch1_128+=2;
       }
       else {
         dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[2]);
-        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);          
+        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);
 
         prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
         //      mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
         avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
-        dl_ch0_128+=3;  
+        dl_ch0_128+=3;
         dl_ch1_128+=3;
-      }          
+      }
     }
 
     avg[aarx] = (((int*)&avg128D)[0])/(nb_rb*nre) +
@@ -3575,7 +3579,7 @@ void dlsch_alamouti(LTE_DL_FRAME_PARMS *frame_parms,
   ch_mag1 = (__m128i *)&dl_ch_mag[2][jj];
   ch_mag0b = (__m128i *)&dl_ch_magb[0][jj];
   ch_mag1b = (__m128i *)&dl_ch_magb[2][jj];
- 
+
   for (rb=0; rb<nb_rb; rb++) {
 
     for (re=0; re<((pilots==0)?12:8); re+=2) {
@@ -3584,7 +3588,7 @@ void dlsch_alamouti(LTE_DL_FRAME_PARMS *frame_parms,
 
       //      printf("Alamouti: symbol %d, rb %d, re %d: rxF0 (%d,%d,%d,%d), rxF1 (%d,%d,%d,%d)\n",symbol,rb,re,rxF0[0],rxF0[1],rxF0[2],rxF0[3],rxF1[0],rxF1[1],rxF1[2],rxF1[3]);
       rxF0[0] = rxF0[0] + rxF1[2];
-      rxF0[1] = rxF0[1] - rxF1[3]; 
+      rxF0[1] = rxF0[1] - rxF1[3];
 
       rxF0[2] = rxF0[2] - rxF1[0];
       rxF0[3] = rxF0[3] + rxF1[1];
@@ -3702,9 +3706,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
     rxF       = &rxdataF[aarx][(frame_parms->first_carrier_offset + (symbol*(frame_parms->ofdm_symbol_size)))];
 
     if ((frame_parms->N_RB_DL&1) == 0)  // even number of RBs
-      
+
       for (rb=0;rb<frame_parms->N_RB_DL;rb++) {
-        
+
         if (rb < 32)
           rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
         else if (rb < 64)
@@ -3826,31 +3830,31 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
           skip_half=1;
         else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
           skip_half=2;
-        
+
         //SSS
 
-        if (((subframe==0)||(subframe==5)) && 
-            (rb>((frame_parms->N_RB_DL>>1)-3)) && 
-            (rb<((frame_parms->N_RB_DL>>1)+3)) && 
+        if (((subframe==0)||(subframe==5)) &&
+            (rb>((frame_parms->N_RB_DL>>1)-3)) &&
+            (rb<((frame_parms->N_RB_DL>>1)+3)) &&
             (l==sss_symb) ) {
           rb_alloc_ind = 0;
         }
-        //SSS 
-        if (((subframe==0)||(subframe==5)) && 
-            (rb==((frame_parms->N_RB_DL>>1)-3)) && 
+        //SSS
+        if (((subframe==0)||(subframe==5)) &&
+            (rb==((frame_parms->N_RB_DL>>1)-3)) &&
             (l==sss_symb))
           skip_half=1;
-        else if (((subframe==0)||(subframe==5)) && 
-                 (rb==((frame_parms->N_RB_DL>>1)+3)) && 
+        else if (((subframe==0)||(subframe==5)) &&
+                 (rb==((frame_parms->N_RB_DL>>1)+3)) &&
                  (l==sss_symb))
           skip_half=2;
 
         //PSS in subframe 0/5 if FDD
         if (frame_parms->frame_type == FDD) {  //FDD
 
-          if (((subframe==0)||(subframe==5)) && 
-	      (rb>((frame_parms->N_RB_DL>>1)-3)) && 
-	      (rb<((frame_parms->N_RB_DL>>1)+3)) && 
+          if (((subframe==0)||(subframe==5)) &&
+	      (rb>((frame_parms->N_RB_DL>>1)-3)) &&
+	      (rb<((frame_parms->N_RB_DL>>1)+3)) &&
 	      (l==pss_symb) ) {
             rb_alloc_ind = 0;
           }
@@ -3860,7 +3864,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
           else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
             skip_half=2;
         }
-        
+
         if ((frame_parms->frame_type == TDD) &&
             (subframe==6)){  //TDD Subframe 6
           if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
@@ -3984,8 +3988,8 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
 
       // PBCH
 
-      if ((subframe==0) && 
-	  (l>=(nsymb>>1)) && 
+      if ((subframe==0) &&
+	  (l>=(nsymb>>1)) &&
 	  (l<((nsymb>>1) + 4))) {
         rb_alloc_ind = 0;
       }
@@ -4008,7 +4012,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
 	  (l==pss_symb) ) {
 	rb_alloc_ind = 0;
       }
-      
+
 
       //  printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);
       //      printf("DC rb %d (%p)\n",rb,rxF);
@@ -4052,7 +4056,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
               rxF_ext[j++]=rxF[(1+i-6)];
 #ifdef DEBUG_DLSCH_DEMOD
               printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
-#endif           
+#endif
             }
           }
 
@@ -4067,9 +4071,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
       dl_ch0+=12;
       rxF+=7;
       rb++;
-     
+
       for (;rb<frame_parms->N_RB_DL;rb++) {
-        //      printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);       
+        //      printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);
         //      printf("rb %d (%p)\n",rb,rxF);
         skip_half=0;
 
@@ -4134,7 +4138,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
         }
 
         if (rb_alloc_ind==1) {
-#ifdef DEBUG_DLSCH_DEMOD	 
+#ifdef DEBUG_DLSCH_DEMOD
 	  printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
 #endif
           /*
@@ -4150,7 +4154,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
 
               for (i=0; i<6; i++) {
                 rxF_ext[i]=rxF[i];
-#ifdef DEBUG_DLSCH_DEMOD	 
+#ifdef DEBUG_DLSCH_DEMOD
 		printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
 	      }
@@ -4233,7 +4237,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
       }
     }
   }
-  
+
 
   return(nb_rb/frame_parms->nb_antennas_rx);
 }
@@ -4250,7 +4254,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
                                       uint32_t high_speed_flag,
                                       LTE_DL_FRAME_PARMS *frame_parms,
 				                              MIMO_mode_t mimo_mode) {
-    
+
   int prb,nb_rb=0;
   int prb_off,prb_off2;
   int rb_alloc_ind,skip_half=0,sss_symb,pss_symb=0,nsymb,l;
@@ -4258,7 +4262,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
   int32_t *dl_ch0,*dl_ch0p,*dl_ch0_ext,*dl_ch1,*dl_ch1p,*dl_ch1_ext,*rxF,*rxF_ext;
   int symbol_mod,pilots=0,j=0;
   unsigned char *pmi_loc;
-  
+
   symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
   //  printf("extract_rbs: symbol_mod %d\n",symbol_mod);
 
@@ -4287,7 +4291,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
     }
 
     pmi_loc = pmi_ext;
-    
+
     // pointers to extracted RX signals and channel estimates
     rxF_ext    = &rxdataF_ext[aarx][symbol*(frame_parms->N_RB_DL*12)];
     dl_ch0_ext = &dl_ch_estimates_ext[aarx][symbol*(frame_parms->N_RB_DL*12)];
@@ -4295,7 +4299,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 
     for (prb=0; prb<frame_parms->N_RB_DL; prb++) {
       skip_half=0;
-      
+
       if (prb < 32)
 	rb_alloc_ind = (rb_alloc[0]>>prb) & 1;
       else if (prb < 64)
@@ -4309,22 +4313,22 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 
       if (rb_alloc_ind == 1)
           nb_rb++;
-      
+
 
       if ((frame_parms->N_RB_DL&1) == 0) {  // even number of RBs
 
 	// PBCH
-	if ((subframe==0) && 
-	    (prb>=((frame_parms->N_RB_DL>>1)-3)) && 
-	    (prb<((frame_parms->N_RB_DL>>1)+3)) && 
-	    (l>=(nsymb>>1)) && 
+	if ((subframe==0) &&
+	    (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
+	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+	    (l>=(nsymb>>1)) &&
 	    (l<((nsymb>>1) + 4))) {
 	  rb_alloc_ind = 0;
 	  //	printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb);
 	}
-	
+
 	//SSS
-	
+
 	if (((subframe==0)||(subframe==5)) &&
 	    (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
 	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
@@ -4332,59 +4336,59 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 	  rb_alloc_ind = 0;
 	  //	printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb);
 	}
-	
-	
-	
+
+
+
 	//PSS in subframe 0/5 if FDD
 	if (frame_parms->frame_type == FDD) {  //FDD
-	  if (((subframe==0)||(subframe==5)) && 
-	      (prb>=((frame_parms->N_RB_DL>>1)-3)) && 
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) && 
+	  if (((subframe==0)||(subframe==5)) &&
+	      (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
+	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
 	      (l==pss_symb) ) {
 	    rb_alloc_ind = 0;
 	    //	  printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb);
 	  }
 	}
-	
+
 	if ((frame_parms->frame_type == TDD) &&
 	    (subframe==6)) { //TDD Subframe 6
-	  if ((prb>=((frame_parms->N_RB_DL>>1)-3)) && 
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) && 
+	  if ((prb>=((frame_parms->N_RB_DL>>1)-3)) &&
+	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
 	      (l==pss_symb) ) {
 	    rb_alloc_ind = 0;
 	  }
 	}
-	
+
 	if (rb_alloc_ind==1) {              // PRB is allocated
 
 
-	  
+
 	  prb_off      = 12*prb;
 	  prb_off2     = 1+(12*(prb-(frame_parms->N_RB_DL>>1)));
 	  dl_ch0p    = dl_ch0+(12*prb);
 	  dl_ch1p    = dl_ch1+(12*prb);
 	  if (prb<(frame_parms->N_RB_DL>>1)){
 	    rxF      = &rxdataF[aarx][prb_off+
-				      frame_parms->first_carrier_offset + 
+				      frame_parms->first_carrier_offset +
 				      (symbol*(frame_parms->ofdm_symbol_size))];
 	  }
 	  else {
 	    rxF      = &rxdataF[aarx][prb_off2+
 				      (symbol*(frame_parms->ofdm_symbol_size))];
 	  }
-	 
+
 	 /*
 	 if (mimo_mode <= PUSCH_PRECODING1)
           *pmi_loc = (pmi>>((prb>>2)<<1))&3;
 	 else
 	  *pmi_loc=(pmi>>prb)&1;*/
-	 
+
 	 *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb);
           pmi_loc++;
-	  
-	  
+
+
           if (pilots == 0) {
-	    
+
             memcpy(dl_ch0_ext,dl_ch0p,12*sizeof(int));
             memcpy(dl_ch1_ext,dl_ch1p,12*sizeof(int));
             memcpy(rxF_ext,rxF,12*sizeof(int));
@@ -4414,17 +4418,17 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 
 
       // PBCH
-	if ((subframe==0) && 
-	    (prb>((frame_parms->N_RB_DL>>1)-3)) && 
-	    (prb<((frame_parms->N_RB_DL>>1)+3)) && 
-	    (l>=(nsymb>>1)) && 
+	if ((subframe==0) &&
+	    (prb>((frame_parms->N_RB_DL>>1)-3)) &&
+	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+	    (l>=(nsymb>>1)) &&
 	    (l<((nsymb>>1) + 4))) {
 	  rb_alloc_ind = 0;
 	  //	printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb);
 	}
-	
+
 	//SSS
-	
+
 	if (((subframe==0)||(subframe==5)) &&
 	    (prb>((frame_parms->N_RB_DL>>1)-3)) &&
 	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
@@ -4432,24 +4436,24 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 	  rb_alloc_ind = 0;
 	  //	printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb);
 	}
-	
-	
-	
+
+
+
 	//PSS in subframe 0/5 if FDD
 	if (frame_parms->frame_type == FDD) {  //FDD
-	  if (((subframe==0)||(subframe==5)) && 
-	      (prb>((frame_parms->N_RB_DL>>1)-3)) && 
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) && 
+	  if (((subframe==0)||(subframe==5)) &&
+	      (prb>((frame_parms->N_RB_DL>>1)-3)) &&
+	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
 	      (l==pss_symb) ) {
 	    rb_alloc_ind = 0;
 	    //	  printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb);
 	  }
 	}
-	
+
 	if ((frame_parms->frame_type == TDD) &&
 	    ((subframe==1) || (subframe==6))) { //TDD Subframe 1-6
-	  if ((prb>((frame_parms->N_RB_DL>>1)-3)) && 
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) && 
+	  if ((prb>((frame_parms->N_RB_DL>>1)-3)) &&
+	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
 	      (l==pss_symb) ) {
 	    rb_alloc_ind = 0;
 	  }
@@ -4457,23 +4461,23 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 
 	if (rb_alloc_ind == 1) {
 	  skip_half=0;
-	
+
 	  //Check if we have to drop half a PRB due to PSS/SSS/PBCH
 	  // skip_half == 0 means full PRB
 	  // skip_half == 1 means first half is used (leftmost half-PRB from PSS/SSS/PBCH)
 	  // skip_half == 2 means second half is used (rightmost half-PRB from PSS/SSS/PBCH)
 	  //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
-	  if ((subframe==0) && 
-	      (prb==((frame_parms->N_RB_DL>>1)-3)) && 
-	      (l>=(nsymb>>1)) && 
+	  if ((subframe==0) &&
+	      (prb==((frame_parms->N_RB_DL>>1)-3)) &&
+	      (l>=(nsymb>>1)) &&
 	      (l<((nsymb>>1) + 4)))
 	    skip_half=1;
-	  else if ((subframe==0) && 
-		   (prb==((frame_parms->N_RB_DL>>1)+3)) && 
-		   (l>=(nsymb>>1)) && 
+	  else if ((subframe==0) &&
+		   (prb==((frame_parms->N_RB_DL>>1)+3)) &&
+		   (l>=(nsymb>>1)) &&
 		   (l<((nsymb>>1) + 4)))
 	    skip_half=2;
-	  
+
 	  //SSS
 	  if (((subframe==0)||(subframe==5)) &&
 	      (prb==((frame_parms->N_RB_DL>>1)-3)) &&
@@ -4483,34 +4487,34 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 		   (prb==((frame_parms->N_RB_DL>>1)+3)) &&
 		   (l==sss_symb))
 	    skip_half=2;
-	  
+
 	  //PSS Subframe 0,5
 	  if (((frame_parms->frame_type == FDD) &&
 	       (((subframe==0)||(subframe==5)))) ||  //FDD Subframes 0,5
 	      ((frame_parms->frame_type == TDD) &&
 	       (((subframe==1) || (subframe==6))))) { //TDD Subframes 1,6
-		
-	    if ((prb==((frame_parms->N_RB_DL>>1)-3)) && 
+
+	    if ((prb==((frame_parms->N_RB_DL>>1)-3)) &&
 		(l==pss_symb))
 	      skip_half=1;
-	    else if ((prb==((frame_parms->N_RB_DL>>1)+3)) && 
+	    else if ((prb==((frame_parms->N_RB_DL>>1)+3)) &&
 		     (l==pss_symb))
 	      skip_half=2;
 	  }
-	  
-	  
+
+
 	  prb_off      = 12*prb;
 	  prb_off2     = 7+(12*(prb-(frame_parms->N_RB_DL>>1)-1));
 	  dl_ch0p      = dl_ch0+(12*prb);
 	  dl_ch1p      = dl_ch1+(12*prb);
-	  
+
 	  if (prb<=(frame_parms->N_RB_DL>>1)){
 	    rxF      = &rxdataF[aarx][prb_off+
-				      frame_parms->first_carrier_offset + 
+				      frame_parms->first_carrier_offset +
 				      (symbol*(frame_parms->ofdm_symbol_size))];
 	  }
 	  else {
-	    rxF      = &rxdataF[aarx][prb_off2+ 
+	    rxF      = &rxdataF[aarx][prb_off2+
 				      (symbol*(frame_parms->ofdm_symbol_size))];
 	  }
 #ifdef DEBUG_DLSCH_DEMOD
@@ -4563,7 +4567,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 	      }
 	    } else { // pilots=1
 	      j=0;
-	      
+
 	      if (skip_half==1) {
 		for (i=0; i<6; i++) {
 		  if ((i!=frame_parms->nushift) &&
@@ -4615,7 +4619,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 	      } //skip_half==0
 	    } //pilots==1
 	  } else {       // Do middle RB (around DC)
-	    
+
 	    if (pilots==0) {
 	      memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
 	      memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
@@ -4630,12 +4634,12 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 	      dl_ch1_ext+=6;
 	      dl_ch0p+=6;
 	      dl_ch1p+=6;
-	      
+
 	      rxF       = &rxdataF[aarx][1+((symbol*(frame_parms->ofdm_symbol_size)))];
 
 	      memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
 	      memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
-	      memcpy(rxF_ext,rxF,6*sizeof(int32_t));	      
+	      memcpy(rxF_ext,rxF,6*sizeof(int32_t));
 #ifdef DEBUG_DLSCH_DEMOD
 	      for (i=0; i<6; i++) {
 		printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
@@ -4646,7 +4650,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 	      dl_ch1_ext+=6;
 	    } else { // pilots==1
 	      j=0;
-	      
+
 	      for (i=0; i<6; i++) {
 		if ((i!=frame_parms->nushift) &&
 		    (i!=((frame_parms->nushift+3)%6))) {
@@ -4659,27 +4663,27 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 		}
 	      }
 	      rxF       = &rxdataF[aarx][1+symbol*(frame_parms->ofdm_symbol_size)];
-	      
+
 	      for (; i<12; i++) {
 		if ((i!=((frame_parms->nushift+6)%12)) &&
 		    (i!=((frame_parms->nushift+9)%12))) {
 		  dl_ch0_ext[j]=dl_ch0p[i];
 		  dl_ch1_ext[j]=dl_ch1p[i];
-		  rxF_ext[j++]=rxF[i-6];	   
+		  rxF_ext[j++]=rxF[i-6];
 #ifdef DEBUG_DLSCH_DEMOD
 		  printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[1+i-6],*(1+(short*)&rxF[1+i-6]));
 #endif
 		}
 	      }
-	      
+
 	      dl_ch0_ext+=8;
 	      dl_ch1_ext+=8;
 	      rxF_ext+=8;
 	    } //pilots==1
 	  }  // if Middle PRB
-	} // if odd PRB	      	      	         
+	} // if odd PRB
       } // if rballoc==1
-    } // for prb 
+    } // for prb
   } // for aarx
   return(nb_rb/frame_parms->nb_antennas_rx);
 }
@@ -4741,12 +4745,12 @@ void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per
   sprintf(fname,"dlsch%d_r%d_rho2.m",eNB_id,round);
   sprintf(vname,"dl_rho2_r%d_%d",eNB_id,round);
   write_output(fname,vname,phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[0],12*N_RB_DL*nsymb,1,1);
-  
-  
+
+
  // sprintf(fname,"dlsch%d_r%d_aver_chan_1.m",eNB_id,round);
  // sprintf(vname,"dl_aver_ch1_r%d_%d",eNB_id,round);
  // write_output(fname,vname,&avg_1[0],1,1,1);
-  
+
   sprintf(fname,"dlsch%d_rxF_r%d_comp0.m",eNB_id,round);
   sprintf(vname,"dl%d_rxF_r%d_comp0",eNB_id,round);
   write_output(fname,vname,phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0],12*N_RB_DL*nsymb,1,1);
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
index 781add5d95c05508cabda86e137a8fb696f6bd98..4c70f0823075cad3ccc7e81faf56013cc99ee08e 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
@@ -155,13 +155,13 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 {
 
 
-  uint8_t *x0             = dlsch0_harq->e;
-  MIMO_mode_t mimo_mode   = dlsch0_harq->mimo_mode;
+  uint8_t *x0 = NULL; //dlsch0_harq->e;
+  MIMO_mode_t mimo_mode = dlsch0_harq->mimo_mode;
 
-  int first_layer0        = dlsch0_harq->first_layer;
-  int Nlayers0            = dlsch0_harq->Nlayers;
-  uint8_t mod_order0      = get_Qm(dlsch0_harq->mcs);
-  uint8_t mod_order1=2;
+  int first_layer0; //= dlsch0_harq->first_layer;
+  int Nlayers0; //  = dlsch0_harq->Nlayers;
+  uint8_t mod_order0; // = get_Qm(dlsch0_harq->mcs);
+  uint8_t mod_order1; //=2;
   uint8_t precoder_index0,precoder_index1;
 
   uint8_t *x1=NULL;
@@ -199,15 +199,40 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
   gain_lin_QPSK = (int16_t)((amp*ONE_OVER_SQRT2_Q15)>>15);
   //  if (mimo_mode == LARGE_CDD) gain_lin_QPSK>>=1;
 
-  if (dlsch1_harq) {
+
+
+  if ((dlsch0_harq != NULL) && (dlsch1_harq != NULL)) { //this is for TM3, TM4
+
+    x0 = dlsch0_harq->e;
+    mimo_mode = dlsch0_harq->mimo_mode;
+    first_layer0 = dlsch0_harq->first_layer;
+    Nlayers0 = dlsch0_harq->Nlayers;
+    mod_order0 = get_Qm(dlsch0_harq->mcs);
     x1             = dlsch1_harq->e;
     // Fill these in later for TM8-10
     //    Nlayers1       = dlsch1_harq->Nlayers;
     //    first_layer1   = dlsch1_harq->first_layer;
     mod_order1     = get_Qm(dlsch1_harq->mcs);
 
+  } else if ((dlsch0_harq != NULL) && (dlsch1_harq == NULL)){ //This is for SIS0 TM1, TM6, etc
+
+    x0 = dlsch0_harq->e;
+    mimo_mode = dlsch0_harq->mimo_mode;
+    first_layer0 = dlsch0_harq->first_layer;
+    Nlayers0 = dlsch0_harq->Nlayers;
+    mod_order0 = get_Qm(dlsch0_harq->mcs);
+
+  } else if ((dlsch0_harq == NULL) && (dlsch1_harq != NULL)){ // This is for TM4 retransmission
+
+    x0 = dlsch1_harq->e;
+    mimo_mode = dlsch1_harq->mimo_mode;
+    first_layer0 = dlsch1_harq->first_layer;
+    Nlayers0 = dlsch1_harq->Nlayers;
+    mod_order0 = get_Qm(dlsch1_harq->mcs);
+
   }
 
+
   /*
   switch (mod_order) {
   case 2:
@@ -229,9 +254,16 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
   }
   */
 
-#ifdef DEBUG_DLSCH_MODULATION
-  printf("allocate_re (mod %d): symbol_offset %d re_offset %d (%d,%d), jj %d -> %d,%d\n",mod_order0,symbol_offset,re_offset,skip_dc,skip_half,*jj, x0[*jj], x0[1+*jj]);
-#endif
+  if (dlsch0_harq != NULL){
+    #ifdef DEBUG_DLSCH_MODULATION
+      printf("allocate_re (mod %d): symbol_offset %d re_offset %d (%d,%d), jj %d -> %d,%d\n",mod_order0,symbol_offset,re_offset,skip_dc,skip_half,*jj, x0[*jj], x0[1+*jj]);
+    #endif
+  } else{
+    #ifdef DEBUG_DLSCH_MODULATION
+      printf("allocate_re (mod %d): symbol_offset %d re_offset %d (%d,%d), jj %d -> %d,%d\n",mod_order0,symbol_offset,re_offset,skip_dc,skip_half,*jj, x0[*jj], x0[1+*jj]);
+    #endif
+  }
+
 
   first_re=0;
   last_re=12;
@@ -360,7 +392,7 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 
       else if (mimo_mode == ALAMOUTI) {
         *re_allocated = *re_allocated + 1;
-      
+
         amp = (int16_t)(((int32_t)tmp_amp*ONE_OVER_SQRT2_Q15)>>15);
 
 
@@ -386,23 +418,23 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           ((int16_t*)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_SQRT2_Q15)>>15);
           ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_SQRT2_Q15)>>15);
           ((int16_t*)&txdataF[1][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample2)[1]*ONE_OVER_SQRT2_Q15)>>15);
-    
+
         break;
-    
+
         case 4:  //16QAM
-    
-          // Antenna 0 position n 
+
+          // Antenna 0 position n
           qam16_table_offset_re = 0;
           qam16_table_offset_im = 0;
-         
+
           if (x0[*jj] == 1)
             qam16_table_offset_re+=2;
           *jj=*jj+1;
           if (x0[*jj] == 1)
             qam16_table_offset_im+=2;
           *jj=*jj+1;
-          
-          
+
+
           if (x0[*jj] == 1)
             qam16_table_offset_re+=1;
           *jj=*jj+1;
@@ -412,12 +444,12 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 
           ((int16_t *)&txdataF[0][tti_offset])[0]+=(int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_re])>>15);
           ((int16_t *)&txdataF[0][tti_offset])[1]+=(int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_im])>>15);
-	  
+
     //((int16_t *)&txdataF[0][tti_offset])[0]+=(qam_table_s0[qam16_table_offset_re]*ONE_OVER_SQRT2_Q15)>>15;
-	  //((int16_t *)&txdataF[0][tti_offset])[1]+=(qam_table_s0[qam16_table_offset_im]*ONE_OVER_SQRT2_Q15)>>15;
+    //((int16_t *)&txdataF[0][tti_offset])[1]+=(qam_table_s0[qam16_table_offset_im]*ONE_OVER_SQRT2_Q15)>>15;
 
           // Antenna 1 position n Real part -> -x1*
-          
+
           qam16_table_offset_re = 0;
           qam16_table_offset_im = 0;
 
@@ -427,8 +459,8 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           if (x0[*jj] == 1)
             qam16_table_offset_im+=2;
           *jj=*jj+1;
-          
-          
+
+
           if (x0[*jj] == 1)
             qam16_table_offset_re+=1;
           *jj=*jj+1;
@@ -439,13 +471,13 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           ((int16_t *)&txdataF[1][tti_offset])[0]+=-(int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_re])>>15);
           ((int16_t *)&txdataF[1][tti_offset])[1]+=(int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_im])>>15);
 
-	       //((int16_t *)&txdataF[1][tti_offset])[0]+=-qam_table_s0[qam16_table_offset_re];
-	       //((int16_t *)&txdataF[1][tti_offset])[1]+=qam_table_s0[qam16_table_offset_im];
+         //((int16_t *)&txdataF[1][tti_offset])[0]+=-qam_table_s0[qam16_table_offset_re];
+         //((int16_t *)&txdataF[1][tti_offset])[1]+=qam_table_s0[qam16_table_offset_im];
 
           break;
 
         case 6:   // 64-QAM
-          
+
           // Antenna 0
           qam64_table_offset_re = 0;
           qam64_table_offset_im = 0;
@@ -468,11 +500,11 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           if (x0[*jj] == 1)
             qam64_table_offset_im+=1;
           *jj=*jj+1;
-          
+
           //((int16_t *)&txdataF[0][tti_offset])[0]+=(int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_re])>>15);
           //((int16_t *)&txdataF[0][tti_offset])[1]+=(int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_im])>>15);
-	        ((int16_t *)&txdataF[0][tti_offset])[0]+=(qam_table_s0[qam64_table_offset_re]*ONE_OVER_SQRT2_Q15)>>15;
-	        ((int16_t *)&txdataF[0][tti_offset])[1]+=(qam_table_s0[qam64_table_offset_im]*ONE_OVER_SQRT2_Q15)>>15;
+          ((int16_t *)&txdataF[0][tti_offset])[0]+=(qam_table_s0[qam64_table_offset_re]*ONE_OVER_SQRT2_Q15)>>15;
+          ((int16_t *)&txdataF[0][tti_offset])[1]+=(qam_table_s0[qam64_table_offset_im]*ONE_OVER_SQRT2_Q15)>>15;
 
           // Antenna 1 => -x1*
           qam64_table_offset_re = 0;
@@ -498,12 +530,12 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 
           //((int16_t *)&txdataF[1][tti_offset])[0]+=-(int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_re])>>15);
           //((int16_t *)&txdataF[1][tti_offset])[1]+=(int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_im])>>15);
-	       ((int16_t *)&txdataF[1][tti_offset])[0]+=-qam_table_s0[qam64_table_offset_re];
-	       ((int16_t *)&txdataF[1][tti_offset])[1]+=qam_table_s0[qam64_table_offset_im];
-          
+         ((int16_t *)&txdataF[1][tti_offset])[0]+=-qam_table_s0[qam64_table_offset_re];
+         ((int16_t *)&txdataF[1][tti_offset])[1]+=qam_table_s0[qam64_table_offset_im];
+
           break;
         }
-	// fill in the rest of the ALAMOUTI precoding
+  // fill in the rest of the ALAMOUTI precoding
         if (is_not_pilot(pilots,re + 1,frame_parms->nushift,use2ndpilots)==1) {
           ((int16_t *)&txdataF[0][tti_offset+1])[0] += -((int16_t *)&txdataF[1][tti_offset])[0]; //x1
           ((int16_t *)&txdataF[0][tti_offset+1])[1] += ((int16_t *)&txdataF[1][tti_offset])[1];
@@ -537,9 +569,9 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             *jj = *jj + 1;
             //printf("%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
             break;
-        
+
           case 4:  //16QAM
-            
+
             qam16_table_offset_re0 = 0;
             qam16_table_offset_im0 = 0;
             if (x0[*jj] == 1)
@@ -548,25 +580,25 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             if (x0[*jj] == 1)
               qam16_table_offset_im0+=2;
             *jj=*jj+1;
-            
+
             if (x0[*jj] == 1)
               qam16_table_offset_re0+=1;
             *jj=*jj+1;
             if (x0[*jj] == 1)
               qam16_table_offset_im0+=1;
             *jj=*jj+1;
-            
+
             xx0_re = qam_table_s0[qam16_table_offset_re0];
             xx0_im = qam_table_s0[qam16_table_offset_im0];
 
             break;
-            
+
           case 6:  //64QAM
-            
-            
+
+
             qam64_table_offset_re0 = 0;
             qam64_table_offset_im0 = 0;
-            
+
             if (x0[*jj] == 1)
               qam64_table_offset_re0+=4;
             *jj=*jj+1;
@@ -590,7 +622,7 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             xx0_im = qam_table_s0[qam64_table_offset_im0];
 
             break;
-            
+
           }
 
           switch (mod_order1) {
@@ -602,15 +634,15 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 
           case 2:  //QPSK
             //printf("%d(%d) : %d,%d => ",tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
-            xx1_re = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; 
+            xx1_re = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
             *jj2 = *jj2 + 1;
-            xx1_im = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; 
+            xx1_im = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
             *jj2 = *jj2 + 1;
             //printf("%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
             break;
-            
+
           case 4:  //16QAM
-            
+
             qam16_table_offset_re1 = 0;
             qam16_table_offset_im1 = 0;
             if (x1[*jj2] == 1)
@@ -630,12 +662,12 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             xx1_im = qam_table_s1[qam16_table_offset_im1];
 
             break;
-            
+
           case 6:  //64QAM
-            
+
             qam64_table_offset_re1 = 0;
             qam64_table_offset_im1 = 0;
-            
+
             if (x1[*jj2] == 1)
               qam64_table_offset_re1+=4;
             *jj2 = *jj2 + 1;
@@ -659,14 +691,14 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             xx1_im = qam_table_s1[qam64_table_offset_im1];
 
             break;
-            
+
           }
 
           // This implements the Large CDD precoding for 2 TX antennas
           // -  -        -    -  -         -  -     -  -  -       -              -
           //| y0 |      | 1  0 || 1    0    || 1   1 || x0 |     |        x0 + x1 |
           //| y1 | = .5 | 0  1 || 0  (-1)^i || 1  -1 || x1 | = .5| (-1)^i(x0 - x1)|
-          // -  -        -    -  -         -  -     -  -  -       - 
+          // -  -        -    -  -         -  -     -  -  -       -
           // Note: Factor .5 is accounted for in amplitude when calling this function
           ((int16_t *)&txdataF[0][tti_offset])[0]+=((xx0_re+xx1_re)>>1);
           ((int16_t *)&txdataF[1][tti_offset])[0]+=(s*((xx0_re-xx1_re)>>1));
@@ -681,9 +713,9 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           s = -s;
         }
       }
-      else if ((mimo_mode >= UNIFORM_PRECODING11)&&(mimo_mode <= PUSCH_PRECODING1)) { 
+      else if ((mimo_mode >= UNIFORM_PRECODING11)&&(mimo_mode <= PUSCH_PRECODING1)) {
   // this is for transmission modes 5-6 (1 layer)
-        *re_allocated = *re_allocated + 1;           
+        *re_allocated = *re_allocated + 1;
         amp = (int16_t)(((int32_t)tmp_amp*ONE_OVER_SQRT2_Q15)>>15);
 
         switch (mod_order0) {
@@ -705,9 +737,9 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           }
 
           break;
-          
+
         case 4:
-          
+
           qam16_table_offset_re = 0;
           qam16_table_offset_im = 0;
 
@@ -717,22 +749,22 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           if (x0[*jj] == 1)
             qam16_table_offset_im+=2;
           *jj=*jj+1;
-          
-          
+
+
           if (x0[*jj] == 1)
             qam16_table_offset_re+=1;
           *jj=*jj+1;
           if (x0[*jj] == 1)
             qam16_table_offset_im+=1;
           *jj=*jj+1;
-          
-            
+
+
            ((int16_t*)&tmp_sample1)[0] = (int16_t)((qam_table_s0[qam16_table_offset_re]));
            ((int16_t*)&tmp_sample1)[1] = (int16_t)((qam_table_s0[qam16_table_offset_im]));
 
            ((int16_t *)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_SQRT2_Q15)>>15);
            ((int16_t *)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_SQRT2_Q15)>>15);
-          
+
           if (frame_parms->nb_antennas_tx == 2) {
             layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index);
             ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_SQRT2_Q15)>>15);
@@ -740,7 +772,7 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           }
 
           break;
-          
+
         case 6:
 
           qam64_table_offset_re = 0;
@@ -763,25 +795,25 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           if (x0[*jj] == 1)
             qam64_table_offset_im+=1;
           *jj=*jj+1;
-          
+
           ((int16_t*)&tmp_sample1)[0] = (int16_t)((qam_table_s0[qam64_table_offset_re]));
           ((int16_t*)&tmp_sample1)[1] = (int16_t)((qam_table_s0[qam64_table_offset_im]));
 
           ((int16_t *)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_SQRT2_Q15)>>15);
           ((int16_t *)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_SQRT2_Q15)>>15);
-          
+
           if (frame_parms->nb_antennas_tx == 2) {
             layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index);
             ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_SQRT2_Q15)>>15);
             ((int16_t*)&txdataF[1][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample2)[1]*ONE_OVER_SQRT2_Q15)>>15);
           }
-          
+
           break;
         }
       }
       else if ((mimo_mode >= DUALSTREAM_UNIFORM_PRECODING1)&&(mimo_mode <= DUALSTREAM_PUSCH_PRECODING)) {
   // this is for transmission mode 4 (1 layer)
-        *re_allocated = *re_allocated + 1;           
+        *re_allocated = *re_allocated + 1;
 
         if (precoder_index==0) {
           precoder_index0 = 0; //[1 1]
@@ -809,7 +841,7 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           ((int16_t*)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_2_Q15)>>15);
 
           //printf("%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
-         
+
           if (frame_parms->nb_antennas_tx == 2) {
             layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index0);
             ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_2_Q15)>>15);
@@ -817,9 +849,9 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           }
 
         break;
-          
+
         case 4:
-          
+
           qam16_table_offset_re = 0;
           qam16_table_offset_im = 0;
 
@@ -829,19 +861,19 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           if (x0[*jj] == 1)
             qam16_table_offset_im+=2;
           *jj=*jj+1;
-          
+
           if (x0[*jj] == 1)
             qam16_table_offset_re+=1;
           *jj=*jj+1;
           if (x0[*jj] == 1)
             qam16_table_offset_im+=1;
           *jj=*jj+1;
-          
+
            ((int16_t*)&tmp_sample1)[0] = (int16_t)((qam_table_s0[qam16_table_offset_re]));
            ((int16_t*)&tmp_sample1)[1] = (int16_t)((qam_table_s0[qam16_table_offset_im]));
            ((int16_t *)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_2_Q15)>>15);
            ((int16_t *)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_2_Q15)>>15);
-          
+
           if (frame_parms->nb_antennas_tx == 2) {
             layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index0);
             ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_2_Q15)>>15);
@@ -849,9 +881,9 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           }
 
           break;
-          
+
         case 6:
-          
+
           qam64_table_offset_re = 0;
           qam64_table_offset_im = 0;
 
@@ -873,25 +905,25 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
           if (x0[*jj] == 1)
             qam64_table_offset_im+=1;
           *jj=*jj+1;
-          
+
           ((int16_t*)&tmp_sample1)[0] = (int16_t)((qam_table_s0[qam64_table_offset_re]));
           ((int16_t*)&tmp_sample1)[1] = (int16_t)((qam_table_s0[qam64_table_offset_im]));
           ((int16_t *)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_2_Q15)>>15);
           ((int16_t *)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_2_Q15)>>15);
-          
+
           if (frame_parms->nb_antennas_tx == 2) {
             layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index0);
             ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_2_Q15)>>15);
             ((int16_t*)&txdataF[1][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample2)[1]*ONE_OVER_2_Q15)>>15);
           }
-          
+
           break;
-          
+
         }
-        
+
         if (dlsch1_harq) {
           switch (mod_order1) {
-         
+
           case 2:
 
             ((int16_t*)&tmp_sample1)[0] = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
@@ -910,9 +942,9 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             }
 
             break;
-            
+
           case 4:
-            
+
             qam16_table_offset_re = 0;
             qam16_table_offset_im = 0;
 
@@ -922,20 +954,20 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             if (x1[*jj2] == 1)
               qam16_table_offset_im+=2;
             *jj2=*jj2+1;
-            
-            
+
+
             if (x1[*jj2] == 1)
               qam16_table_offset_re+=1;
             *jj2=*jj2+1;
             if (x1[*jj2] == 1)
               qam16_table_offset_im+=1;
             *jj2=*jj2+1;
-            
+
              ((int16_t*)&tmp_sample1)[0] = (int16_t)((qam_table_s1[qam16_table_offset_re]));
              ((int16_t*)&tmp_sample1)[1] = (int16_t)((qam_table_s1[qam16_table_offset_im]));
              ((int16_t *)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_2_Q15)>>15);
              ((int16_t *)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_2_Q15)>>15);
-            
+
             if (frame_parms->nb_antennas_tx == 2) {
               layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index1);
               ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_2_Q15)>>15);
@@ -943,9 +975,9 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             }
 
             break;
-            
+
           case 6:
-            
+
             qam64_table_offset_re = 0;
             qam64_table_offset_im = 0;
             if (x1[*jj2] == 1)
@@ -966,20 +998,20 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
             if (x1[*jj2] == 1)
               qam64_table_offset_im+=1;
             *jj2=*jj2+1;
-            
+
             ((int16_t*)&tmp_sample1)[0] = (int16_t)((qam_table_s1[qam64_table_offset_re]));
             ((int16_t*)&tmp_sample1)[1] = (int16_t)((qam_table_s1[qam64_table_offset_im]));
             ((int16_t *)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_2_Q15)>>15);
             ((int16_t *)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_2_Q15)>>15);
-            
+
             if (frame_parms->nb_antennas_tx == 2) {
               layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index1);
               ((int16_t*)&txdataF[1][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample2)[0]*ONE_OVER_2_Q15)>>15);
               ((int16_t*)&txdataF[1][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample2)[1]*ONE_OVER_2_Q15)>>15);
             }
-            
+
             break;
-            
+
           }
         }
       }
@@ -1097,7 +1129,6 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
   return(0);
 }
 
-
 int allocate_REs_in_RB_MCH(int32_t **txdataF,
                            uint32_t *jj,
                            uint16_t re_offset,
@@ -1305,32 +1336,75 @@ int dlsch_modulation(int32_t **txdataF,
 {
 
   uint8_t nsymb;
-  uint8_t harq_pid = dlsch0->current_harq_pid;
-  LTE_DL_eNB_HARQ_t *dlsch0_harq = dlsch0->harq_processes[harq_pid];
+  uint8_t harq_pid; //= dlsch0->current_harq_pid;
+  LTE_DL_eNB_HARQ_t *dlsch0_harq;
   LTE_DL_eNB_HARQ_t *dlsch1_harq; //= dlsch1->harq_processes[harq_pid];
   uint32_t i,jj,jj2,re_allocated,symbol_offset;
   uint16_t l,rb,re_offset;
   uint32_t rb_alloc_ind;
-  uint32_t *rb_alloc = dlsch0_harq->rb_alloc;
+  uint32_t *rb_alloc; //=dlsch0_harq->rb_alloc;
+
   uint8_t pilots=0;
   uint8_t skip_dc,skip_half;
-  uint8_t mod_order0 = get_Qm(dlsch0_harq->mcs);
+  uint8_t mod_order0 = 0;
   uint8_t mod_order1 = 0;
   int16_t amp_rho_a, amp_rho_b;
   int16_t qam16_table_a0[4],qam64_table_a0[8],qam16_table_b0[4],qam64_table_b0[8];
   int16_t qam16_table_a1[4],qam64_table_a1[8],qam16_table_b1[4],qam64_table_b1[8];
   int16_t *qam_table_s0,*qam_table_s1;
+  uint8_t get_pmi_temp;
 #ifdef DEBUG_DLSCH_MODULATION
-  uint8_t Nl0 = dlsch0_harq->Nl;
+  uint8_t Nl0;  //= dlsch0_harq->Nl;
   uint8_t Nl1;
 #endif
 
-  if (dlsch1) {
+  if ((dlsch0 != NULL) && (dlsch1 != NULL)){
+    harq_pid = dlsch0->current_harq_pid;
+    dlsch0_harq = dlsch0->harq_processes[harq_pid];
+    mod_order0 = get_Qm(dlsch0_harq->mcs);
+    rb_alloc = dlsch0_harq->rb_alloc;
+#ifdef DEBUG_DLSCH_MODULATION
+    Nl0 = dlsch0_harq->Nl;
+#endif
+
     dlsch1_harq = dlsch1->harq_processes[harq_pid];
     mod_order1 = get_Qm(dlsch1_harq->mcs);
 #ifdef DEBUG_DLSCH_MODULATION
     Nl1 = dlsch1_harq->Nl;
 #endif
+
+  }else if ((dlsch0 != NULL) && (dlsch1 == NULL)){
+
+    harq_pid = dlsch0->current_harq_pid;
+    dlsch0_harq = dlsch0->harq_processes[harq_pid];
+    mod_order0 = get_Qm(dlsch0_harq->mcs);
+    rb_alloc = dlsch0_harq->rb_alloc;
+#ifdef DEBUG_DLSCH_MODULATION
+    Nl0 = dlsch0_harq->Nl;
+#endif
+
+    dlsch1_harq = NULL;
+    mod_order1 = 0;
+#ifdef DEBUG_DLSCH_MODULATION
+    Nl1 = 0;
+#endif
+
+  }else if ((dlsch0 == NULL) && (dlsch1 != NULL)){
+
+    harq_pid = dlsch1->current_harq_pid;
+    dlsch1_harq = dlsch1->harq_processes[harq_pid];
+    mod_order0 = get_Qm(dlsch1_harq->mcs);
+    rb_alloc = dlsch1_harq->rb_alloc;
+#ifdef DEBUG_DLSCH_MODULATION
+    Nl0 = dlsch1_harq->Nl;
+#endif
+
+    dlsch0_harq = NULL;
+    mod_order1 = 0;
+#ifdef DEBUG_DLSCH_MODULATION
+    Nl1 = NULL;
+#endif
+
   }
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_MODULATION, VCD_FUNCTION_IN);
@@ -1565,7 +1639,7 @@ int dlsch_modulation(int32_t **txdataF,
 
       if (rb_alloc_ind > 0) {
         //    printf("Allocated rb %d/symbol %d, skip_half %d, subframe_offset %d, symbol_offset %d, re_offset %d, jj %d\n",rb,l,skip_half,subframe_offset,symbol_offset,re_offset,jj);
- 
+
       allocate_REs_in_RB(frame_parms,
                          txdataF,
                          &jj,
@@ -1640,29 +1714,29 @@ int dlsch_modulation_SIC(int32_t **sic_buffer,
   amp=1; //we do full scale here for SIC
   gain_lin_QPSK = (int16_t)((ONE_OVER_SQRT2_Q15));
   //printf("gain=%d\n", gain_lin_QPSK);
- 
+
   jj = 0;
   i = 0;
   while (jj <= G-1) {
-       
+
     re_allocated = re_allocated + 1;
 
     switch (mod_order0) {
     case 2:  //QPSK
       /* TODO: handle more than 1 antenna */
       //printf("%d(%d) : %d,%d => ",tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
-        
+
       ((int16_t*)&sic_buffer[0][i])[0] = (x0[jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; //I //b_i
-          
+
       jj = jj + 1;
-          
+
       ((int16_t*)&sic_buffer[0][i])[1] = (x0[jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; //Q //b_{i+1}
-          
+
       jj = jj + 1;
-          
+
       //printf("recon %d,%d\n",((int16_t*)&sic_buffer[0][i])[0],((int16_t*)&sic_buffer[0][i])[1]);
       i++;
-          
+
       break;
 
     case 4:  //16QAM
@@ -1694,8 +1768,8 @@ int dlsch_modulation_SIC(int32_t **sic_buffer,
 
       ((int16_t *)&sic_buffer[0][i])[0]+=qam16_table[qam16_table_offset_re];
       ((int16_t *)&sic_buffer[0][i])[1]+=qam16_table[qam16_table_offset_im];
-      
-      i++; 
+
+      i++;
 
       break;
 
@@ -1737,12 +1811,12 @@ int dlsch_modulation_SIC(int32_t **sic_buffer,
 
       ((int16_t *)&sic_buffer[0][i])[0]+=(qam64_table[qam64_table_offset_re])>>1;//(int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_re])>>15);
       ((int16_t *)&sic_buffer[0][i])[1]+=(qam64_table[qam64_table_offset_im])>>1;//(int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_im])>>15);
-     
+
       i++;
-          
+
       break;
       }
-      
+
     }
 
 
diff --git a/openair1/SIMULATION/LTE_PHY/dlsim.c b/openair1/SIMULATION/LTE_PHY/dlsim.c
index 335002a5eaa52ca95255172a67b74c9fd4fd1664..0b39a3580a3c7813a6daa776338f42bccc23ead4 100755
--- a/openair1/SIMULATION/LTE_PHY/dlsim.c
+++ b/openair1/SIMULATION/LTE_PHY/dlsim.c
@@ -161,6 +161,7 @@ int main(int argc, char **argv)
   uint16_t tdd_config=3;
   uint16_t n_rnti=0x1234;
   int n_users = 1;
+  int TB=0;
   RX_type_t rx_type=rx_standard;
 
 
@@ -170,10 +171,10 @@ int main(int argc, char **argv)
   unsigned char *input_buffer0[2],*input_buffer1[2];
   unsigned short input_buffer_length0,input_buffer_length1;
 
-  /* A variable "ret" is a nuumber of turbo iterations, that are performed in the turbo-decoder for each CW. 
+  /* A variable "ret" is a nuumber of turbo iterations, that are performed in the turbo-decoder for each CW.
   The decoder checks CRC, and if CRC test fails, it increments "ret". Ret is between 1 and 4, where 4 is for
-  the max number of turbo iterations. If the CRC is passed, ret is equal to a current iteration. 
-  This is done separately for each CW inside decoding process. 
+  the max number of turbo iterations. If the CRC is passed, ret is equal to a current iteration.
+  This is done separately for each CW inside decoding process.
   Again: this is not a HARQ retransmission!*/
   unsigned int ret[2];
   unsigned int coded_bits_per_codeword[2],nsymb,dci_cnt,tbs[2];
@@ -258,6 +259,9 @@ int main(int argc, char **argv)
   int llr8_flag=0;
 
   double effective_rate=0.0;
+  double thr_cw0_tm4 = 0.0;
+  double thr_cw0_tm4_nonconst = 0.0;
+  double thr_cw0[4]={0,0,0,0}, thr_cw1[4]={0,0,0,0}, thr_cw0_tot = 0.0, thr_cw1_tot = 0.0;
   char channel_model_input[17]="I";
 
   int TB0_active = 1;
@@ -356,7 +360,7 @@ int main(int argc, char **argv)
       common_flag = 1;
       TPC = atoi(optarg);
       break;
-      
+
     case 'E':
       threequarter_fs=1;
       break;
@@ -427,7 +431,7 @@ int main(int argc, char **argv)
     case 'w':
       snr_int = atof(optarg);
       break;
- 
+
     case 'N':
       n_ch_rlz= atof(optarg);
       break;
@@ -455,10 +459,10 @@ int main(int argc, char **argv)
       case 'E':
         channel_model=EPA;
         break;
-      case 'F': 
+      case 'F':
         channel_model=EVA;
         break;
-      case 'G': 
+      case 'G':
         channel_model=ETU;
         break;
       case 'H':
@@ -534,7 +538,7 @@ int main(int argc, char **argv)
         exit(-1);
       }
       break;
-    
+
       case 'R':
         num_rounds=atoi(optarg);
         break;
@@ -543,7 +547,7 @@ int main(int argc, char **argv)
         break;
       case 'T':
         n_rnti=atoi(optarg);
-        break;  
+        break;
       case 'u':
         rx_type = (RX_type_t) atoi(optarg);
         if (rx_type<rx_standard || rx_type>rx_SIC_dual_stream) {
@@ -572,7 +576,7 @@ int main(int argc, char **argv)
         break;
       case 'V':
         interf_unaw_shift0=atoi(optarg);
-        break;   
+        break;
       case 'W':
         interf_unaw_shift1=atoi(optarg);
         break;
@@ -608,10 +612,10 @@ int main(int argc, char **argv)
       printf("-u Receiver type: 0=standard, 1 = single stream IC (for TM3,4,5,6), 2 = dual stream IC (for TM3,4), 3 = SIC (for TM3,4) \n");
       exit(1);
       break;
-    
+
     }
   }
-    
+
   if (common_flag == 0) {
     switch (N_RB_DL) {
     case 6:
@@ -636,7 +640,7 @@ int main(int argc, char **argv)
   } else
     NB_RB = 4;
 
-  NB_RB=conv_nprb(0,DLSCH_RB_ALLOC,N_RB_DL); 
+  NB_RB=conv_nprb(0,DLSCH_RB_ALLOC,N_RB_DL);
 
   if ((transmission_mode > 1) && (n_tx != 2)) {
 
@@ -671,12 +675,12 @@ int main(int argc, char **argv)
   */
   }
 
-  if (transmission_mode==5) { 
+  if (transmission_mode==5) {
     n_users = 2;
     eNB_id_i = PHY_vars_UE->n_connected_eNB;
     //eNB_id_i=1;
   }
-  else 
+  else
     eNB_id_i = eNB_id;
 
   lte_param_init(n_tx,
@@ -730,7 +734,7 @@ int main(int argc, char **argv)
    SCM_A, SCM_B, SCM_C, SCM_D, EPA, EVA, ETU, Rayleigh8, Rayleigh1, Rayleigh1_corr, Rayleigh1_anticorr, Rice1, Rice8, Rayleigh1_orthogonal, Rayleigh1_orth_eff_ch_TM4_prec_real, Rayleigh1_orth_eff_ch_TM4_prec_imag, Rayleigh8_orth_eff_ch_TM4_prec_real, Rayleigh8_orth_eff_ch_TM4_prec_imag, TS_SHIFT);
   if(transmission_mode==5)
     sprintf(bler_fname,"bler_tx%d_rec%d_chan%d_nrx%d_mcs%d_mcsi%d_u%d_imod%d.csv",transmission_mode,rx_type,channel_model,n_rx,mcs1,mcs_i,rx_type,i_mod);
-  else if (abstx == 1) 
+  else if (abstx == 1)
     if (perfect_ce==1)
    sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_ab_pce_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx,mcs1, mcs2,interf_unaw_shift );
     else
@@ -740,7 +744,7 @@ int main(int argc, char **argv)
       sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_pce_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx,mcs1, mcs2, interf_unaw_shift);
    else
     sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames,n_rx,mcs1, mcs2, interf_unaw_shift);
-  
+
   bler_fd = fopen(bler_fname,"w");
   if (bler_fd==NULL) {
     fprintf(stderr,"Cannot create file %s!\n",bler_fname);
@@ -749,7 +753,7 @@ int main(int argc, char **argv)
 
   fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate 0; rate 1; err0_st1; err0_st2 trials0; err1_st1; err1_st2; trials1; err2_st1; err2_st2; trials2; err3_st1; err3_st2; trials3; throug 0; throug 1; sum throug; dci_err\n");
   if (test_perf != 0) {
-    
+
     char hostname[1024];
 
     hostname[1023] = '\0';
@@ -766,14 +770,14 @@ int main(int argc, char **argv)
       exit(-1);
     }
   }
-  
+
   if(abstx){
     // CSV file  // add here second stream mcs
-    
+
     if (transmission_mode == 5)
       sprintf(csv_fname,"dataout_tx%d_u2%d_mcs%d_chan%d_nsimus%d_R%d_abstr.m",transmission_mode,rx_type,mcs1,channel_model,n_frames,num_rounds);
-    
-    else 
+
+    else
       if (perfect_ce==1)
         sprintf(csv_fname,"dout_tx%d_r%d_mcs%d_mcsi%d_ch%d_ns%d_R%d_pce_sh%d_%d_pnort_r45.m",transmission_mode,rx_type,mcs1,mcs2,channel_model,n_frames,num_rounds, interf_unaw_shift, n_ch_rlz);
       else
@@ -901,7 +905,7 @@ n(tikz_fname,"w");
   PHY_vars_UE->transmission_mode[eNB_id]=transmission_mode;
   if (PHY_vars_UE->transmission_mode[eNB_id] !=4) // add TM3 exception
       PHY_vars_UE->PHY_measurements.rank[eNB_id]=0;
-  else 
+  else
       PHY_vars_UE->PHY_measurements.rank[eNB_id]=1;
   // Fill in UL_alloc
   UL_alloc_pdu.type    = 0;
@@ -911,7 +915,7 @@ n(tikz_fname,"w");
   UL_alloc_pdu.ndi     = 1;
   UL_alloc_pdu.TPC     = 0;
   UL_alloc_pdu.cqi_req = 1;
-  
+
   CCCH_alloc_pdu.type               = 0;
   CCCH_alloc_pdu.vrb_type           = 0;
   CCCH_alloc_pdu.rballoc            = CCCH_RB_ALLOC;
@@ -966,7 +970,7 @@ n(tikz_fname,"w");
                                          rx_sample_offset,
                                          0);
   }
-  
+
 
 
   if (eNB2UE[0]==NULL) {
@@ -974,7 +978,7 @@ n(tikz_fname,"w");
     exit(-1);
   }
 
-  if ((transmission_mode == 3) || (transmission_mode==4) || (transmission_mode==8))  
+  if ((transmission_mode == 3) || (transmission_mode==4) || (transmission_mode==8))
     Kmimo=2;
   else
     Kmimo=1;
@@ -1060,9 +1064,9 @@ n(tikz_fname,"w");
       case 1:
       case 2:
         if (common_flag == 0) {
-          
+
           if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
-            
+
             switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
             case 6:
               dci_length = sizeof_DCI1_1_5MHz_TDD_t;
@@ -1072,7 +1076,7 @@ n(tikz_fname,"w");
               ((DCI1_1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1_1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1084,7 +1088,7 @@ n(tikz_fname,"w");
               ((DCI1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_5MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1096,7 +1100,7 @@ n(tikz_fname,"w");
               ((DCI1_10MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_10MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1_10MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_10MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_10MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_10MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_10MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1106,7 +1110,7 @@ n(tikz_fname,"w");
               ((DCI1_20MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_20MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1_20MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_20MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_20MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_20MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_20MHz_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               dci_length = sizeof_DCI1_20MHz_TDD_t;
@@ -1123,7 +1127,7 @@ n(tikz_fname,"w");
               ((DCI1_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
               ((DCI1_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1134,7 +1138,7 @@ n(tikz_fname,"w");
               ((DCI1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
               ((DCI1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1145,7 +1149,7 @@ n(tikz_fname,"w");
               ((DCI1_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
               ((DCI1_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1156,18 +1160,18 @@ n(tikz_fname,"w");
               ((DCI1_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
               ((DCI1_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
               ((DCI1_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
-            }    
+            }
           }
           memcpy(&dci_alloc[num_dci].dci_pdu[0],&DLSCH_alloc_pdu_1[k],dci_length_bytes);
           dci_alloc[num_dci].dci_length = dci_length;
           dci_alloc[num_dci].L          = 1;
           dci_alloc[num_dci].rnti       = n_rnti+k;
           dci_alloc[num_dci].format     = format1;
-          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);  
+          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);
 
           printf("Generating dlsch params for user %d\n",k);
           generate_eNB_dlsch_params_from_dci(0,
@@ -1187,7 +1191,7 @@ n(tikz_fname,"w");
         }
         else { //common flag =1
           if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
-            
+
             switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
             case 6:
               dci_length = sizeof_DCI1A_1_5MHz_TDD_1_6_t;
@@ -1198,7 +1202,7 @@ n(tikz_fname,"w");
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1211,7 +1215,7 @@ n(tikz_fname,"w");
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1224,7 +1228,7 @@ n(tikz_fname,"w");
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1235,7 +1239,7 @@ n(tikz_fname,"w");
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               dci_length = sizeof_DCI1A_20MHz_TDD_1_6_t;
@@ -1253,7 +1257,7 @@ n(tikz_fname,"w");
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1265,7 +1269,7 @@ n(tikz_fname,"w");
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1277,7 +1281,7 @@ n(tikz_fname,"w");
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1289,11 +1293,11 @@ n(tikz_fname,"w");
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
-            }    
+            }
           }
           memcpy(&dci_alloc[num_dci].dci_pdu[0],&DLSCH_alloc_pdu_1[k],dci_length_bytes);
           dci_alloc[num_dci].dci_length = dci_length;
@@ -1301,7 +1305,7 @@ n(tikz_fname,"w");
           dci_alloc[num_dci].rnti       = SI_RNTI;
           dci_alloc[num_dci].format     = format1A;
           dci_alloc[num_dci].firstCCE       = 0;
-          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);  
+          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);
 
           printf("Generating dlsch params for user %d\n",k);
           generate_eNB_dlsch_params_from_dci(0,
@@ -1316,19 +1320,19 @@ n(tikz_fname,"w");
                      0,
                      P_RNTI,
                      PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single);
-          
+
           num_common_dci++;
           num_dci++;
-          
+
         }
         break;
       case 3: //LARGE CDD
         if (common_flag == 0) {
-          
+
           if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 2) {// here DCI does not contain any precoder information. matrix is fixed as identity, but dont forget aboy cycling
 
             if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
-              
+
               switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
               case 6:
           dci_length = sizeof_DCI2A_1_5MHz_2A_TDD_t;
@@ -1337,10 +1341,10 @@ n(tikz_fname,"w");
           ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
           ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           break;
@@ -1352,10 +1356,10 @@ n(tikz_fname,"w");
           ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
           ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           break;
@@ -1367,10 +1371,10 @@ n(tikz_fname,"w");
           ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
           ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           break;
@@ -1380,10 +1384,10 @@ n(tikz_fname,"w");
           ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
           ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           dci_length = sizeof_DCI2A_20MHz_2A_TDD_t;
@@ -1391,7 +1395,7 @@ n(tikz_fname,"w");
           break;
               }
             }
-         
+
             else { // fdd
               switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
               case 6:
@@ -1400,10 +1404,10 @@ n(tikz_fname,"w");
           ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           break;
@@ -1414,10 +1418,10 @@ n(tikz_fname,"w");
           ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           break;
@@ -1428,10 +1432,10 @@ n(tikz_fname,"w");
           ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           break;
@@ -1442,27 +1446,27 @@ n(tikz_fname,"w");
           ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2A_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           break;
-              }    
+              }
             }
           }
           else if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 4) { //4 antenna, needs diff precoding codebook index depeneding on layers
 
           }
-            
+
           memcpy(&dci_alloc[num_dci].dci_pdu[0],&DLSCH_alloc_pdu_1[k],dci_length_bytes);
           dci_alloc[num_dci].dci_length = dci_length;
           dci_alloc[num_dci].L          = 1;
           dci_alloc[num_dci].rnti       = n_rnti+k;
           dci_alloc[num_dci].format     = format2A;
-          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);  
-          
+          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);
+
           printf("Generating dlsch params for user %d / format 2A (%d)\n",k,format2A);
           generate_eNB_dlsch_params_from_dci(0,
                      subframe,
@@ -1476,13 +1480,13 @@ n(tikz_fname,"w");
                      0,
                      P_RNTI,
                      PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single);
-          
+
           num_dci++;
           num_ue_spec_dci++;
         }
         else { //commonn flag 1
           if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) { //tdd
-            
+
             switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
             case 6:
               dci_length = sizeof_DCI1A_1_5MHz_TDD_1_6_t;
@@ -1493,7 +1497,7 @@ n(tikz_fname,"w");
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1506,7 +1510,7 @@ n(tikz_fname,"w");
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1519,7 +1523,7 @@ n(tikz_fname,"w");
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1530,7 +1534,7 @@ n(tikz_fname,"w");
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               dci_length = sizeof_DCI1A_20MHz_TDD_1_6_t;
@@ -1548,7 +1552,7 @@ n(tikz_fname,"w");
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1560,7 +1564,7 @@ n(tikz_fname,"w");
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1572,7 +1576,7 @@ n(tikz_fname,"w");
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1584,11 +1588,11 @@ n(tikz_fname,"w");
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
-            }    
+            }
           }
           memcpy(&dci_alloc[num_dci].dci_pdu[0],&DLSCH_alloc_pdu_1[k],dci_length_bytes);
           dci_alloc[num_dci].dci_length = dci_length;
@@ -1596,8 +1600,8 @@ n(tikz_fname,"w");
           dci_alloc[num_dci].rnti       = SI_RNTI;
           dci_alloc[num_dci].format     = format1A;
           dci_alloc[num_dci].firstCCE       = 0;
-          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);  
-          
+          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);
+
           printf("Generating dlsch params for user %d\n",k);
           generate_eNB_dlsch_params_from_dci(0,
                      subframe,
@@ -1611,33 +1615,33 @@ n(tikz_fname,"w");
                      0,
                      P_RNTI,
                      PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single);
-          
+
           num_common_dci++;
           num_dci++;
-          
+
         }
         printf("Generated DCI format 2A (Transmission Mode 3)\n");
         break;
 
       case 4: // !!! this dci format contains precoder information
         if (common_flag == 0) {
-          
+
           if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 2) {
 
             if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
-              
+
               switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
               case 6:
-          dci_length = sizeof_DCI2_1_5MHz_2A_TDD_t; 
+          dci_length = sizeof_DCI2_1_5MHz_2A_TDD_t;
           dci_length_bytes = sizeof(DCI2_1_5MHz_2A_TDD_t);
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc        = DLSCH_RB_ALLOC;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC            = 0;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai            = 0;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid       = 0;
-          ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1           = mcs1;  
+          ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1           = mcs1;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1           = 1;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1            = 0;
-          ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2           = mcs2;  
+          ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2           = mcs2;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2           = 1;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2            = 0;
           ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap        = 0;
@@ -1648,13 +1652,13 @@ n(tikz_fname,"w");
           dci_length_bytes = sizeof(DCI2_5MHz_2A_TDD_t);
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rah              = 0;
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
-          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0; 
-          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0; 
+          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
+          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
@@ -1669,10 +1673,10 @@ n(tikz_fname,"w");
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
@@ -1685,10 +1689,10 @@ n(tikz_fname,"w");
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
@@ -1698,7 +1702,7 @@ n(tikz_fname,"w");
           break;
               }
             }
-          
+
             else {
               switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
               case 6:
@@ -1707,10 +1711,10 @@ n(tikz_fname,"w");
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
@@ -1723,10 +1727,10 @@ n(tikz_fname,"w");
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
@@ -1739,10 +1743,10 @@ n(tikz_fname,"w");
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
@@ -1755,36 +1759,36 @@ n(tikz_fname,"w");
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-          ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
+          ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv1              = 0;
-          ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
+          ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
           ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi             = 2;
           break;
-              }    
+              }
             }
           }
           else if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 4) {
 
           }
-          
-           printf ("TM4 with tpmi =%d\n", ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi);    
-           if ((((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2) || (((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2)) { 
+
+           printf ("TM4 with tpmi =%d\n", ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi);
+           if ((((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2) || (((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2)) {
 
             PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single = (unsigned short)(taus()&0xffff);
-            
+
            }
-            
+
           memcpy(&dci_alloc[num_dci].dci_pdu[0],&DLSCH_alloc_pdu_1[k],dci_length_bytes);
           dci_alloc[num_dci].dci_length = dci_length;
           dci_alloc[num_dci].L          = 1;
           dci_alloc[num_dci].rnti       = n_rnti+k;
           dci_alloc[num_dci].format     = format2;
-          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);  
-          
+          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);
+
           printf("Generating dlsch params for user %d\n",k);
           generate_eNB_dlsch_params_from_dci(0,
                      subframe,
@@ -1798,13 +1802,13 @@ n(tikz_fname,"w");
                      0,
                      P_RNTI,
                      PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single);
-          
+
           num_dci++;
           num_ue_spec_dci++;
         }
         else { //common_flag==1
           if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
-            
+
             switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
             case 6:
               dci_length = sizeof_DCI1A_1_5MHz_TDD_1_6_t;
@@ -1815,7 +1819,7 @@ n(tikz_fname,"w");
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_1_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1828,7 +1832,7 @@ n(tikz_fname,"w");
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_5MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1841,7 +1845,7 @@ n(tikz_fname,"w");
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_10MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1852,7 +1856,7 @@ n(tikz_fname,"w");
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_20MHz_TDD_1_6_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               dci_length = sizeof_DCI1A_20MHz_TDD_1_6_t;
@@ -1870,7 +1874,7 @@ n(tikz_fname,"w");
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_1_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1882,7 +1886,7 @@ n(tikz_fname,"w");
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_5MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1894,7 +1898,7 @@ n(tikz_fname,"w");
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_10MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
@@ -1906,11 +1910,11 @@ n(tikz_fname,"w");
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = computeRIV(PHY_vars_eNB->lte_frame_parms.N_RB_DL,0,9);
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = TPC;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
-              ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;  
+              ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs              = mcs1;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi              = 1;
               ((DCI1A_20MHz_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv               = 0;
               break;
-            }    
+            }
           }
           memcpy(&dci_alloc[num_dci].dci_pdu[0],&DLSCH_alloc_pdu_1[k],dci_length_bytes);
           dci_alloc[num_dci].dci_length = dci_length;
@@ -1918,7 +1922,7 @@ n(tikz_fname,"w");
           dci_alloc[num_dci].rnti       = SI_RNTI;
           dci_alloc[num_dci].format     = format1A;
           dci_alloc[num_dci].firstCCE       = 0;
-          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);  
+          dump_dci(&PHY_vars_eNB->lte_frame_parms,&dci_alloc[num_dci]);
 
             printf("Generating dlsch params for user %d\n",k);
             generate_eNB_dlsch_params_from_dci(0,
@@ -1933,7 +1937,7 @@ n(tikz_fname,"w");
                        0,
                        P_RNTI,
                        PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single);
-          
+
           num_common_dci++;
           num_dci++;
 
@@ -1985,12 +1989,12 @@ n(tikz_fname,"w");
       */
     }
 
-    if (n_frames==1) 
+    if (n_frames==1)
       printf("num_pdcch_symbols %d, numCCE %d => ",num_pdcch_symbols,numCCE);
 
     numCCE = get_nCCE(num_pdcch_symbols,&PHY_vars_eNB->lte_frame_parms,get_mi(&PHY_vars_eNB->lte_frame_parms,subframe));
 
-    if (n_frames==1) 
+    if (n_frames==1)
       printf("%d\n",numCCE);
 
     // apply RNTI-based nCCE allocation
@@ -2123,7 +2127,7 @@ n(tikz_fname,"w");
       initialize(&time_vector_rx_demod);
       struct list time_vector_rx_dec;
       initialize(&time_vector_rx_dec);
-      
+
       for (trials = 0;trials<n_frames;trials++) {
       //printf("Trial %d\n",trials);
         fflush(stdout);
@@ -2141,31 +2145,33 @@ n(tikz_fname,"w");
         resend_cw0_cw1=1;
         resend_cw1=0;
 
-        while (((transmission_mode == 3 || transmission_mode == 4) && 
+        while (((transmission_mode == 3 || transmission_mode == 4) &&
                ((round < num_rounds) && (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) &&
-               (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations))) || 
-               ((transmission_mode!=4 && transmission_mode != 3) && ((round< num_rounds) && 
+               (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations))) ||
+               ((transmission_mode!=4 && transmission_mode != 3) && ((round< num_rounds) &&
                (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)))) {
-          
+
           //printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials %d\n",trials,round, ret[0], ret[1], round_trials[round]);
-         
+
         if (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)
           round_trials[0][round]++;
-         
+
         if (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)
           round_trials[1][round]++;
 
+        // printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials TB0 = %d, round_trials TB1 = %d \n",trials,round, ret[0], ret[1], round_trials[0][round], round_trials[1][round]);
+
 
         /*printf("Trial %d, round cw0 =  %d , round cw1 = %d, ret[0] = %d, ret[1] = %d, round_trials cw0 [%d]= %d, round_trials cw1 [%d]= %d\n",trials, round, round, \
           ret[0], ret[1], round, round_trials[0][round], round, round_trials[1][round]);*/
 
           //printf("round_trials %d round %d\n", round_trials[round], round);
 
-          if (transmission_mode == 4 || transmission_mode == 5 || transmission_mode == 6) 
+          if (transmission_mode == 4 || transmission_mode == 5 || transmission_mode == 6)
             pmi_feedback=1;
-          else 
+          else
             pmi_feedback=0;
-          
+
           if (abstx) {
             if (trials==0 && round==0 && SNR==snr0)  //generate a new channel
               hold_channel = 0;
@@ -2176,12 +2182,12 @@ n(tikz_fname,"w");
             hold_channel = 0;//(round==0) ? 0 : 1;
 
         PMI_FEEDBACK:
-        
+
           //printf("Trial %d : Round %d, pmi_feedback %d \n",trials,round,pmi_feedback);
           for (aa=0; aa<PHY_vars_eNB->lte_frame_parms.nb_antennas_tx;aa++) {
             memset(&PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][aa][0],0,FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX*sizeof(int32_t));
           }
-        
+
           if (input_fd==NULL) {
 
             start_meas(&PHY_vars_eNB->phy_proc_tx);
@@ -2189,15 +2195,22 @@ n(tikz_fname,"w");
             // Simulate HARQ procedures!!!
             if (common_flag == 0) {
 
+
               PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->rvidx = round&3;
-                if (transmission_mode == 3 || transmission_mode == 4) 
+              if (transmission_mode == 3 || transmission_mode == 4)
                   PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->rvidx = round&3;
-              
+
               if (round == 0) {   // First round
                 TB0_active = 1;
 
+             /* PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->rvidx = round&3;
+              if (transmission_mode == 3 || transmission_mode == 4)
+                  PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->rvidx = round&3;*/
+
+
+
                 if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
-                  
+
                   switch (transmission_mode) {
                   case 1:
                   case 2:
@@ -2257,7 +2270,7 @@ n(tikz_fname,"w");
                     }
                     break;
                   case 4:
-                    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) { 
+                    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
                      case 6:
                       ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
                       ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
@@ -2287,8 +2300,8 @@ n(tikz_fname,"w");
                       memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_20MHz_2A_TDD_t));
                       break;
                     }
-                    break; 
-              
+                    break;
+
                   case 5:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = 0;
@@ -2356,7 +2369,7 @@ n(tikz_fname,"w");
                     }
                     break;
                   case 4:
-                    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) { 
+                    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
                      case 6:
                       ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
                       ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
@@ -2386,18 +2399,18 @@ n(tikz_fname,"w");
                       memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_20MHz_2A_FDD_t));
                       break;
                     }
-                    break; 
+                    break;
                   case 5:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = 0;
                     memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t));
                     break;
                   }
-                  
+
                 }
               }
-              else { 
-                
+              else {
+
                 if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
                   switch (transmission_mode) {
                   case 1:
@@ -2437,7 +2450,7 @@ n(tikz_fname,"w");
                       else {  // deactivate TB0
                         ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
-                        ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;   
+                        ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
                         ((DCI2A_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                         }
                       memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2A_1_5MHz_2A_TDD_t));
@@ -2499,6 +2512,7 @@ n(tikz_fname,"w");
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi             = 2;
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2514,6 +2528,8 @@ n(tikz_fname,"w");
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        printf("\n Requesting only TB1 from temp DCI\n");
+                        ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2529,6 +2545,7 @@ n(tikz_fname,"w");
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2544,6 +2561,7 @@ n(tikz_fname,"w");
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2553,7 +2571,7 @@ n(tikz_fname,"w");
                       break;
                     }
                     break;
-                   
+
                   case 5:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = round&3;
@@ -2662,6 +2680,7 @@ n(tikz_fname,"w");
                         ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
                         ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2677,6 +2696,8 @@ n(tikz_fname,"w");
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        printf("\n Requesting only TB1 from temp DCI\n");
+                        ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2692,6 +2713,7 @@ n(tikz_fname,"w");
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2707,6 +2729,7 @@ n(tikz_fname,"w");
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
+                        ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2715,9 +2738,9 @@ n(tikz_fname,"w");
                       memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_20MHz_2A_FDD_t));
                       break;
                     }
-                    break;  
-                    
-                    
+                    break;
+
+
                   case 5:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = round&3;
@@ -2725,9 +2748,8 @@ n(tikz_fname,"w");
                     break;
                   }
                 }
-                    }
+              }
             }
-          
             num_pdcch_symbols_2 = generate_dci_top(num_ue_spec_dci,
                                                    num_common_dci,
                                                    dci_alloc,
@@ -2742,120 +2764,113 @@ n(tikz_fname,"w");
               exit(-1);
             }
 
-            for (k=0;k<n_users;k++) {
-              for (int cw=0; cw<Kmimo; cw++) {
-                coded_bits_per_codeword[cw] = get_G(&PHY_vars_eNB->lte_frame_parms,
-                                                PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->nb_rb,
-                                                PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->rb_alloc,
-                                                get_Qm(PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->mcs),
-                                                PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->Nl,
+ for (k=0;k<n_users;k++) {
+              for (int TB=0; TB<Kmimo; TB++) {
+                if (PHY_vars_eNB->dlsch_eNB[0][TB] == NULL)
+                  continue;
+
+                coded_bits_per_codeword[TB] = get_G(&PHY_vars_eNB->lte_frame_parms,
+                                                PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->nb_rb,
+                                                PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->rb_alloc,
+                                                get_Qm(PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->mcs),
+                                                PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Nl,
                                                 num_pdcch_symbols,
                                                 0,subframe);
 
 
       #ifdef TBS_FIX   // This is for MESH operation!!!
-                tbs[cw] = (double)3*TBStable[get_I_TBS(PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->mcs)][PHY_vars_eNB->dlsch_eNB[k][cw]->nb_rb-1]/4;
+                tbs[TB] = (double)3*TBStable[get_I_TBS(PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->mcs)][PHY_vars_eNB->dlsch_eNB[k][TB]->nb_rb-1]/4;
       #else
-                tbs[cw] = PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->TBS;
+                tbs[TB] = PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->TBS;
       #endif
 
-                rate[cw] = (double)tbs[cw]/(double)coded_bits_per_codeword[cw];
-              
+                rate[TB] = (double)tbs[TB]/(double)coded_bits_per_codeword[TB];
+
                 if ((SNR == snr0) && (trials == 0) && (round == 0) && (pmi_feedback == 0))
-                  printf("User %d, cw %d: Rate = %f (%f bits/dim) (G %d, TBS %d, mod %d, pdcch_sym %d, ndi %d)\n",
-                         k,cw,rate[cw],rate[cw]*get_Qm(PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->mcs),
-                         coded_bits_per_codeword[cw],
-                         tbs[cw],
-                         get_Qm(PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->mcs),
+                  printf("User %d, TB %d: Rate = %f (%f bits/dim) (G %d, TBS %d, mod %d, pdcch_sym %d, ndi %d)\n",
+                         k,TB,rate[TB],rate[TB]*get_Qm(PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->mcs),
+                         coded_bits_per_codeword[TB],
+                         tbs[TB],
+                         get_Qm(PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->mcs),
                          num_pdcch_symbols,
-                         PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->round);
+                         PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->round);
 
               // use the PMI from previous trial
                 if (DLSCH_alloc_pdu2_1E[0].tpmi == 5) {
                   PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->pmi_alloc = quantize_subband_pmi(&PHY_vars_UE->PHY_measurements,0,PHY_vars_eNB->lte_frame_parms.N_RB_DL);
                   PHY_vars_UE->dlsch_ue[0][0]->pmi_alloc = quantize_subband_pmi(&PHY_vars_UE->PHY_measurements,0,PHY_vars_UE->lte_frame_parms.N_RB_DL);
-                  if (n_users>1) 
-                    PHY_vars_eNB->dlsch_eNB[1][0]->harq_processes[0]->pmi_alloc = (PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->pmi_alloc ^ 0x1555); 
+                  if (n_users>1)
+                    PHY_vars_eNB->dlsch_eNB[1][0]->harq_processes[0]->pmi_alloc = (PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->pmi_alloc ^ 0x1555);
                   /*
                     if ((trials<10) && (round==0)) {
                     printf("tx PMI UE0 %x (pmi_feedback %d)\n",pmi2hex_2Ar1(PHY_vars_eNB->dlsch_eNB[0][0]->pmi_alloc),pmi_feedback);
                     if (transmission_mode ==5)
                     printf("tx PMI UE1 %x\n",pmi2hex_2Ar1(PHY_vars_eNB->dlsch_eNB[1][0]->pmi_alloc));
                     }
-          */    
+          */
                 }
-              
-              
-                if (transmission_mode==4 && ((((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2) ||(((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2))){
-                  PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->pmi_alloc = quantize_subband_pmi(&PHY_vars_UE->PHY_measurements,0,PHY_vars_eNB->lte_frame_parms.N_RB_DL);
-                  PHY_vars_UE->dlsch_ue[0][0]->pmi_alloc = quantize_subband_pmi(&PHY_vars_UE->PHY_measurements,0,PHY_vars_UE->lte_frame_parms.N_RB_DL);
+
+                //Here need to add cases for TPMI 6 and TPMI 5 and check for both TB.
+                if (transmission_mode == 4 && ((((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2) ||(((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi == 2))){
+                  PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->pmi_alloc = quantize_subband_pmi(&PHY_vars_UE->PHY_measurements,0,PHY_vars_eNB->lte_frame_parms.N_RB_DL);
+                  PHY_vars_UE->dlsch_ue[0][TB]->pmi_alloc = quantize_subband_pmi(&PHY_vars_UE->PHY_measurements,0,PHY_vars_UE->lte_frame_parms.N_RB_DL);
                 }
-              
-              
 
 
-                start_meas(&PHY_vars_eNB->dlsch_encoding_stats);        
-                if (dlsch_encoding(((cw==0) ? input_buffer0[k] : input_buffer1[k]),
+
+
+                start_meas(&PHY_vars_eNB->dlsch_encoding_stats);
+                if (dlsch_encoding(((TB==0) ? input_buffer0[k] : input_buffer1[k]),
                                    &PHY_vars_eNB->lte_frame_parms,
                                    num_pdcch_symbols,
-                                   PHY_vars_eNB->dlsch_eNB[k][cw],
+                                   PHY_vars_eNB->dlsch_eNB[k][TB],
                                    0,subframe,
                                    &PHY_vars_eNB->dlsch_rate_matching_stats,
                                    &PHY_vars_eNB->dlsch_turbo_encoding_stats,
                                    &PHY_vars_eNB->dlsch_interleaving_stats)<0)
                   exit(-1);
 
-                stop_meas(&PHY_vars_eNB->dlsch_encoding_stats);  
+                stop_meas(&PHY_vars_eNB->dlsch_encoding_stats);
 
-                PHY_vars_eNB->dlsch_eNB[k][cw]->rnti = (common_flag==0) ? n_rnti+k : SI_RNTI;    
-                start_meas(&PHY_vars_eNB->dlsch_scrambling_stats);        
+                PHY_vars_eNB->dlsch_eNB[k][TB]->rnti = (common_flag==0) ? n_rnti+k : SI_RNTI;
+                start_meas(&PHY_vars_eNB->dlsch_scrambling_stats);
                 dlsch_scrambling(&PHY_vars_eNB->lte_frame_parms,
-                     0,
-                     PHY_vars_eNB->dlsch_eNB[k][cw],
-                     coded_bits_per_codeword[cw],
-                     cw,
-                     subframe<<1);
-                stop_meas(&PHY_vars_eNB->dlsch_scrambling_stats);        
+                                 0,
+                                 PHY_vars_eNB->dlsch_eNB[k][TB],
+                                 coded_bits_per_codeword[TB],
+                                 TB,
+                                 subframe<<1);
+                stop_meas(&PHY_vars_eNB->dlsch_scrambling_stats);
 
                 if (n_frames==1) {
-                  for (s=0;s<PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->C;s++) {
-                    if (s<PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->Cminus)
-                      Kr = PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->Kminus;
+                  for (s=0;s<PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->C;s++) {
+                    if (s<PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Cminus)
+                      Kr = PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Kminus;
                     else
-                      Kr = PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->Kplus;
-                      
+                      Kr = PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Kplus;
                     Kr_bytes = Kr>>3;
-                      
-                   // for (i=0;i<Kr_bytes;i++)
-                    //  printf("cw%d   %d : (%x)\n",cw,i,PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->c[s][i]);
                   }
                 }
               }
-          
-              start_meas(&PHY_vars_eNB->dlsch_modulation_stats);        
+
+              start_meas(&PHY_vars_eNB->dlsch_modulation_stats);
               re_allocated = dlsch_modulation(PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id],
                                               AMP,
                                               subframe,
                                               &PHY_vars_eNB->lte_frame_parms,
                                               num_pdcch_symbols,
                                               PHY_vars_eNB->dlsch_eNB[k][0],
-                                              PHY_vars_eNB->dlsch_eNB[k][1]
-                                               );
-              stop_meas(&PHY_vars_eNB->dlsch_modulation_stats);        
-              /*
-              if (trials==0 && round==0)
-          printf("RE count %d\n",re_allocated);
-              */
+                                              PHY_vars_eNB->dlsch_eNB[k][1]);
+              stop_meas(&PHY_vars_eNB->dlsch_modulation_stats);
             } //n_users
 
-            
             generate_pilots(PHY_vars_eNB,
                             PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id],
                             AMP,
                             LTE_NUMBER_OF_SUBFRAMES_PER_FRAME);
-          
+
             start_meas(&PHY_vars_eNB->ofdm_mod_stats);
-            
+
             do_OFDM_mod_l(PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id],
                           PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id],
                           (subframe*2),
@@ -2865,10 +2880,10 @@ n(tikz_fname,"w");
                           PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id],
                           (subframe*2)+1,
                           &PHY_vars_eNB->lte_frame_parms);
-            
+
             stop_meas(&PHY_vars_eNB->ofdm_mod_stats);
-            stop_meas(&PHY_vars_eNB->phy_proc_tx); 
-            
+            stop_meas(&PHY_vars_eNB->phy_proc_tx);
+
             do_OFDM_mod_l(PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id],
                           PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id],
                           (subframe*2)+2,
@@ -2887,11 +2902,24 @@ n(tikz_fname,"w");
                                       PHY_vars_eNB->lte_frame_parms.samples_per_tti);
             }
             tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
-          
+
+            if (n_frames==1) {
+              write_output("txsigF0.m","txsF0", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][0][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1);
+              if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1)
+                write_output("txsigF1.m","txsF1", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][1][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1);
+            }
+
+            tx_lev = 0;
+            for (aa=0; aa<PHY_vars_eNB->lte_frame_parms.nb_antennas_tx; aa++) {
+              tx_lev += signal_energy(&PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][aa]
+                                      [subframe*PHY_vars_eNB->lte_frame_parms.samples_per_tti],
+                                      PHY_vars_eNB->lte_frame_parms.samples_per_tti);
+            }
+            tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
+
             if (n_frames==1) {
               printf("tx_lev = %d (%d dB)\n",tx_lev,tx_lev_dB);
-              write_output("txsig0.m","txs0", &PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0][subframe* PHY_vars_eNB->lte_frame_parms.samples_per_tti],
-                                                                                                  PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1);
+              write_output("txsig0.m","txs0", &PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0][subframe* PHY_vars_eNB->lte_frame_parms.samples_per_tti], PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1);
             }
           }
           /*
@@ -2899,7 +2927,7 @@ n(tikz_fname,"w");
             i=0;
             while (!feof(input_fd)) {
             fscanf(input_fd,"%s %s",input_val_str,input_val_str2);
-            
+
             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));
@@ -2918,7 +2946,7 @@ n(tikz_fname,"w");
             tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
             }
           */
-       
+
           //    printf("Copying tx ..., nsymb %d (n_tx %d), awgn %d\n",nsymb,PHY_vars_eNB->lte_frame_parms.nb_antennas_tx,awgn_flag);
           for (i=0;i<2*frame_parms->samples_per_tti;i++) {
             for (aa=0;aa<PHY_vars_eNB->lte_frame_parms.nb_antennas_tx;aa++) {
@@ -2937,7 +2965,7 @@ n(tikz_fname,"w");
             //printf("r_im0 = %d\n",r_im[0][i]);
             //printf("r_re1 = %d\n",r_re[1][i]);
             //printf("r_im1 = %d\n",r_im[1][i]);
-                           
+
                 }
                 else {
                   for (aarx=0;aarx<PHY_vars_UE->lte_frame_parms.nb_antennas_rx;aarx++) {
@@ -2956,8 +2984,8 @@ n(tikz_fname,"w");
           }
 
           // Multipath channel
-          if (awgn_flag == 0) {  
-            multipath_channel(eNB2UE[round+round],s_re,s_im,r_re,r_im,
+          if (awgn_flag == 0) {
+            multipath_channel(eNB2UE[round],s_re,s_im,r_re,r_im,
                               2*frame_parms->samples_per_tti,hold_channel);
             //      printf("amc: ****************** eNB2UE[%d]->n_rx = %d,dd %d\n",round,eNB2UE[round]->nb_rx,eNB2UE[round]->channel_offset);
             if(abstx==1 && num_rounds>1)
@@ -2967,7 +2995,7 @@ n(tikz_fname,"w");
                 random_channel(eNB2UE[3],0);
               }
             if (PHY_vars_UE->perfect_ce==1){
-              freq_channel(eNB2UE[round+round],PHY_vars_UE->lte_frame_parms.N_RB_DL,12*PHY_vars_UE->lte_frame_parms.N_RB_DL + 1);
+              freq_channel(eNB2UE[round],PHY_vars_UE->lte_frame_parms.N_RB_DL,12*PHY_vars_UE->lte_frame_parms.N_RB_DL + 1);
                       //  write_output("channel.m","ch",eNB2UE[round]->ch[0],eNB2UE[round]->channel_length,1,8);
                       //  write_output("channelF.m","chF",eNB2UE[round]->chF[0],12*PHY_vars_UE->lte_frame_parms.N_RB_DL +1,1,8);
             }
@@ -2979,7 +3007,7 @@ n(tikz_fname,"w");
             freq_channel(eNB2UE[0], NB_RB,2*NB_RB + 1);
             // snr=pow(10.0,.1*SNR);
             fprintf(csv_fd,"%f,",SNR);
-            
+
             for (u=0;u<2*NB_RB;u++){
               for (aarx=0;aarx<eNB2UE[0]->nb_rx;aarx++) {
                 for (aatx=0;aatx<eNB2UE[0]->nb_tx;aatx++) {
@@ -2989,10 +3017,10 @@ n(tikz_fname,"w");
                 }
               }
             }
-            
+
             if(num_rounds>1){
               freq_channel(eNB2UE[1], NB_RB,2*NB_RB + 1);
-              
+
               for (u=0;u<2*NB_RB;u++){
                 for (aarx=0;aarx<eNB2UE[1]->nb_rx;aarx++) {
                   for (aatx=0;aatx<eNB2UE[1]->nb_tx;aatx++) {
@@ -3003,7 +3031,7 @@ n(tikz_fname,"w");
                 }
               }
               freq_channel(eNB2UE[2], NB_RB,2*NB_RB + 1);
-              
+
               for (u=0;u<2*NB_RB;u++){
                 for (aarx=0;aarx<eNB2UE[2]->nb_rx;aarx++) {
                   for (aatx=0;aatx<eNB2UE[2]->nb_tx;aatx++) {
@@ -3013,9 +3041,9 @@ n(tikz_fname,"w");
                   }
                 }
               }
-              
+
               freq_channel(eNB2UE[3], NB_RB,2*NB_RB + 1);
-              
+
               for (u=0;u<2*NB_RB;u++){
                 for (aarx=0;aarx<eNB2UE[3]->nb_rx;aarx++) {
                   for (aatx=0;aatx<eNB2UE[3]->nb_tx;aatx++) {
@@ -3028,28 +3056,28 @@ n(tikz_fname,"w");
             }
           }
         }
-        
+
         //AWGN
         // This is the SNR on the PDSCH for OFDM symbols without pilots -> rho_A
         sigma2_dB = 10*log10((double)tx_lev) +10*log10((double)PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size/(double)(NB_RB*12)) - SNR - get_pa_dB(PHY_vars_eNB->pdsch_config_dedicated);
         sigma2 = pow(10,sigma2_dB/10);
         if (n_frames==1)
           printf("Sigma2 %f (sigma2_dB %f,%f,%f )\n",sigma2,sigma2_dB,10*log10((double)PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size/(double)(NB_RB*12)),get_pa_dB(PHY_vars_eNB->pdsch_config_dedicated));
-        
+
         for (i=0; i<2*frame_parms->samples_per_tti; i++) {
           for (aa=0;aa<PHY_vars_eNB->lte_frame_parms.nb_antennas_rx;aa++) {
             //printf("s_re[0][%d]=> %f , r_re[0][%d]=> %f\n",i,s_re[aa][i],i,r_re[aa][i]);
-            ((short*) PHY_vars_UE->lte_ue_common_vars.rxdata[aa])[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti)+2*i] = 
+            ((short*) PHY_vars_UE->lte_ue_common_vars.rxdata[aa])[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti)+2*i] =
               (short) (r_re[aa][i] + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
-            ((short*) PHY_vars_UE->lte_ue_common_vars.rxdata[aa])[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti)+2*i+1] = 
+            ((short*) PHY_vars_UE->lte_ue_common_vars.rxdata[aa])[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti)+2*i+1] =
               (short) (r_im[aa][i] + (iqim*r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
           }
-        }   
-        
+        }
+
         //    lte_sync_time_init(PHY_vars_eNB->lte_frame_parms,lte_ue_common_vars);
         //    lte_sync_time(lte_ue_common_vars->rxdata, PHY_vars_eNB->lte_frame_parms);
         //    lte_sync_time_free();
-        
+
         /*
           // optional: read rx_frame from file
           if ((rx_frame_file = fopen("rx_frame.dat","r")) == NULL)
@@ -3057,22 +3085,22 @@ n(tikz_fname,"w");
           printf("Cannot open rx_frame.m data file\n");
           exit(0);
           }
-            
+
           result = fread((void *)PHY_vars->rx_vars[0].RX_DMA_BUFFER,4,FRAME_LENGTH_COMPLEX_SAMPLES,rx_frame_file);
           printf("Read %d bytes\n",result);
           result = fread((void *)PHY_vars->rx_vars[1].RX_DMA_BUFFER,4,FRAME_LENGTH_COMPLEX_SAMPLES,rx_frame_file);
           printf("Read %d bytes\n",result);
-            
+
           fclose(rx_frame_file);
         */
-        
+
         if (n_frames==1) {
           printf("RX level in null symbol %d\n",dB_fixed(signal_energy(&PHY_vars_UE->lte_ue_common_vars.rxdata[0][160+OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
           printf("RX level in data symbol %d\n",dB_fixed(signal_energy(&PHY_vars_UE->lte_ue_common_vars.rxdata[0][160+(2*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES)],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
           printf("rx_level Null symbol %f\n",10*log10(signal_energy_fp(r_re,r_im,1,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2,256+(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES))));
           printf("rx_level data symbol %f\n",10*log10(signal_energy_fp(r_re,r_im,1,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2,256+(2*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES))));
         }
-        
+
         if (PHY_vars_eNB->lte_frame_parms.Ncp == 0) {  // normal prefix
           pilot1 = 4;
           pilot2 = 7;
@@ -3082,8 +3110,8 @@ n(tikz_fname,"w");
           pilot1 = 3;
           pilot2 = 6;
           pilot3 = 9;
-        }    
-        
+        }
+
         start_meas(&PHY_vars_UE->phy_proc_rx);
         // Inner receiver scheduling for 3 slots
           for (Ns=(2*subframe);Ns<((2*subframe)+3);Ns++) {
@@ -3092,17 +3120,17 @@ n(tikz_fname,"w");
           printf("Ns %d, l %d, l2 %d\n",Ns, l, l+(Ns%2)*pilot2);
               /*
           This function implements the OFDM front end processor (FEP).
-              
+
           Parameters:
           frame_parms   LTE DL Frame Parameters
           ue_common_vars   LTE UE Common Vars
           l   symbol within slot (0..6/7)
           Ns   Slot number (0..19)
           sample_offset   offset within rxdata (points to beginning of subframe)
-          no_prefix   if 1 prefix is removed by HW 
-              
+          no_prefix   if 1 prefix is removed by HW
+
               */
-            
+
               start_meas(&PHY_vars_UE->ofdm_demod_stats);
               slot_fep(PHY_vars_UE,
                        l,
@@ -3119,9 +3147,9 @@ n(tikz_fname,"w");
                       for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
                         for (i=0; i<frame_parms->N_RB_DL*12; i++) {
                           ((int16_t *) PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[k][(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=
-                          (int16_t)(eNB2UE[round+round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x*AMP);
+                          (int16_t)(eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].x*AMP);
                           ((int16_t *) PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[k][(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=
-                          (int16_t)(eNB2UE[round+round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP);
+                          (int16_t)(eNB2UE[round]->chF[aarx+(aa*frame_parms->nb_antennas_rx)][i].y*AMP);
                         }
                       }
                     }
@@ -3143,14 +3171,14 @@ n(tikz_fname,"w");
                       for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
                         for (i=0; i<frame_parms->N_RB_DL*12; i++) {
                           ((int16_t *) PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[0][(aa<<1)+aarx])[2*i+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=(short)(AMP);
-                          ((int16_t *) PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[0][(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=0/2;  
+                          ((int16_t *) PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[0][(aa<<1)+aarx])[2*i+1+((l+(Ns%2)*pilot2)*frame_parms->ofdm_symbol_size+LTE_CE_FILTER_LENGTH)*2]=0/2;
                         }
                        }
                     }
                 }
               }
               }
-              
+
               if ((Ns==((2*subframe))) && (l==0)) {
                 lte_ue_measurements(PHY_vars_UE,
                                     subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti,
@@ -3215,7 +3243,7 @@ n(tikz_fname,"w");
                                                    eNB_id,
                                                    subframe);
                   printf("dci_cnt %d\n",dci_cnt);
-          
+
                   if (dci_cnt==0) {
                     dlsch_active = 0;
                     if (round==0) {
@@ -3227,7 +3255,7 @@ n(tikz_fname,"w");
                         printf("DCI error trial %d errs[0][0] %d\n",trials,errs[0][0]);
                     }
                   }
-          
+
                   for (i=0;i<dci_cnt;i++) {
                     //printf("Generating dlsch parameters for RNTI %x\n",dci_alloc_rx[i].rnti);
                      if (round == 0) {
@@ -3236,7 +3264,7 @@ n(tikz_fname,"w");
                       if ((transmission_mode == 3 || transmission_mode ==4) && (round == 0)) {
                         PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->first_tx=1;
                       }
-                    if ((dci_alloc_rx[i].rnti == n_rnti) && 
+                    if ((dci_alloc_rx[i].rnti == n_rnti) &&
                         (generate_ue_dlsch_params_from_dci(0,
                                                            subframe,
                                                            dci_alloc_rx[i].dci_pdu,
@@ -3281,9 +3309,9 @@ n(tikz_fname,"w");
                           errs[0][0]++;
                           round=5;
 
-                          if (n_frames==1) 
+                          if (n_frames==1)
                             printf("DCI misdetection trial %d\n",trials);
-                          
+
                         }
                       }
                   }
@@ -3329,7 +3357,7 @@ n(tikz_fname,"w");
                         break;
                       case 4:
                         generate_ue_dlsch_params_from_dci(0,
-                                                          subframe, 
+                                                          subframe,
                                                           &DLSCH_alloc_pdu_1[0],
                                                           (common_flag==0)? C_RNTI : SI_RNTI,
                                                           (common_flag==0)? format2 : format1A,//format1A only for a codeblock
@@ -3373,7 +3401,7 @@ n(tikz_fname,"w");
 
 
                   start_meas(&PHY_vars_UE->dlsch_llr_stats);
-                      
+
                   for (m=PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols; m<pilot2; m++) {
                     if (rx_pdsch(PHY_vars_UE,
                                  PDSCH,
@@ -3391,8 +3419,8 @@ n(tikz_fname,"w");
                   }
                   stop_meas(&PHY_vars_UE->dlsch_llr_stats);
                 }
-                  
-                if ((Ns==(1+(2*subframe))) && (l==pilot1)){// process symbols (6 Extended Prefix),7,8,9 
+
+                if ((Ns==(1+(2*subframe))) && (l==pilot1)){// process symbols (6 Extended Prefix),7,8,9
                     start_meas(&PHY_vars_UE->dlsch_llr_stats);
                     for (m=pilot2;m<pilot3; m++) {
                       if (rx_pdsch(PHY_vars_UE,
@@ -3411,7 +3439,7 @@ n(tikz_fname,"w");
                       }
                     stop_meas(&PHY_vars_UE->dlsch_llr_stats);
                   }
-                
+
                 if ((Ns==(2+(2*subframe))) && (l==0)) { // process symbols 10,11,(12,13 Normal Prefix) do deinterleaving for TTI
                   start_meas(&PHY_vars_UE->dlsch_llr_stats);
                   for (m=pilot3; m<PHY_vars_UE->lte_frame_parms.symbols_per_tti; m++) {
@@ -3446,122 +3474,124 @@ n(tikz_fname,"w");
               }
             }
           }
-          
-          if (rx_type==rx_SIC_dual_stream){
+
+          /*if (rx_type==rx_SIC_dual_stream){
             cw_to_decode_interf=1;
             cw_to_decode_interf_free=1;
           }
             else {
-            cw_to_decode_interf=Kmimo; 
-            } 
-            
-          for (cw_non_sic=0; cw_non_sic<cw_to_decode_interf; cw_non_sic++){ // may be we ll have to swap CW
-
-            PHY_vars_UE->dlsch_ue[0][cw_non_sic]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
-            coded_bits_per_codeword[cw_non_sic] = get_G(&PHY_vars_eNB->lte_frame_parms,
-                                            PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->nb_rb,
-                                            PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->rb_alloc,
-                                            get_Qm(PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->mcs),
-                                            PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->Nl,
+            cw_to_decode_interf=Kmimo;
+            }*/
+
+          for (TB=0; TB<Kmimo; TB++){ // may be we ll have to swap CW
+
+            if (PHY_vars_UE->dlsch_ue[0][TB] == NULL)
+            continue;
+
+            PHY_vars_UE->dlsch_ue[0][TB]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
+            coded_bits_per_codeword[TB] = get_G(&PHY_vars_eNB->lte_frame_parms,
+                                            PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->nb_rb,
+                                            PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->rb_alloc,
+                                            get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs),
+                                            PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->Nl,
                                             num_pdcch_symbols,
                                             0,subframe);
 
-            PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid]->G = coded_bits_per_codeword[cw_non_sic];
-            PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->mcs);
-            
+            PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->G = coded_bits_per_codeword[TB];
+            PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs);
+
             if (n_frames==1) {
-              printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,cw_non_sic,coded_bits_per_codeword[cw_non_sic],
-                     PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid]->TBS);
-            
+              printf("Kmimo=%d, TB=%d, G=%d, TBS=%d\n",Kmimo,TB,coded_bits_per_codeword[TB],
+                     PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->TBS);
+
               // calculate uncoded BER
-              uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[cw_non_sic]);
+              uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[TB]);
 
               AssertFatal(uncoded_ber_bit, "uncoded_ber_bit==NULL");
-              
-              sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round, cw_non_sic);
-              sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, cw_non_sic);
-              write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[cw_non_sic],coded_bits_per_codeword[cw_non_sic],1,0);
-              sprintf(fname,"dlsch_cw%d_e.m", cw_non_sic);
-              sprintf(vname,"dlschcw%d_e", cw_non_sic);
-              write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->e,coded_bits_per_codeword[cw_non_sic],1,4);
+
+              sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round, TB);
+              sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, TB);
+              write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->codeword],coded_bits_per_codeword[TB],1,0);
+              sprintf(fname,"dlsch_cw%d_e.m", TB);
+              sprintf(vname,"dlschcw%d_e", TB);
+              write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->e,coded_bits_per_codeword[TB],1,4);
               uncoded_ber=0;
               printf("trials=%d\n", trials);
 
-              for (i=0;i<coded_bits_per_codeword[cw_non_sic];i++) 
-                if (PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[cw_non_sic][i]<0)) {
+              for (i=0;i<coded_bits_per_codeword[TB];i++)
+                if (PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->codeword][i]<0)) {
                   uncoded_ber_bit[i] = 1;
                   uncoded_ber++;
                 }
                 else
                   uncoded_ber_bit[i] = 0;
-              
-              uncoded_ber/=coded_bits_per_codeword[cw_non_sic];
+
+              uncoded_ber/=coded_bits_per_codeword[TB];
               avg_ber += uncoded_ber;
-              sprintf(fname,"cw%d_uncoded_ber_bit.m", cw_non_sic);
-              sprintf(vname,"uncoded_ber_bit_cw%d", cw_non_sic);
-              write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[cw_non_sic],1,0);
-              printf("cw %d, uncoded ber %f\n",cw_non_sic,uncoded_ber);
-              
+              sprintf(fname,"cw%d_uncoded_ber_bit.m", TB);
+              sprintf(vname,"uncoded_ber_bit_cw%d", TB);
+              write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[TB],1,0);
+              printf("cw %d, uncoded ber %f\n",TB,uncoded_ber);
+
 
               free(uncoded_ber_bit);
-              uncoded_ber_bit = NULL;  
+              uncoded_ber_bit = NULL;
 
             }
 
-            start_meas(&PHY_vars_UE->dlsch_unscrambling_stats);        
+            start_meas(&PHY_vars_UE->dlsch_unscrambling_stats);
             dlsch_unscrambling(&PHY_vars_UE->lte_frame_parms,
                                0,
-                               PHY_vars_UE->dlsch_ue[0][cw_non_sic],
-                               coded_bits_per_codeword[cw_non_sic],
-                               PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw_non_sic],
-                               cw_non_sic,
+                               PHY_vars_UE->dlsch_ue[0][TB],
+                               coded_bits_per_codeword[TB],
+                               PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->codeword],
+                               TB,
                                subframe<<1);
-            stop_meas(&PHY_vars_UE->dlsch_unscrambling_stats);        
+            stop_meas(&PHY_vars_UE->dlsch_unscrambling_stats);
 
             start_meas(&PHY_vars_UE->dlsch_decoding_stats);
-            ret[cw_non_sic] = dlsch_decoding(PHY_vars_UE,
-                                             PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw_non_sic],
+            ret[TB] = dlsch_decoding(PHY_vars_UE,
+                                             PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[TB],
                                              &PHY_vars_UE->lte_frame_parms,
-                                             PHY_vars_UE->dlsch_ue[0][cw_non_sic],
-                                             PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid],
+                                             PHY_vars_UE->dlsch_ue[0][TB],
+                                             PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid],
                                              subframe,
-                                             PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid,
+                                             PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid,
                                              1,llr8_flag);
-            stop_meas(&PHY_vars_UE->dlsch_decoding_stats); 
+            stop_meas(&PHY_vars_UE->dlsch_decoding_stats);
             //printf("retr cw 0 = %d\n", ret[0]);
             //printf("current round = %d\n", PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid]->round);
 
-           
-             
-            if (ret[cw_non_sic] <= PHY_vars_UE->dlsch_ue[0][cw_non_sic]->max_turbo_iterations ) { //if CW0 is decoded, approach CW1
-              
-              if (cw_non_sic==0) {
-                avg_iter[0] += ret[0];
-                iter_trials[0]++;
-              }
-              
+
+
+            if (ret[TB] <= PHY_vars_UE->dlsch_ue[0][TB]->max_turbo_iterations ) { //if CW0 is decoded, approach CW1
+
+
+                /*avg_iter[TB] += ret[TB];
+                iter_trials[TB]++;*/
+
               if (n_frames==2) {
-                printf("cw non sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",cw_non_sic,round,uncoded_ber);
-            #ifdef PRINT_BYTES
-                for (s=0;s<PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->C;s++) {
-                  if (s<PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->Cminus)
-                    Kr = PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->Kminus;
+                printf("cw non sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",TB,round,uncoded_ber);
+#ifdef PRINT_BYTES
+                for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->C;s++) {
+                  if (s<PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->Cminus)
+                    Kr = PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->Kminus;
                   else
-                    Kr = PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->Kplus;
-                  
+                    Kr = PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->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_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->c[s][i],
-                           PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->c[s][i]);
+                    printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->c[s][i],
+                           PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->c[s][i]);
                 }
-            #endif
+#endif
               }
-              
-              PHY_vars_UE->total_TBS[eNB_id] =  PHY_vars_UE->total_TBS[eNB_id] + PHY_vars_UE->dlsch_ue[eNB_id][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][cw_non_sic]->current_harq_pid]->TBS;
 
-              // If the  receiver is NOT SIC, Here we are done with both CW, now only to calculate BLER  
+              PHY_vars_UE->total_TBS[eNB_id] =  PHY_vars_UE->total_TBS[eNB_id] + PHY_vars_UE->dlsch_ue[eNB_id][TB]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][TB]->current_harq_pid]->TBS;
+
+              // If the  receiver is NOT SIC, Here we are done with both CW, now only to calculate BLER
               //If the receiver IS SIC, we are done only with CW0, CW1 was only compensated by this moment (y1' obtained)
               if (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode == LARGE_CDD) {   //try to decode second stream using SIC
               /*
@@ -3577,15 +3607,15 @@ n(tikz_fname,"w");
               dlsch0_eNB_harq->rvidx        = dlsch0_ue_harq->rvidx;
               dlsch0_eNB_harq->Nl           = dlsch0_ue_harq->Nl;
               dlsch0_eNB_harq->round        = dlsch0_ue_harq->round;
-              
+
               dlsch0_eNB_harq->TBS          = dlsch0_ue_harq->TBS;
               dlsch0_eNB_harq->dl_power_off = dlsch0_ue_harq->dl_power_off;
               dlsch0_eNB_harq->status       = dlsch0_ue_harq->status;
-              
+
               PHY_vars_UE->dlsch_eNB[eNB_id]->active       = PHY_vars_UE->dlsch_ue[eNB_id][0]->active;
               PHY_vars_UE->dlsch_eNB[eNB_id]->rnti         = PHY_vars_UE->dlsch_ue[eNB_id][0]->rnti;
               PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid         = PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid;
-              
+
               dlsch_encoding(PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->b,
                  &PHY_vars_UE->lte_frame_parms,
                  num_pdcch_symbols,
@@ -3595,7 +3625,7 @@ n(tikz_fname,"w");
                  &PHY_vars_UE->dlsch_turbo_encoding_stats,
                  &PHY_vars_UE->dlsch_interleaving_stats
                  );
-              
+
               coded_bits_per_codeword = get_G(&PHY_vars_UE->lte_frame_parms,
                       PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->nb_rb,
                       PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->rb_alloc,
@@ -3603,8 +3633,8 @@ n(tikz_fname,"w");
                       PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->Nl,
                       num_pdcch_symbols,
                       0,subframe);
-              
-              
+
+
               //scrambling
               dlsch_scrambling(&PHY_vars_UE->lte_frame_parms,
                    0,
@@ -3612,8 +3642,8 @@ n(tikz_fname,"w");
                    coded_bits_per_codeword,
                    0,
                    subframe<<1);
-              
-              
+
+
               //modulation
               re_allocated = dlsch_modulation(sic_buffer,
                       AMP,
@@ -3627,7 +3657,7 @@ n(tikz_fname,"w");
               // compute the norm of the effective channel for both receive antennas -> alphha[0], alphha[2]
               // multiply with the norm of the effective channnel
               */
-              
+
               //stripping (from matched filter output of first stream = rxdataF_comp0)
               // this is pseudocode
               /*
@@ -3635,8 +3665,8 @@ n(tikz_fname,"w");
           PHY_vars_UE->lte_ue_pdsch_vars[eNB_id].rxdataF_ext[i] -=   alpha[i].*sic_buffer[i];
           }
               */
-              
-              //apply rho to output 
+
+              //apply rho to output
               /*
           dlsch_channel_compensation(PHY_vars_UE->lte_ue_pdsch_vars[eNB_id].rxdataF_ext,
                    PHY_vars_UE->lte_ue_pdsch_vars[eNB_id].dl_ch_rho_ext[harq_pid][round],
@@ -3654,22 +3684,26 @@ n(tikz_fname,"w");
           */
 
 
-              //detection of second stream  
+              //detection of second stream
               //}
-              
+
               }
-              
+
               if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
                   (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) &&
                   rx_type==rx_SIC_dual_stream) {
                // printf("current round = %d\n", PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->round);
 
+
+              //printf("\n CW 0 is decoded, i go for , round %d\n", round);
+              //printf("\n ret[TB0] = %d  round %d\n", ret[TB], round);
+
                 for (round_sic = 0 ; round_sic < (round +1); round_sic++) {
                 //printf("I enter round_sic loop \n");
                 //printf("round_sic= %d\n", round_sic);
                 dlsch0_ue_harq = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid];
                 dlsch0_eNB_harq = PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid];
-                  
+
                 dlsch0_eNB_harq->mimo_mode    = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode;
                 dlsch0_eNB_harq->rb_alloc[0]  = dlsch0_ue_harq->rb_alloc_even[0];
                 dlsch0_eNB_harq->nb_rb        = dlsch0_ue_harq->nb_rb;
@@ -3680,11 +3714,11 @@ n(tikz_fname,"w");
                 dlsch0_eNB_harq->TBS          = dlsch0_ue_harq->TBS;
                 dlsch0_eNB_harq->dl_power_off = dlsch0_ue_harq->dl_power_off;
                 dlsch0_eNB_harq->status       = dlsch0_ue_harq->status;
-                  
+
                 PHY_vars_UE->dlsch_eNB[eNB_id]->active                   = PHY_vars_UE->dlsch_ue[eNB_id][0]->active;
                 PHY_vars_UE->dlsch_eNB[eNB_id]->rnti                     = PHY_vars_UE->dlsch_ue[eNB_id][0]->rnti;
                 PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid         = PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid;
-                
+
                 dlsch_encoding(input_buffer0[0], //PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->b,
                                &PHY_vars_UE->lte_frame_parms,
                                num_pdcch_symbols,
@@ -3694,9 +3728,9 @@ n(tikz_fname,"w");
                                &PHY_vars_UE->dlsch_rate_matching_stats,
                                &PHY_vars_UE->dlsch_turbo_encoding_stats,
                                &PHY_vars_UE->dlsch_interleaving_stats);
-             
-                  
-                coded_bits_per_codeword[cw_non_sic]= get_G(&PHY_vars_UE->lte_frame_parms,
+
+
+                coded_bits_per_codeword[TB]= get_G(&PHY_vars_UE->lte_frame_parms,
                                                 PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->nb_rb,
                                                 PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->rb_alloc,
                                                 get_Qm(PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->mcs),
@@ -3708,7 +3742,7 @@ n(tikz_fname,"w");
                 dlsch_scrambling(&PHY_vars_UE->lte_frame_parms,
                                  0,
                                  PHY_vars_UE->dlsch_eNB[eNB_id],
-                                 coded_bits_per_codeword[cw_non_sic],
+                                 coded_bits_per_codeword[TB],
                                  0,
                                  subframe<<1);
 
@@ -3718,241 +3752,236 @@ n(tikz_fname,"w");
                                                     num_pdcch_symbols,
                                                     &PHY_vars_UE->dlsch_eNB[0][0],
                                                     NULL,
-                                                    coded_bits_per_codeword[cw_non_sic]);
-                  
+                                                    coded_bits_per_codeword[TB]);
+
                // write_output("sic_buffer.m","sic", *sic_buffer,re_allocated,1,1);
                // write_output("rxdataF_comp1.m","rxF_comp1", *PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round],14*12*25,1,1);
                // write_output("rxdataF_rho.m","rho", *PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round],14*12*25,1,1);
 
-                switch  (get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)){
-                  
+                switch  (get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs)){
+
                   case 2:
 
                     dlsch_qpsk_llr_SIC(&PHY_vars_UE->lte_frame_parms,
-                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
                                        sic_buffer,
-                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
-                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
                                        num_pdcch_symbols,
                                        dlsch0_eNB_harq->nb_rb,
                                        subframe,
                                        dlsch0_eNB_harq->rb_alloc[0],
-                                       get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs), 
-                                       PHY_vars_UE->dlsch_ue[eNB_id][0]);
+                                       get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs),
+                                       PHY_vars_UE->dlsch_ue[eNB_id][TB]);
                   break;
 
                   case 4:
 
                     dlsch_16qam_llr_SIC(&PHY_vars_UE->lte_frame_parms,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
                                         sic_buffer,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
                                         num_pdcch_symbols,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
                                         dlsch0_eNB_harq->nb_rb,
                                         subframe,
                                         dlsch0_eNB_harq->rb_alloc[0],
-                                        get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs),
+                                        get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs),
                                         PHY_vars_UE->dlsch_ue[eNB_id][0]);
                   break;
                   case 6:
                     dlsch_64qam_llr_SIC(&PHY_vars_UE->lte_frame_parms,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
                                         sic_buffer,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
                                         num_pdcch_symbols,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
                                         dlsch0_eNB_harq->nb_rb,
                                         subframe,
                                         dlsch0_eNB_harq->rb_alloc[0],
-                                        get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs),
-                                        PHY_vars_UE->dlsch_ue[eNB_id][0]);
+                                        get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs),
+                                        PHY_vars_UE->dlsch_ue[eNB_id][TB]);
                   break;
                     }
                   }
-            
+
                     //  write_output("rxdata_llr1.m","llr1", PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1],re_allocated*2,1,0);
-            
-                for (cw_sic=cw_to_decode_interf_free; cw_sic<cw_to_decode_interf_free+1;cw_sic++){
-                  PHY_vars_UE->dlsch_ue[0][cw_sic]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
-                  coded_bits_per_codeword[cw_sic]= get_G(&PHY_vars_eNB->lte_frame_parms,
-                                                         PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->nb_rb,
-                                                         PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->rb_alloc,
-                                                         get_Qm(PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->mcs),
-                                                         PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->Nl,
+
+                  // replace cw_sic with TB+1
+                  PHY_vars_UE->dlsch_ue[0][TB+1]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
+                  coded_bits_per_codeword[TB+1]= get_G(&PHY_vars_eNB->lte_frame_parms,
+                                                         PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->nb_rb,
+                                                         PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->rb_alloc,
+                                                         get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs),
+                                                         PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->Nl,
                                                          num_pdcch_symbols,
                                                          0,
                                                          subframe);
-                  
-                  PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_sic]->current_harq_pid]->G = coded_bits_per_codeword[cw_sic];
-                  PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_sic]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->mcs);
-                
+
+                  PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->G = coded_bits_per_codeword[TB+1];
+                  PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs);
+
                   if (n_frames==1) {
-                    printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,cw_sic,coded_bits_per_codeword[cw_sic],
-                    PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_sic]->current_harq_pid]->TBS);
-              
+                    printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,TB+1,coded_bits_per_codeword[TB+1],
+                    PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->TBS);
+
                   // calculate uncoded BER
-                    uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[cw_sic]);
+                    uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[TB+1]);
                     AssertFatal(uncoded_ber_bit, "uncoded_ber_bit==NULL");
-                    sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round, cw_sic);
-                    sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, cw_sic);
-                    write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[cw_sic],coded_bits_per_codeword[cw_sic],1,0);
-                    sprintf(fname,"dlsch_cw%d_e.m", cw_sic);
-                    sprintf(vname,"dlschcw%d_e", cw_sic);
-                    write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->e,coded_bits_per_codeword[cw_sic],1,4);
+                    sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round, TB+1);
+                    sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, TB+1);
+                    write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[TB+1],coded_bits_per_codeword[TB+1],1,0);
+                    sprintf(fname,"dlsch_cw%d_e.m", TB+1);
+                    sprintf(vname,"dlschcw%d_e", TB+1);
+                    write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->e,coded_bits_per_codeword[TB+1],1,4);
                     uncoded_ber=0;
                     printf("trials=%d\n", trials);
-                    for (i=0;i<coded_bits_per_codeword[cw_sic];i++) 
-                    if (PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[cw_sic][i]<0)) {
+                    for (i=0;i<coded_bits_per_codeword[TB+1];i++)
+                    if (PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword][i]<0)) {
                       uncoded_ber_bit[i] = 1;
                       uncoded_ber++;
-                    } 
+                    }
                     else
                     uncoded_ber_bit[i] = 0;
-                  
-                   uncoded_ber/=coded_bits_per_codeword[cw_sic];
+
+                   uncoded_ber/=coded_bits_per_codeword[TB+1];
                    avg_ber += uncoded_ber;
-                   sprintf(fname,"cw%d_uncoded_ber_bit.m", cw_sic);
-                   sprintf(vname,"uncoded_ber_bit_cw%d", cw_sic);
-                   write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[cw_sic],1,0);
-                   printf("cw %d, uncoded ber %f\n",cw_sic,uncoded_ber);     
+                   sprintf(fname,"cw%d_uncoded_ber_bit.m", TB+1);
+                   sprintf(vname,"uncoded_ber_bit_cw%d", TB+1);
+                   write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[TB+1],1,0);
+                   printf("cw %d, uncoded ber %f\n",TB+1,uncoded_ber);
                          free(uncoded_ber_bit);
-                   uncoded_ber_bit = NULL;  
+                   uncoded_ber_bit = NULL;
                 }
 
                 start_meas(&PHY_vars_UE->dlsch_unscrambling_stats);
                 dlsch_unscrambling(&PHY_vars_UE->lte_frame_parms,
                                    0,
-                                   PHY_vars_UE->dlsch_ue[0][cw_sic],
-                                   coded_bits_per_codeword[cw_sic],
-                                   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw_sic],
-                                   cw_sic,
+                                   PHY_vars_UE->dlsch_ue[0][TB+1],
+                                   coded_bits_per_codeword[TB+1],
+                                   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
+                                   TB+1,
                                    subframe<<1);
                 stop_meas(&PHY_vars_UE->dlsch_unscrambling_stats);
 
                 start_meas(&PHY_vars_UE->dlsch_decoding_stats);
                 ret[1] = dlsch_decoding(PHY_vars_UE,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
                                         &PHY_vars_UE->lte_frame_parms,
-                                        PHY_vars_UE->dlsch_ue[0][cw_sic],
-                                        PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_sic]->current_harq_pid],
+                                        PHY_vars_UE->dlsch_ue[0][TB+1],
+                                        PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid],
                                         subframe,
-                                        PHY_vars_UE->dlsch_ue[0][cw_sic]->current_harq_pid,
+                                        PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid,
                                         1,llr8_flag);
-                stop_meas(&PHY_vars_UE->dlsch_decoding_stats); 
-
-               // printf("retr cw 1 = %d\n", ret[1]);
-                 
-                if (ret[1] <= PHY_vars_UE->dlsch_ue[0][cw_sic]->max_turbo_iterations ) { 
-                
-                  avg_iter[1] += ret[1];
-                  iter_trials[1]++;
-                  
-                  
+                stop_meas(&PHY_vars_UE->dlsch_decoding_stats);
+
+                //printf("ret TB 1 = %d round %d \n", ret[1], round);
+
+                if (ret[TB+1] <= PHY_vars_UE->dlsch_ue[0][TB+1]->max_turbo_iterations ) {
+
+                  avg_iter[TB+1] += ret[TB+1];
+                  iter_trials[TB+1]++;
+
+
                   if (n_frames==1) {
-                    printf("cw sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",cw_sic,round,uncoded_ber);
-                    
+                    printf("cw sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",TB+1,round,uncoded_ber);
+
                     #ifdef PRINT_BYTES
-                    for (s=0;s<PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->C;s++) {
-                    if (s<PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->Cminus)
-                      Kr = PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->Kminus;
+                    for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->C;s++) {
+                    if (s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Cminus)
+                      Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kminus;
                     else
-                      Kr = PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->Kplus;
+                      Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->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_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->c[s][i],
-                      PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->c[s][i]);
+                      printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i],
+                      PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->c[s][i]);
                     }
                     #endif
-                  }  
-                  
-                }    
-                else {
-                  errs[cw_sic][round]++;
-                 // exit(0);
-                  
-                  if (cw_sic==1) {
-                    avg_iter[1] += ret[1]-1;
-                    iter_trials[1]++;
                   }
-                  
-                  if (n_frames==2) {
-              //if ((n_frames==1) || (SNR>=30)) {
-              printf("cw sic %d, round %d: DLSCH errors found, uncoded ber %f\n",cw_sic,round,uncoded_ber);
-          #ifdef PRINT_BYTES
-              for (s=0;s<PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->C;s++) {
-                if (s<PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->Cminus)
-                  Kr = PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->Kminus;
-                else
-                  Kr = PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->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_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->c[s][i],
-                   PHY_vars_UE->dlsch_ue[0][cw_sic]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][cw_sic]->harq_processes[0]->c[s][i]);
-              }
-          #endif
+                } else{
+                  errs[TB+1][round]++;
+                 // exit(0);
+
+                  avg_iter[TB+1] += ret[TB+1]-1;
+                  iter_trials[TB+1]++;
+
+                  if (n_frames==1) {
+                    //if ((n_frames==1) || (SNR>=30)) {
+                    printf("cw sic %d, round %d: DLSCH errors found, uncoded ber %f\n",TB+1,round,uncoded_ber);
+#ifdef PRINT_BYTES
+                    for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->C;s++) {
+                      if (s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Cminus)
+                        Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kminus;
+                      else
+                        Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->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_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i],
+                         PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->c[s][i]);
+                    }
+#endif
                   } //n_frames==1
                  // exit(0);
-                } //if (ret > PHY_vars_UE->dlsch_ue[0][cw_sic]->max_turbo_iterations ) 
-              } //for (int cw_1=cw_to_decode_interf_free; cw_1<cw_to_decode_interf_free+1;cw_1++)
-                    
-                
-            } //if SIC
-            
-            
-          } //if (ret <= PHY_vars_UE->dlsch_ue[0][cw_non_sic]->max_turbo_iterations )
-            else {
-              errs[cw_non_sic][round]++;
-              
-              if (cw_non_sic==0) {
+              } //if (ret > PHY_vars_UE->dlsch_ue[0][TB+1]->max_turbo_iterations )
+            }//if SIC
+          } else {
+
+            errs[TB][round]++;
+
+
+              /*if (cw_non_sic==0) {
           avg_iter[0] += ret[0]-1;
           iter_trials[0]++;
+              }*/
+
+            if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
+              (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) &&
+                (rx_type==rx_SIC_dual_stream)) {
+                errs[TB+1][round]++;
               }
-              
-                if (rx_type==rx_SIC_dual_stream) {
-           errs[1][round]++;
-              }
-              
-                if (cw_non_sic==1) {
+
+                /*if (cw_non_sic==1) {
           avg_iter[1] += ret[1]-1;
           iter_trials[1]++;
-              }
-              
-                      
+              }*/
+
+
               if (n_frames==1) {
           //if ((n_frames==1) || (SNR>=30)) {
-          printf("cw %d, round %d: DLSCH errors found, uncoded ber %f\n",cw_non_sic,round,uncoded_ber);
-      #ifdef PRINT_BYTES
-          for (s=0;s<PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->C;s++) {
-            if (s<PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->Cminus)
-              Kr = PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->Kminus;
-            else
-              Kr = PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->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_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->c[s][i],
-               PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][cw_non_sic]->harq_processes[0]->c[s][i]);
-          }
-      #endif
+                printf("cw %d, round %d: DLSCH errors found, uncoded ber %f\n",TB,round,uncoded_ber);
+#ifdef PRINT_BYTES
+                for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->C;s++) {
+                  if (s<PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->Cminus)
+                    Kr = PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->Kminus;
+                  else
+                    Kr = PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->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_UE->dlsch_ue[0][TB]->harq_processes[0]->c[s][i],
+                     PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->c[s][i]);
+                }
+#endif
               }
             }
+            TB++; // to terminate the loop over TB
           }
-        
+
           stop_meas(&PHY_vars_UE->phy_proc_rx);
-          
+
           if (n_frames==1) {
 
             //rxsig
@@ -4024,25 +4053,26 @@ n(tikz_fname,"w");
             //pdcch_vars
             write_output("pdcchF0_ext.m","pdcchF_ext", PHY_vars_UE->lte_ue_pdcch_vars[eNB_id]->rxdataF_ext[0],2*3*PHY_vars_UE->lte_frame_parms.ofdm_symbol_size,1,1);
             write_output("pdcch00_ch0_ext.m","pdcch00_ch0_ext",PHY_vars_UE->lte_ue_pdcch_vars[eNB_id]->dl_ch_estimates_ext[0],300*3,1,1);
-            
+
             write_output("pdcch_rxF_comp0.m","pdcch0_rxF_comp0",PHY_vars_UE->lte_ue_pdcch_vars[eNB_id]->rxdataF_comp[0],4*300,1,1);
             write_output("pdcch_rxF_llr.m","pdcch_llr",PHY_vars_UE->lte_ue_pdcch_vars[eNB_id]->llr,2400,1,4);
-            
-            
+
+
             if (round == 3) exit(-1);
           }
 
           if (xforms==1) {
-            phy_scope_UE(form_ue, 
+            phy_scope_UE(form_ue,
              PHY_vars_UE,
              eNB_id,
              0,// UE_id
-             subframe); 
+             subframe);
           }
-        
 
-          
+
+
           if ((transmission_mode != 3 && transmission_mode !=4 ) && ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations){
+            //printf("flag 1 \n");
             round++;
           }
 
@@ -4052,51 +4082,56 @@ n(tikz_fname,"w");
             round++;
             resend_cw0_cw1=1;  //resend both cws
             resend_cw1=0;
-            
+            TB0_active=1;
+            //printf("flag 2 \n");
+
           }
 
           if ((transmission_mode == 3 || transmission_mode == 4 ) && (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations ) && (ret[0] <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)){
             resend_one[round]++;
             round++;
             resend_cw0_cw1=0;
-            resend_cw1=1; //resend only cw1, alamouti
-            
+            TB0_active=0;
+            //PHY_vars_UE->PHY_measurements.rank[eNB_id]=0;
+           // printf("\n DLSIM TB0 disactivated\n");
+            //printf("flag 3 \n");
+
           }
 
         }
-   //}  //round
+
 
         if(transmission_mode != 3 && transmission_mode !=4 ){
           if ((errs[0][0]>=n_frames/10) && (trials>(n_frames/2)) )
           break;
-        }  
+        }
 
         //len = chbch_stats_read(stats_buffer,NULL,0,4096);
         //printf("%s\n\n",stats_buffer);
-          
+
         if (PHY_vars_UE->frame_rx % 10 == 0) {
           PHY_vars_UE->bitrate[eNB_id] = (PHY_vars_UE->total_TBS[eNB_id] - PHY_vars_UE->total_TBS_last[eNB_id])*10;
           LOG_D(PHY,"[UE %d] Calculating bitrate: total_TBS = %d, total_TBS_last = %d, bitrate = %d kbits/s\n",PHY_vars_UE->Mod_id,PHY_vars_UE->total_TBS[eNB_id],PHY_vars_UE->total_TBS_last[eNB_id],PHY_vars_UE->bitrate[eNB_id]/1000);
           PHY_vars_UE->total_TBS_last[eNB_id] = PHY_vars_UE->total_TBS[eNB_id];
         }
 
-          
+
         PHY_vars_UE->frame_rx++;
-       
-        /* calculate the total processing time for each packet, 
+
+        /* calculate the total processing time for each packet,
          * get the max, min, and number of packets that exceed t>2000us
          */
-        double t_tx = (double)PHY_vars_eNB->phy_proc_tx.p_time/cpu_freq_GHz/1000.0;        
-        double t_tx_ifft = (double)PHY_vars_eNB->ofdm_mod_stats.p_time/cpu_freq_GHz/1000.0;        
-        double t_tx_mod = (double)PHY_vars_eNB->dlsch_modulation_stats.p_time/cpu_freq_GHz/1000.0;        
-        double t_tx_enc = (double)PHY_vars_eNB->dlsch_encoding_stats.p_time/cpu_freq_GHz/1000.0;        
-        
-        
-        double t_rx = (double)PHY_vars_UE->phy_proc_rx.p_time/cpu_freq_GHz/1000.0;        
-        double t_rx_fft = (double)PHY_vars_UE->ofdm_demod_stats.p_time/cpu_freq_GHz/1000.0;        
-        double t_rx_demod = (double)PHY_vars_UE->dlsch_rx_pdcch_stats.p_time/cpu_freq_GHz/1000.0;        
-        double t_rx_dec = (double)PHY_vars_UE->dlsch_decoding_stats.p_time/cpu_freq_GHz/1000.0;    
-              
+        double t_tx = (double)PHY_vars_eNB->phy_proc_tx.p_time/cpu_freq_GHz/1000.0;
+        double t_tx_ifft = (double)PHY_vars_eNB->ofdm_mod_stats.p_time/cpu_freq_GHz/1000.0;
+        double t_tx_mod = (double)PHY_vars_eNB->dlsch_modulation_stats.p_time/cpu_freq_GHz/1000.0;
+        double t_tx_enc = (double)PHY_vars_eNB->dlsch_encoding_stats.p_time/cpu_freq_GHz/1000.0;
+
+
+        double t_rx = (double)PHY_vars_UE->phy_proc_rx.p_time/cpu_freq_GHz/1000.0;
+        double t_rx_fft = (double)PHY_vars_UE->ofdm_demod_stats.p_time/cpu_freq_GHz/1000.0;
+        double t_rx_demod = (double)PHY_vars_UE->dlsch_rx_pdcch_stats.p_time/cpu_freq_GHz/1000.0;
+        double t_rx_dec = (double)PHY_vars_UE->dlsch_decoding_stats.p_time/cpu_freq_GHz/1000.0;
+
               if (t_tx > t_tx_max)
           t_tx_max = t_tx;
               if (t_tx < t_tx_min)
@@ -4109,13 +4144,13 @@ n(tikz_fname,"w");
           n_tx_dropped++;
               if (t_rx > 2000)
           n_rx_dropped++;
-              
+
 
               push_front(&time_vector_tx, t_tx);
               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);
-        
+
               push_front(&time_vector_rx, t_rx);
               push_front(&time_vector_rx_fft, t_rx_fft);
               push_front(&time_vector_rx_demod, t_rx_demod);
@@ -4123,8 +4158,8 @@ n(tikz_fname,"w");
 
 
             }   //trials
-        printf("both failed round 0 = %d, both failed round 1 = %d, both failed round 2 = %d, both failed round 3 = %d\n", resend_both[0], resend_both[1], resend_both[2], resend_both[3]);
-        printf("one failed round 0 = %d, one failed round 1 = %d, one failed round 2 = %d, one failed round 3 = %d\n", resend_one[0], resend_one[1], resend_one[2], resend_one[3]);
+        printf("\n both failed round 0 = %d, both failed round 1 = %d, both failed round 2 = %d, both failed round 3 = %d\n", resend_both[0], resend_both[1], resend_both[2], resend_both[3]);
+        printf(" one failed round 0  = %d, one failed round 1  = %d, one failed round 2  = %d, one failed round 3  = %d\n", resend_one[0], resend_one[1], resend_one[2], resend_one[3]);
 
       // round_trials[0]: number of code word : goodput the protocol
       double table_tx[time_vector_tx.size];
@@ -4221,13 +4256,72 @@ n(tikz_fname,"w");
         ((double)(round_trials[1][0])/((double)round_trials[1][0] + round_trials[1][1] + round_trials[1][2] + round_trials[1][3]));
       }
 
+      /*
+      Here we compute throughput per cw based on the formula
+      T=P_suc[r1]R(mcs) + sum[r=2 ..r=4] (P_(suc r, fail r-1)*R/r).
+      The non-constr formula should not be used, when there are some errors on the last round,
+      meaning when not all the packages are finally decoded.
+      */
+
+      if (transmission_mode == 3 || transmission_mode == 4) {
+        // FOR CW0
+        thr_cw0[0] = rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0]));
+        thr_cw0[1] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/2)*(((double)errs[0][0] - (double)errs[0][1])/(double)round_trials[0][0]);
+        thr_cw0[2] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/3)*(((double)errs[0][1] - (double)errs[0][2])/(double)round_trials[0][0]);
+        thr_cw0[3] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/4)*(((double)errs[0][2] - (double)errs[0][3])/(double)round_trials[0][0]);
+        thr_cw0_tot = (double)thr_cw0[0]+(double)thr_cw0[1]+(double)thr_cw0[2]+(double)thr_cw0[3];
+        printf("\n Throughput cw0 sum =  %f \n", thr_cw0_tot);
+        printf("round_trials =  %d, errs[0][0] = %d, round_trials[0][1] = %d, errs[0][1] = %d, round_trials[0][2] = %d, errs[0][2] = %d, \
+        round_trials[0][3] = %d, errs[0][3] = %d \n", round_trials[0][0], errs[0][0],round_trials[0][1], errs[0][1], round_trials[0][2], \
+        errs[0][2], round_trials[0][3], errs[0][3]);
+
+        thr_cw1[0] = rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0]));
+        thr_cw1[1] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/2)*(((double)errs[1][0] - (double)errs[1][1])/(double)round_trials[1][0]);
+        thr_cw1[2] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/3)*(((double)errs[1][1] - (double)errs[1][2])/(double)round_trials[1][0]);
+        thr_cw1[3] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/4)*(((double)errs[1][2] - (double)errs[1][3])/(double)round_trials[1][0]);
+        thr_cw1_tot = (double)thr_cw1[0]+(double)thr_cw1[1]+(double)thr_cw1[2]+(double)thr_cw1[3];
+        printf("Throughput cw1 sum =  %f \n", thr_cw1_tot);
+        printf("Throughput cw1 round 0 =  %f \n", thr_cw1[0]);
+        printf("Throughput cw1 round 1 =  %f \n", thr_cw1[1]);
+        printf("Throughput cw1 round 2 =  %f \n", thr_cw1[2]);
+        printf("Throughput cw1 round 3 =  %f \n", thr_cw1[3]);
+        printf("round_trials[1][0] =  %d, errs[1][0] = %d, round_trials[1][1] = %d, errs[1][1] = %d, round_trials[1][2] = %d, errs[1][2] = %d, \
+          round_trials[1][3] = %d, errs[1][3] = %d \n", round_trials[1][0], errs[1][0], round_trials[1][1], errs[1][1], round_trials[1][2], \
+          errs[1][2], round_trials[1][3], errs[1][3]);
+      }
+
+#if 0
+        thr_cw0_tm4_nonconst = rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)* \
+        ((double)(round_trials[0][0]-dci_errors)/((double)round_trials[0][0] + round_trials[0][1] + round_trials[0][2] + round_trials[0][3]));
+        printf("Throughput cw0 noncnstr =  %f \n", thr_cw0_tm4_nonconst);
+#endif
+        //FOR CW1
+       /*thr_cw1[0] = rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0])) \
+       *(1-((double)errs[1][0]/(double)round_trials[1][0]));
+       printf("thr cw1 round 0 = %f\n", thr_cw1[0]);
+        thr_cw1[1]=(rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/2)*\
+        (((double)errs[1][0]-(double)errs[1][1])*((double)round_trials[0][0] - (double)errs[0][1])/((double)round_trials[0][0]*(double)round_trials[1][0]));
+        printf("thr cw1 round 1 = %f\n", thr_cw1[1]);
+        thr_cw1[2] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/3)*\
+       ((double)errs[1][1]-(double)errs[1][2])*((double)round_trials[0][0]-(double)errs[0][2])/((double)round_trials[0][0]*(double)round_trials[1][0]);
+        printf("thr cw1 round 2 = %f\n", thr_cw1[2]);
+        thr_cw1[3] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/4)*\
+        ((double)errs[1][2]-(double)errs[1][3])*((double)round_trials[0][0] - (double)errs[0][3])/((double)round_trials[0][0]*(double)round_trials[1][0]);
+        resid_errs=
+        printf("thr cw1 round 3 = %f\n", thr_cw1[3]);
+        thr_cw1_tot =thr_cw1[0]+thr_cw1[1]+thr_cw1[2]+thr_cw1[3];
+        printf("Throughput cw1 sum =  %f \n", thr_cw1_tot);
+        printf("round_trials =  %d, errs[1][0] = %d, round_trials[1][1] = %d, errs[1][1] = %d, round_trials[1][2] = %d, errs[1][2] = %d, \
+          round_trials[1][3] = %d, errs[1][3] = %d \n", round_trials[1][0], errs[1][0],round_trials[1][1], errs[1][1], round_trials[1][2], \
+          errs[1][2], round_trials[1][3], errs[1][3]);
+      }*/
 
 
       printf("\n**********************SNR = %f dB (tx_lev %f, sigma2_dB %f)**************************\n",
              SNR,
              (double)tx_lev_dB+10*log10(PHY_vars_UE->lte_frame_parms.ofdm_symbol_size/(NB_RB*12)),
               sigma2_dB);
-      
+
       printf("Errors (%d(%d)/%d %d(%d)/%d %d(%d)/%d %d(%d)/%d), Pe = (%e(%e),%e(%e),%e(%e),%e(%e)),"
               "dci_errors %d/%d, Pe = %e => effective rate %f  (%2.1f%%,%f, %f), normalized delay %f (%f), "
               "throughput stream 0 = %f , throughput stream 1 = %f, system throughput = %f , rate 0 = %f , rate 1 = %f \n",
@@ -4262,14 +4356,19 @@ n(tikz_fname,"w");
         4.0*(round_trials[0][3]-errs[0][3]))/((double)round_trials[0][0])/(double)PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
        (1.0*(round_trials[0][0]-errs[0][0])+2.0*(round_trials[0][1]-errs[0][1])+3.0*(round_trials[0][2]-errs[0][2])
         +4.0*(round_trials[0][3]-errs[0][3]))/((double)round_trials[0][0]),
-       rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0])),
-       rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[0][1])),
-       rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0]))+
-       rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[0][1])),
+       thr_cw0_tot,
+       thr_cw1_tot,
+       thr_cw0_tot + thr_cw1_tot,
        rate[0],
        rate[1]);
-        
-      
+
+
+
+
+
+
+
+
 
       if (print_perf==1) {
         printf("eNB TX function statistics (per 1ms subframe)\n\n");
@@ -4417,19 +4516,19 @@ n(tikz_fname,"w");
                 rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0])),
                 dci_errors);
             }
-   
+
 
       if(abstx){ //ABSTRACTION
-  if ((transmission_mode != 3)&& (transmission_mode != 4)) {         
+  if ((transmission_mode != 3)&& (transmission_mode != 4)) {
     blerr[0][0] = (double)errs[0][0]/(round_trials[0][0]);
-    
+
     if(num_rounds>1){
       blerr[0][1] = (double)errs[0][1]/(round_trials[0][1]);
-      
+
       blerr[0][2] = (double)errs[0][2]/(round_trials[0][2]);
-      
+
       blerr[0][3] = (double)errs[0][3]/(round_trials[0][3]);
-      
+
       fprintf(csv_fd,"%e;%e;%e;%e;\n",blerr[0][0],blerr[0][1],blerr[0][2],blerr[0][3]);
     }
     else {
@@ -4453,7 +4552,7 @@ n(tikz_fname,"w");
     }
   }
      }
-            
+
       if ( (test_perf != 0) && (100 * effective_rate > test_perf )) {
   //fprintf(time_meas_fd,"SNR; MCS; TBS; rate; err0; trials0; err1; trials1; err2; trials2; err3; trials3; dci_err\n");
   if ((transmission_mode != 3) && (transmission_mode != 4)) {
@@ -4515,7 +4614,7 @@ n(tikz_fname,"w");
       errs[0][3],
       round_trials[0][3],
       dci_errors);
-    
+
     //fprintf(time_meas_fd,"SNR; MCS; TBS; rate; DL_DECOD_ITER; err0; trials0; err1; trials1; err2; trials2; err3; trials3; PE; dci_err;PE;ND;\n");
     fprintf(time_meas_fd,"%f;%d;%d;%d;%d;%f;%2.1f;%f;%f;%d;%d;%d;%d;%d;%d;%d;%d;%e;%e;%e;%e;%d;%d;%e;%f;%f;",
       SNR,
@@ -4545,7 +4644,7 @@ n(tikz_fname,"w");
       (1.0*(round_trials[0][0]-errs[0][0])+2.0*(round_trials[0][1]-errs[0][1])+3.0*(round_trials[0][2]-errs[0][2])+4.0*(round_trials[0][3]-errs[0][3]))/((double)round_trials[0][0]));
   }
   //fprintf(time_meas_fd,"eNB_PROC_TX(%d); OFDM_MOD(%d); DL_MOD(%d); DL_SCR(%d); DL_ENC(%d); UE_PROC_RX(%d); OFDM_DEMOD_CH_EST(%d); RX_PDCCH(%d); CH_COMP_LLR(%d); DL_USCR(%d); DL_DECOD(%d);\n",
-  fprintf(time_meas_fd,"%d; %d; %d; %d; %d; %d; %d; %d; %d; %d; %d;", 
+  fprintf(time_meas_fd,"%d; %d; %d; %d; %d; %d; %d; %d; %d; %d; %d;",
     PHY_vars_eNB->phy_proc_tx.trials,
     PHY_vars_eNB->ofdm_mod_stats.trials,
     PHY_vars_eNB->dlsch_modulation_stats.trials,
@@ -4573,31 +4672,31 @@ n(tikz_fname,"w");
     );
   //fprintf(time_meas_fd,"eNB_PROC_TX_STD;eNB_PROC_TX_MAX;eNB_PROC_TX_MIN;eNB_PROC_TX_MED;eNB_PROC_TX_Q1;eNB_PROC_TX_Q3;eNB_PROC_TX_DROPPED;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f;%f;%f;%d;", std_phy_proc_tx, t_tx_max, t_tx_min, tx_median, tx_q1, tx_q3, n_tx_dropped);
-  
+
   //fprintf(time_meas_fd,"IFFT;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f;", std_phy_proc_tx_ifft, tx_ifft_median, tx_ifft_q1, tx_ifft_q3);
-  
+
   //fprintf(time_meas_fd,"MOD;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f;", std_phy_proc_tx_mod, tx_mod_median, tx_mod_q1, tx_mod_q3);
-  
+
   //fprintf(time_meas_fd,"ENC;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f;", std_phy_proc_tx_enc, tx_enc_median, tx_enc_q1, tx_enc_q3);
-  
-  
+
+
   //fprintf(time_meas_fd,"UE_PROC_RX_STD;UE_PROC_RX_MAX;UE_PROC_RX_MIN;UE_PROC_RX_MED;UE_PROC_RX_Q1;UE_PROC_RX_Q3;UE_PROC_RX_DROPPED;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f;%f;%f;%d;", std_phy_proc_rx, t_rx_max, t_rx_min, rx_median, rx_q1, rx_q3, n_rx_dropped);
 
   //fprintf(time_meas_fd,"FFT;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f;", std_phy_proc_rx_fft, rx_fft_median, rx_fft_q1, rx_fft_q3);
-  
+
   //fprintf(time_meas_fd,"DEMOD;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f;", std_phy_proc_rx_demod,rx_demod_median, rx_demod_q1, rx_demod_q3);
-  
+
   //fprintf(time_meas_fd,"DEC;\n");
   fprintf(time_meas_fd,"%f;%f;%f;%f\n", std_phy_proc_rx_dec, rx_dec_median, rx_dec_q1, rx_dec_q3);
-  
 
-  /*  
+
+  /*
     fprintf(time_meas_fd,"%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;",
     PHY_vars_eNB->phy_proc_tx.trials,
     PHY_vars_eNB->ofdm_mod_stats.trials,
@@ -4622,34 +4721,34 @@ n(tikz_fname,"w");
       if (((double)errs[0][0]/(round_trials[0][0]))<1e-2 && ((double)errs[1][0]/(round_trials[1][0]))<1e-2)
       break;
     }
-    else{ 
-      if (((double)errs[0][0]/(round_trials[0][0]))<1e-2) 
+    else{
+      if (((double)errs[0][0]/(round_trials[0][0]))<1e-2)
       break;
-    
+
       }
   }
   else {
-    
+
      if ((rx_type==rx_IC_dual_stream) || (rx_type==rx_standard) || (rx_type==rx_SIC_dual_stream)) {
       if (((double)errs[0][0]/(round_trials[0][0]))<1e-3 && ((double)errs[1][0]/(round_trials[1][0]))<1e-3)
       break;
     }
-    else{ 
-      if (((double)errs[0][0]/(round_trials[0][0]))<1e-3) 
+    else{
+      if (((double)errs[0][0]/(round_trials[0][0]))<1e-3)
       break;
-    
+
       }
-    
+
   }
-  
-      
+
+
       if (n_frames==1)
   break;
 
       }// SNR
-      
+
   } //ch_realization
-  
+
   fclose(bler_fd);
 
   if (test_perf !=0)