From 26407d26afa17c34f762bea7e377a12ef194d766 Mon Sep 17 00:00:00 2001
From: Nick Ho <nick133371@gmail.com>
Date: Sun, 14 May 2017 14:38:06 +0200
Subject: [PATCH] ADD PHY_CONFIG and PHY Parameters for NB-IoT

---
 cmake_targets/CMakeLists.txt    |    1 +
 openair1/PHY/INIT/defs-nb.h     |  384 +++++++
 openair1/PHY/INIT/lte_init-nb.c | 1822 +++++++++++++++++++++++++++++++
 openair1/PHY/impl_defs_lte-nb.h |  222 ++++
 4 files changed, 2429 insertions(+)
 create mode 100644 openair1/PHY/INIT/defs-nb.h
 create mode 100644 openair1/PHY/INIT/lte_init-nb.c
 create mode 100644 openair1/PHY/impl_defs_lte-nb.h

diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt
index 7f9b294ae9..7cadb5acdb 100644
--- a/cmake_targets/CMakeLists.txt
+++ b/cmake_targets/CMakeLists.txt
@@ -1043,6 +1043,7 @@ set(PHY_SRC
   ${OPENAIR1_DIR}/PHY/CODING/viterbi.c
   ${OPENAIR1_DIR}/PHY/CODING/viterbi_lte.c
   ${OPENAIR1_DIR}/PHY/INIT/lte_init.c
+  ${OPENAIR1_DIR}/PHY/INIT/lte_init-nb.c
   ${OPENAIR1_DIR}/PHY/INIT/lte_parms.c
   ${OPENAIR1_DIR}/PHY/INIT/lte_param_init.c
   ${OPENAIR1_DIR}/PHY/TOOLS/file_output.c
diff --git a/openair1/PHY/INIT/defs-nb.h b/openair1/PHY/INIT/defs-nb.h
new file mode 100644
index 0000000000..059d802a71
--- /dev/null
+++ b/openair1/PHY/INIT/defs-nb.h
@@ -0,0 +1,384 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#ifndef __INIT_DEFS__H__
+#define __INIT_DEFS__H__
+
+#include "PHY/defs.h"
+
+
+#include "SystemInformationBlockType2.h"
+//#include "RadioResourceConfigCommonSIB.h"
+#include "RadioResourceConfigDedicated.h"
+#include "TDD-Config.h"
+#include "MBSFN-SubframeConfigList.h"
+#include "MobilityControlInfo.h"
+#if defined(Rel10) || defined(Rel14)
+#include "SCellToAddMod-r10.h"
+#endif
+/** @addtogroup _PHY_STRUCTURES_
+ * @{
+ */
+
+/*!
+\fn int phy_init_top(LTE_DL_FRAME_PARMS *frame_parms)
+\brief Allocate and Initialize the PHY variables after receiving static configuration
+@param frame_parms Pointer to LTE_DL_FRAME_PARMS (common configuration)
+@returns 0 on success
+ */
+int phy_init_top(LTE_DL_FRAME_PARMS *frame_parms);
+
+
+/*!
+\brief Allocate and Initialize the PHY variables relevant to the LTE implementation.
+\details Only a subset of phy_vars_ue is initialized.
+@param[out] phy_vars_ue Pointer to UE Variables
+@param nb_connected_eNB Number of eNB that UE can process in one PDSCH demodulation subframe
+@param abstraction_flag 1 indicates memory should be allocated for abstracted MODEM
+@returns 0 on success
+@returns -1 if any memory allocation failed
+@note The current implementation will never return -1, but segfault.
+ */
+int phy_init_lte_ue(PHY_VARS_UE *phy_vars_ue,
+                    int          nb_connected_eNB,
+                    uint8_t         abstraction_flag);
+
+/*!
+\brief Allocate and initialize the PHY variables relevant to the LTE implementation (eNB).
+\details Only a subset of phy_vars_eNb is initialized.
+@param[out] phy_vars_eNb Pointer to eNB Variables
+@param is_secondary_eNb Flag to indicate this eNB gets synch from another
+@param abstraction_flag 1 indicates memory should be allocated for abstracted MODEM
+@returns 0 on success
+@returns -1 if any memory allocation failed
+@note The current implementation will never return -1, but segfault.
+ */
+int phy_init_lte_eNB(PHY_VARS_eNB *phy_vars_eNb,
+                     unsigned char is_secondary_eNb,
+                     unsigned char abstraction_flag);
+
+/** \brief Configure LTE_DL_FRAME_PARMS with components derived after initial synchronization (MIB decoding + primary/secondary synch).
+\details The basically allows configuration of \f$N_{\mathrm{RB}}^{\mathrm{DL}}\f$, the cell id  \f$N_{\mathrm{ID}}^{\mathrm{cell}}\f$, the normal/extended prefix mode, the frame type (FDD/TDD), \f$N_{\mathrm{cp}}\f$, the number of TX antennas at eNB (\f$p\f$) and the number of PHICH groups, \f$N_{\mathrm{group}}^{\mathrm{PHICH}}\f$
+@param lte_frame_parms pointer to LTE parameter structure
+@param N_RB_DL Number of DL resource blocks
+@param Nid_cell Cell ID
+@param Ncp Normal/Extended Prefix flag
+@param frame_type FDD/TDD framing
+@param p_eNB Number of eNB TX antennas
+@param phich_config Pointer to PHICH_CONFIG_COMMON
+ */
+void phy_config_mib(LTE_DL_FRAME_PARMS *lte_frame_parms,
+                    uint8_t                N_RB_DL,
+                    uint8_t                Nid_cell,
+                    uint8_t                Ncp,
+                    uint8_t                frame_type,
+                    uint8_t                p_eNB,
+                    PHICH_CONFIG_COMMON *phich_config);
+
+
+/** \brief Configure LTE_DL_FRAME_PARMS with components derived after reception of SIB1.
+\details From a PHY perspective this allows configuration of TDD framing parameters and SI reception.
+@param Mod_id Instance ID of eNB
+@param CC_id Component Carrier index
+@param tdd_Config TDD UL/DL and S-subframe configurations
+@param SIwindowsize Size of a SI window in frames where repetitions of a unique System Information message block is repeated
+@param SIperiod Periodicity of System Information Messages (in multiples of a frame)*/
+void phy_config_sib1_eNB(module_id_t    Mod_id,
+                         int CC_id,
+                         TDD_Config_t  *tdd_Config,
+                         uint8_t           SIwindowsize,
+                         uint16_t            SIperiod);
+
+/** \brief Configure LTE_DL_FRAME_PARMS with components derived after reception of SIB1.
+\details From a PHY perspective this allows configuration of TDD framing parameters and SI reception.
+@param Mod_id Instance ID of UE
+@param CC_id Component Carrier index
+@param CH_index Index of eNB for this configuration
+@param tdd_Config TDD UL/DL and S-subframe configurations
+@param SIwindowsize Size of a SI window in frames where repetitions of a unique System Information message block is repeated
+@param SIperiod Periodicity of System Information Messages (in multiples of a frame)*/
+void phy_config_sib1_ue(module_id_t   Mod_id,
+                        int CC_id,
+                        uint8_t          CH_index,
+                        TDD_Config_t *tdd_Config,
+                        uint8_t          SIwindowsize,
+                        uint16_t           SIperiod);
+
+
+/*!
+  \fn void phy_config_sib2_ue(module_id_t Mod_id,uint8_t CC_id,uint8_t CH_index,
+      RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
+      ARFCN_ValueEUTRA_t *ul_CArrierFreq,
+            long *ul_Bandwidth,
+      AdditionalSpectrumEmission_t additionalSpectrumEmission,
+      struct MBSFN_SubframeConfigList *mbsfn_SubframeConfigList)
+  \brief Configure LTE_DL_FRAME_PARMS with components derived after reception of SIB2 (at UE).
+  @param Mod_id Instance id
+  @param CC_id
+  @param CH_index Index of CH to which UE is connected
+  @param CC_id Component Carrier Index
+  @param radioResourceConfigCommon Radio Configuration from SIB2
+  @param ul_CarrierFreq UL carrier ARFCN, null if optional (i.e. implicit from DL)
+  @param ul_Bandwidth UL bandwidth, null if optional (i.e. same as DL)
+  @param additionalSpectrumEmission UL parameter (see 36.101)
+  @param mbsfn_SubframeConfigList MBSFN subframe configuration
+ */
+void phy_config_sib2_ue(module_id_t                     Mod_id,
+                        int                         CC_id,
+                        uint8_t                         CH_index,
+                        RadioResourceConfigCommonSIB_t  *radioResourceConfigCommon,
+                        ARFCN_ValueEUTRA_t              *ul_CArrierFreq,
+                        long                            *ul_Bandwidth,
+                        AdditionalSpectrumEmission_t    *additionalSpectrumEmission,
+                        struct MBSFN_SubframeConfigList *mbsfn_SubframeConfigList);
+
+
+/*!
+  \fn phy_config_afterHO_ue
+  \brief Configure Common PHY parameters from mobilityControlInfo
+  @param Mod_id
+  @param CC_id
+  @param eNB_index
+  @param mobilityControlInfo pointer to the mobility control information for handover
+  @param ho_failed flag to indicated whether the ho was successful or not
+ */
+void phy_config_afterHO_ue(module_id_t Mod_id,
+                           uint8_t CC_id,
+                           uint8_t eNB_index,
+                           MobilityControlInfo_t *mobilityControlInfo,
+                           uint8_t ho_failed);
+/*!
+  \fn void phy_config_sib2_eNB(module_id_t Mod_id,
+                               RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
+             ARFCN_ValueEUTRA_t *ul_CArrierFreq,
+             long *ul_Bandwidth,
+             AdditionalSpectrumEmission_t additionalSpectrumEmission,
+             struct MBSFN_SubframeConfigList  *mbsfn_SubframeConfigList)
+  \brief Configure LTE_DL_FRAME_PARMS with components of SIB2 (at eNB).
+  @param Mod_id Instance id
+  @param Mod_id Component Carrier index
+  @param radioResourceConfigCommon Radio Configuration from SIB2
+  @param ul_CarrierFreq UL carrier ARFCN, null if optional (i.e. implicit from DL)
+  @param ul_Bandwidth UL bandwidth, null if optional (i.e. same as DL)
+  @param additionalSpectrumEmission UL parameter (see 36.101)
+  @param mbsfn_SubframeConfigList MBSFN subframe configuration
+ */
+void phy_config_sib2_eNB(module_id_t                            Mod_id,
+                         int                                CC_id,
+                         RadioResourceConfigCommonSIB_t         *radioResourceConfigCommon,
+                         ARFCN_ValueEUTRA_t                     *ul_CArrierFreq,
+                         long                                   *ul_Bandwidth,
+                         AdditionalSpectrumEmission_t           *additionalSpectrumEmission,
+                         struct MBSFN_SubframeConfigList        *mbsfn_SubframeConfigList);
+
+
+/*!
+\fn void phy_config_dedicated_ue(module_id_t Mod_id,uint8_t CC_id,uint8_t CH_index,
+               struct PhysicalConfigDedicated *physicalConfigDedicated)
+\brief Configure UE dedicated parameters.
+\details Invoked upon reception of RRCConnectionSetup or RRCConnectionReconfiguration from eNB.
+@param Mod_id Instance ID for eNB
+@param CC_id Component Carrier index
+@param CH_index Index of eNB for this configuration
+@param physicalConfigDedicated PHY Configuration information
+
+ */
+void phy_config_dedicated_ue(module_id_t Mod_id,
+                             int CC_id,
+                             uint8_t CH_index,
+                             struct PhysicalConfigDedicated *physicalConfigDedicated);
+
+/*!
+\fn void phy_config_harq_ue(module_id_t Mod_id,uint8_t CC_id,uint8_t CH_index,
+               uint16_t max_harq_tx)
+\brief Configure UE UL max harq Tx.
+\details Invoked upon reception of RRCConnectionSetup or RRCConnectionReconfiguration from eNB.
+@param Mod_id Instance ID for eNB
+@param CC_id Component Carrier index
+@param CH_index Index of eNB for this configuration
+@param max_harq_tx max harq tx information
+
+ */
+void phy_config_harq_ue(module_id_t Mod_id,int CC_id,uint8_t CH_index,
+                           uint16_t max_harq_tx);
+/**
+\brief Configure UE MBSFN common parameters.
+\details Invoked upon reception of SIB13 from eNB.
+@param Mod_id Instance ID for UE
+@param CC_id Component Carrier Index
+@param CH_index eNB id (for multiple eNB reception)
+@param mbsfn_Area_idx Index of MBSFN-Area for which this command operates
+@param mbsfn_AreaId_r9 MBSFN-Area Id
+ */
+
+void phy_config_sib13_ue(module_id_t Mod_id,
+                         int CC_id,uint8_t CH_index,int mbsfn_Area_idx,
+                         long mbsfn_AreaId_r9);
+
+/**
+\brief Configure eNB MBSFN common parameters.
+\details Invoked upon transmission of SIB13 from eNB.
+@param Mod_id Instance ID for eNB
+@param CC_id Component Carrier index
+@param mbsfn_Area_idx Index of MBSFN-Area for which this command operates
+@param mbsfn_AreaId_r9 MBSFN-Area Id
+ */
+void phy_config_sib13_eNB(module_id_t Mod_id,
+                          int CC_id,
+                          int mbsfn_Area_idx,
+                          long mbsfn_AreaId_r9);
+
+/**
+\brief Configure cba rnti for .
+@param Mod_id Instance ID for eNB
+@param CC_id Component Carrier Index
+@param eNB_flag flag indicating whether the nodeis eNB (1) or UE (0)
+@param index index of the node
+@param cba_rnti rnti for the cba transmission
+@param num_active_cba_groups num active cba group
+ */
+void  phy_config_cba_rnti (module_id_t Mod_id,int CC_id,eNB_flag_t eNB_flag, uint8_t index, rnti_t cba_rnti, uint8_t cba_group_id, uint8_t num_active_cba_groups);
+
+/** \brief Configure RRC inter-cell measurements procedures
+@param Mod_id Index of UE
+@param CC_id
+@param eNB_index Index of corresponding eNB
+@param n_adj_cells Number of adjacent cells on which to perform the measuremnts
+@param adj_cell_id Array of cell ids of adjacent cells
+ */
+void phy_config_meas_ue(module_id_t Mod_id,
+                        uint8_t CC_id,
+                        uint8_t eNB_index,
+                        uint8_t n_adj_cells,
+                        uint32_t *adj_cell_id);
+
+/*!
+\fn void phy_config_dedicated_eNB(module_id_t Mod_id,uint16_t rnti,
+                                  struct PhysicalConfigDedicated *physicalConfigDedicated)
+\brief Prepare for configuration of PHY with dedicated parameters.
+\details Invoked just prior to transmission of RRCConnectionSetup or RRCConnectionReconfiguration at eNB.
+@param Mod_id Instance ID for eNB
+@param CC_id Component Carrier index
+@param rnti rnti for UE context
+@param physicalConfigDedicated PHY Configuration information
+ */
+void phy_config_dedicated_eNB(module_id_t Mod_id,
+                              int CC_id,
+                              rnti_t rnti,
+                              struct PhysicalConfigDedicated *physicalConfigDedicated);
+
+/*!
+\fn void phy_config_dedicated_eNB_step2(PHY_VARS_eNB *phy_vars_eNB)
+\brief Configure PHY with dedicated parameters between configuration of DLSCH (n) and ULSCH (n+4) in current subframe (n).
+@param phy_vars_eNB Pointer to PHY_VARS_eNB structure
+ */
+void phy_config_dedicated_eNB_step2(PHY_VARS_eNB *phy_vars_eNB);
+
+/*
+  \fn int phy_init_secsys_eNB(PHY_VARS_eNB *phy_vars_eNb)
+\brief Allocate and Initialize the PHY variables relevant to the LTE implementation.
+@param phy_vars_eNb pointer to LTE parameter structure for the eNb
+ */
+int phy_init_secsys_eNB(PHY_VARS_eNB *phy_vars_eNb);
+
+
+void phy_init_lte_top(LTE_DL_FRAME_PARMS *lte_frame_parms);
+
+//void copy_lte_parms_to_phy_framing(LTE_DL_FRAME_PARMS *frame_parm, PHY_FRAMING *phy_framing);
+
+void lte_param_init(unsigned char N_tx_port_eNB,
+		    unsigned char N_tx, 
+		    unsigned char N_rx,
+		    unsigned char transmission_mode,
+		    uint8_t extended_prefix_flag,
+		    frame_t frame_type, 
+		    uint16_t Nid_cell,
+		    uint8_t tdd_config,
+		    uint8_t N_RB_DL,
+		    uint8_t threequarter_fs,
+                    uint8_t osf,
+		    uint32_t perfect_ce);
+
+#if defined(Rel10) || defined(Rel14)
+void phy_config_dedicated_scell_ue(uint8_t Mod_id,
+                                   uint8_t eNB_index,
+                                   SCellToAddMod_r10_t *sCellToAddMod_r10,
+                                   int CC_id);
+
+void phy_config_dedicated_scell_eNB(uint8_t Mod_id,
+                                    uint16_t rnti,
+                                    SCellToAddMod_r10_t *sCellToAddMod_r10,
+                                    int CC_id);
+
+#endif
+
+/*brief Configure LTE_DL_FRAME_PARMS with components derived after initial synchronization (MIB-NB decoding + primary/secondary synch).*/
+void NB_phy_config_mib_eNB(int                    Mod_id,
+			int                    CC_id,
+			int                    eutra_band,
+			int                    Nid_cell,
+			int                    Ncp,
+			int                    p_eNB,
+			uint32_t               dl_CarrierFreq,
+			uint32_t               ul_CarrierFreq,
+			struct MasterInformationBlock_NB__operationModeInfo_r13_u operationModeInfo);
+
+/*NB_phy_config_sib1_eNB is not needed since NB-IoT use only FDD mode*/
+
+/*brief Configure LTE_DL_FRAME_PARMS with components of SIB2-NB (at eNB).*/
+void NB_phy_config_sib2_eNB(module_id_t                            Mod_id,
+                         int                                CC_id,
+                         RadioResourceConfigCommonSIB_NB_r13         *radioResourceConfigCommon,
+                         ARFCN_ValueEUTRA_r9_t                     *ul_CArrierFreq,,
+                         );
+
+void NB_phy_config_dedicated_eNB(module_id_t Mod_id,
+                              int CC_id,
+                              rnti_t rnti,
+                              struct PhysicalConfigDedicated_NB_r13 *physicalConfigDedicated);
+
+
+
+
+
+/*! !\fn void phy_cleanup(void)
+\brief Cleanup the PHY variables*/
+void phy_cleanup(void);
+
+
+int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf);
+void dump_frame_parms(LTE_DL_FRAME_PARMS *frame_parms);
+
+void lte_param_init(unsigned char N_tx_port_eNB, 
+                    unsigned char N_tx_phy,
+		    unsigned char N_rx,
+		    unsigned char transmission_mode,
+		    uint8_t extended_prefix_flag,
+		    frame_t frame_type, 
+		    uint16_t Nid_cell,
+		    uint8_t tdd_config,
+		    uint8_t N_RB_DL,
+		    uint8_t threequarter_fs,
+                    uint8_t osf,
+		    uint32_t perfect_ce);
+/** @} */
+#endif
+
diff --git a/openair1/PHY/INIT/lte_init-nb.c b/openair1/PHY/INIT/lte_init-nb.c
new file mode 100644
index 0000000000..490159e138
--- /dev/null
+++ b/openair1/PHY/INIT/lte_init-nb.c
@@ -0,0 +1,1822 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#include "defs.h"
+#include "SCHED/defs.h"
+#include "PHY/extern.h"
+#include "SIMULATION/TOOLS/defs.h"
+#include "RadioResourceConfigCommonSIB.h"
+#include "RadioResourceConfigDedicated.h"
+#include "TDD-Config.h"
+#include "LAYER2/MAC/extern.h"
+#include "MBSFN-SubframeConfigList.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+#define DEBUG_PHY
+#include "assertions.h"
+#include <math.h>
+
+#include "defs-nb.h"
+#include "RadioResourceConfigCommonSIB-NB-r13.h"
+#include "PHY/impl_defs_lte-nb.h"
+
+extern uint16_t prach_root_sequence_map0_3[838];
+extern uint16_t prach_root_sequence_map4[138];
+uint8_t dmrs1_tab[8] = {0,2,3,4,6,8,9,10};
+
+
+void NB_phy_config_mib_eNB(int                 Mod_id,
+			int                 CC_id,
+			int                 eutra_band,
+			int                 Nid_cell,
+			int                 Ncp,
+			int                 p_eNB,
+			uint32_t            dl_CarrierFreq,
+			uint32_t            ul_CarrierFreq) {
+
+  /*Not sure if phy parameters should be initial here or not*/
+  /*the phy_config_mib_eNB as the entry point to allocate the context for L1.  The RC contains the context for L1,L2. If RC.eNB is NULL, it hasn't been allocated earlier so we allocate it there.*/
+  /*if (RC.eNB == NULL) {
+    RC.eNB                               = (PHY_VARS_eNB ***)malloc((1+NUMBER_OF_eNB_MAX)*sizeof(PHY_VARS_eNB***));
+    LOG_I(PHY,"RC.eNB = %p\n",RC.eNB);
+    memset(RC.eNB,0,(1+NUMBER_OF_eNB_MAX)*sizeof(PHY_VARS_eNB***));
+  }
+  if (RC.eNB[Mod_id] == NULL) {
+    RC.eNB[Mod_id]                       = (PHY_VARS_eNB **)malloc((1+MAX_NUM_CCs)*sizeof(PHY_VARS_eNB**));
+    LOG_I(PHY,"RC.eNB[%d] = %p\n",Mod_id,RC.eNB[Mod_id]);
+    memset(RC.eNB[Mod_id],0,(1+MAX_NUM_CCs)*sizeof(PHY_VARS_eNB***));
+  }
+  if (RC.eNB[Mod_id][CC_id] == NULL) {
+    RC.eNB[Mod_id][CC_id] = (PHY_VARS_eNB *)malloc(sizeof(PHY_VARS_eNB));
+    LOG_I(PHY,"RC.eNB[%d][%d] = %p\n",Mod_id,CC_id,RC.eNB[Mod_id][CC_id]);
+    RC.eNB[Mod_id][CC_id]->Mod_id        = Mod_id;
+    RC.eNB[Mod_id][CC_id]->CC_id         = CC_id;
+  }
+
+  RC.eNB[Mod_id][CC_id]->mac_enabled     = 1;
+
+  fp = &RC.eNB[Mod_id][CC_id]->frame_parms; */
+
+  NB_DL_FRAME_PARMS *fp = &PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms;
+
+   //LOG_I(PHY,"Configuring MIB-NB for instance %d, CCid %d : (band %d,N_RB_DL %d,Nid_cell %d,p %d,DL freq %u)\n",
+	//Mod_id, CC_id, eutra_band, N_RB_DL_array[dl_Bandwidth], Nid_cell, p_eNB,dl_CarrierFreq);
+
+  fp->Nid_cell                           = Nid_cell;
+  fp->nushift                            = Nid_cell%6;
+  fp->eutra_band                         = eutra_band;
+  fp->Ncp                                = Ncp;
+  fp->nb_antenna_ports_eNB               = p_eNB;
+  fp->dl_CarrierFreq                     = dl_CarrierFreq;
+  fp->ul_CarrierFreq                     = ul_CarrierFreq;
+  
+
+  init_frame_parms(fp,1);
+  //init_lte_top(fp);
+
+}
+
+void NB_phy_config_sib2_eNB(uint8_t Mod_id,
+                         int CC_id,
+                         RadioResourceConfigCommonSIB_NB_r13_t *radioResourceConfigCommon,
+                         ARFCN_ValueEUTRA_r9_t *ul_CArrierFreq
+                         )
+{
+	NB_DL_FRAME_PARMS *fp = &PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms;
+	  //LTE_eNB_UE_stats *eNB_UE_stats		= PHY_vars_eNB_g[Mod_id][CC_id]->eNB_UE_stats;
+	  //int32_t rx_total_gain_eNB_dB		= PHY_vars_eNB_g[Mod_id][CC_id]->rx_total_gain_eNB_dB;
+	  int i;
+	  uint8_t MAX_NPRACH = 4;
+          NPRACH_Parameters_NB_r13_t *np;
+	  
+	  LOG_D(PHY,"[eNB%d] CCid %d: Applying radioResourceConfigCommon_NB\n",Mod_id,CC_id);
+	  
+      /*NPRACH configCommon*/
+	  fp->nprach_config_common.nprach_CP_Length                                     =radioResourceConfigCommon->nprach_Config_r13.nprach_CP_Length_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_CP_Length = %d\n",fp->nprach_config_common.nprach_CP_Length);
+	  //fp->nprach_config_common.rsrp_ThresholdsPrachInfoList.list                    =radioResourceConfigCommon->nprach_Config_r13.rsrp_ThresholdsPrachInfoList_r13.list;
+	  //LOG_D(PHY,"nprach_config_common.rsrp_ThresholdsPrachInfoList = %d\n",fp->nprach_config_common.rsrp_ThresholdsPrachInfoList);
+
+	  /*Loop over the configuration according to the maxNPRACH_Resources*/
+      for (fp->CE=0; fp->CE <= MAX_NPRACH;fp->CE++){
+      np = radioResourceConfigCommon->nprach_Config_r13.nprach_ParametersList_r13.list.array[fp->CE];	  	
+      /*fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->maxNumPreambleAttemptCE           =np->maxNumPreambleAttemptCE_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.maxNumPreambleAttemptCE = %d\n",fp->nprach_config_common.nprach_ParametersList.list.maxNumPreambleAttemptCE);
+      fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->npdcch_NumRepetitions_RA          =np->npdcch_NumRepetitions_RA_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.npdcch_NumRepetitions_RA = %d\n",fp->nprach_config_common.nprach_ParametersList.list.npdcch_NumRepetitions_RA);
+      fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->nprach_Periodicity                =np->nprach_Periodicity_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.nprach_Periodicity = %d\n",fp->nprach_config_common.nprach_ParametersList.list.nprach_Periodicity);
+      fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->nprach_StartTime                  =np->nprach_StartTime_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.nprach_StartTime = %d\n",fp->nprach_config_common.nprach_ParametersList.list.nprach_StartTime);
+      fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->nprach_SubcarrierOffset           =np->nprach_SubcarrierOffset_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.nprach_SubcarrierOffset = %d\n",fp->nprach_config_common.nprach_ParametersList.list.nprach_SubcarrierOffset);
+      fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->nprach_SubcarrierMSG3_RangeStart  =np->nprach_SubcarrierMSG3_RangeStart_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.nprach_SubcarrierMSG3_RangeStart = %d\n",fp->nprach_config_common.nprach_ParametersList.list.nprach_SubcarrierMSG3_RangeStart);
+      fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->npdcch_Offset_RA                  =np->npdcch_Offset_RA_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.npdcch_Offset_RA = %d\n",fp->nprach_config_common.nprach_ParametersList.list.npdcch_Offset_RA);
+      fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->npdcch_StartSF_CSS_RA             =np->npdcch_StartSF_CSS_RA_r13;
+	  //LOG_D(PHY,"nprach_config_common.nprach_ParametersList.list.npdcch_StartSF_CSS_RA = %d\n",fp->nprach_config_common.nprach_ParametersList.list.array[fp->CE]->npdcch_StartSF_CSS_RA);
+      */	  
+      }
+
+	  /*Should modify to compute_nprach_seq*/
+	  //compute_prach_seq(&fp->prach_config_common,fp->frame_type,PHY_vars_eNB_g[Mod_id][CC_id]->X_u);
+	  
+	  /*NPDSCH ConfigCommon*/
+	  fp->npdsch_config_common.nrs_Power           = radioResourceConfigCommon->npdsch_ConfigCommon_r13.nrs_Power_r13;
+	
+	  /*NPUSCH ConfigCommon*/
+	  /*A list (1-3) should be loop for ack_NACK_NumRepetitions_Msg4*/
+	  for (fp->CE=1; fp->CE <= MAX_NPRACH;fp->CE++){
+	  fp->npusch_config_common.ack_NACK_NumRepetitions_Msg4[fp->CE]        = radioResourceConfigCommon->npusch_ConfigCommon_r13.ack_NACK_NumRepetitions_Msg4_r13.list.array[fp->CE];
+          //LOG_D(PHY,"npusch_config_common.ack_NACK_NumRepetitions_Msg4 = %d]n",fp->npusch_config_common.ack_NACK_NumRepetitions_Msg4);
+	  }
+	  fp->npusch_config_common.srs_SubframeConfig                          = radioResourceConfigCommon->npusch_ConfigCommon_r13.srs_SubframeConfig_r13;
+	  LOG_D(PHY,"npusch_config_common.srs_SubframeConfig = %d]n",fp->npusch_config_common.srs_SubframeConfig);
+	  fp->npusch_config_common.dmrs_Config.threeTone_BaseSequence          = radioResourceConfigCommon->npusch_ConfigCommon_r13.dmrs_Config_r13->threeTone_BaseSequence_r13;
+	  LOG_D(PHY,"npusch_config_common.dmrs_Config.threeTone_BaseSequence = %d]n",fp->npusch_config_common.dmrs_Config.threeTone_BaseSequence);
+	  fp->npusch_config_common.dmrs_Config.sixTone_BaseSequence            = radioResourceConfigCommon->npusch_ConfigCommon_r13.dmrs_Config_r13->sixTone_BaseSequence_r13;
+	  LOG_D(PHY,"npusch_config_common.dmrs_Config.sixTone_BaseSequence = %d]n",fp->npusch_config_common.dmrs_Config.sixTone_BaseSequence);
+	  fp->npusch_config_common.dmrs_Config.threeTone_CyclicShift           = radioResourceConfigCommon->npusch_ConfigCommon_r13.dmrs_Config_r13->threeTone_CyclicShift_r13;
+	  LOG_D(PHY,"npusch_config_common.dmrs_Config.threeTone_CyclicShift = %d]n",fp->npusch_config_common.dmrs_Config.threeTone_CyclicShift);
+	  fp->npusch_config_common.dmrs_Config.sixTone_CyclicShift             = radioResourceConfigCommon->npusch_ConfigCommon_r13.dmrs_Config_r13->sixTone_CyclicShift_r13;
+	  LOG_D(PHY,"npusch_config_common.dmrs_Config.sixTone_CyclicShift = %d]n",fp->npusch_config_common.dmrs_Config.sixTone_CyclicShift);
+	  fp->npusch_config_common.dmrs_Config.twelveTone_BaseSequence         = radioResourceConfigCommon->npusch_ConfigCommon_r13.dmrs_Config_r13->twelveTone_BaseSequence_r13;
+	  LOG_D(PHY,"npusch_config_common.dmrs_Config.twelveTone_BaseSequence = %d]n",fp->npusch_config_common.dmrs_Config.twelveTone_BaseSequence);
+
+	  fp->npusch_config_common.ul_ReferenceSignalsNPUSCH.groupAssignmentNPUSCH  = radioResourceConfigCommon->npusch_ConfigCommon_r13.ul_ReferenceSignalsNPUSCH_r13.groupAssignmentNPUSCH_r13;
+	  LOG_D(PHY,"npusch_config_common.ul_ReferenceSignalsNPUSCH.groupAssignmentNPUSCH = %d]n",fp->npusch_config_common.ul_ReferenceSignalsNPUSCH.groupAssignmentNPUSCH);
+	  fp->npusch_config_common.ul_ReferenceSignalsNPUSCH.groupHoppingEnabled    = radioResourceConfigCommon->npusch_ConfigCommon_r13.ul_ReferenceSignalsNPUSCH_r13.groupHoppingEnabled_r13;
+	  LOG_D(PHY,"npusch_config_common.ul_ReferenceSignalsNPUSCH.groupHoppingEnabled = %d]n",fp->npusch_config_common.ul_ReferenceSignalsNPUSCH.groupHoppingEnabled);
+
+      /*should change the part that implement the ul hopping in NB-IoT*/
+	  init_ul_hopping(fp);
+
+	  /*UL Power Control Config Common*/
+	
+	  fp->ul_power_control_config_common.p0_NominalNPUSCH      = radioResourceConfigCommon->uplinkPowerControlCommon_r13.p0_NominalNPUSCH_r13;
+	  fp->ul_power_control_config_common.alpha				   = radioResourceConfigCommon->uplinkPowerControlCommon_r13.alpha_r13;
+      fp->ul_power_control_config_common.deltaPreambleMsg3     = radioResourceConfigCommon->uplinkPowerControlCommon_r13.deltaPreambleMsg3_r13;
+
+	  /*DL gap*/
+                                                                                                    
+          fp->DL_gap_config.dl_GapDurationCoeff                        = radioResourceConfigCommon->dl_Gap_r13->dl_GapDurationCoeff_r13;
+	  fp->DL_gap_config.dl_GapPeriodicity                      = radioResourceConfigCommon->dl_Gap_r13->dl_GapPeriodicity_r13;
+	  fp->DL_gap_config.dl_GapThreshold                        = radioResourceConfigCommon->dl_Gap_r13->dl_GapThreshold_r13;
+	  
+	  /*PUCCH stuff in LTE*/
+	  //init_ncs_cell(fp,PHY_vars_eNB_g[Mod_id][CC_id]->ncs_cell);
+	
+	  init_ul_hopping(fp);
+	
+	
+	  
+}
+
+void NB_phy_config_dedicated_eNB(uint8_t Mod_id,
+                              int CC_id,
+                              uint16_t rnti,
+                              struct PhysicalConfigDedicated_NB_r13 *physicalConfigDedicated)
+{
+	  PHY_VARS_eNB *eNB = PHY_vars_eNB_g[Mod_id][CC_id];
+	  int8_t UE_id = find_ue(rnti,eNB);
+	
+	  if (UE_id == -1) {
+		LOG_E( PHY, "[eNB %"PRIu8"] find_ue() returns -1\n", Mod_id);
+		return;
+	  }
+	
+	/*physicalconfigDedicated is defined in PHY_VARS_eNB in defs.h in PHY layer*/
+	  if (physicalConfigDedicated) {
+		eNB->physicalConfigDedicated[UE_id] = physicalConfigDedicated;
+		LOG_I(PHY,"phy_config_dedicated_eNB: physicalConfigDedicated=%p\n",physicalConfigDedicated);
+	
+	  } else {
+		LOG_E(PHY,"[eNB %d] Received NULL radioResourceConfigDedicated from eNB %d\n",Mod_id, UE_id);
+		return;
+	  }
+	
+	}
+
+
+// FIXME not used anywhere
+void phy_config_mib(LTE_DL_FRAME_PARMS *fp,
+                    uint8_t N_RB_DL,
+                    uint8_t Nid_cell,
+                    uint8_t Ncp,
+                    uint8_t frame_type,
+                    uint8_t p_eNB,
+                    PHICH_CONFIG_COMMON *phich_config)
+{
+  fp->N_RB_DL                            = N_RB_DL;
+  fp->Nid_cell                           = Nid_cell;
+  fp->nushift                            = Nid_cell%6;
+  fp->Ncp                                = Ncp;
+  fp->frame_type                         = frame_type;
+  fp->nb_antenna_ports_eNB               = p_eNB;
+  fp->phich_config_common.phich_resource = phich_config->phich_resource;
+  fp->phich_config_common.phich_duration = phich_config->phich_duration;
+}
+
+void phy_config_sib1_eNB(uint8_t Mod_id,
+                         int CC_id,
+                         TDD_Config_t *tdd_Config,
+                         uint8_t SIwindowsize,
+                         uint16_t SIPeriod)
+{
+
+  LTE_DL_FRAME_PARMS *fp = &PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms;
+
+  if (tdd_Config) {
+    fp->tdd_config    = tdd_Config->subframeAssignment;
+    fp->tdd_config_S  = tdd_Config->specialSubframePatterns;
+  }
+
+  fp->SIwindowsize  = SIwindowsize;
+  fp->SIPeriod      = SIPeriod;
+}
+
+void phy_config_sib1_ue(uint8_t Mod_id,int CC_id,
+                        uint8_t eNB_id,
+                        TDD_Config_t *tdd_Config,
+                        uint8_t SIwindowsize,
+                        uint16_t SIperiod)
+{
+
+  LTE_DL_FRAME_PARMS *fp = &PHY_vars_UE_g[Mod_id][CC_id]->frame_parms;
+
+  if (tdd_Config) {
+    fp->tdd_config    = tdd_Config->subframeAssignment;
+    fp->tdd_config_S  = tdd_Config->specialSubframePatterns;
+  }
+
+  fp->SIwindowsize  = SIwindowsize;
+  fp->SIPeriod      = SIperiod;
+}
+
+void phy_config_sib2_eNB(uint8_t Mod_id,
+                         int CC_id,
+                         RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
+                         ARFCN_ValueEUTRA_t *ul_CArrierFreq,
+                         long *ul_Bandwidth,
+                         AdditionalSpectrumEmission_t *additionalSpectrumEmission,
+                         struct MBSFN_SubframeConfigList  *mbsfn_SubframeConfigList)
+{
+
+  LTE_DL_FRAME_PARMS *fp = &PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms;
+  //LTE_eNB_UE_stats *eNB_UE_stats      = PHY_vars_eNB_g[Mod_id][CC_id]->eNB_UE_stats;
+  //int32_t rx_total_gain_eNB_dB        = PHY_vars_eNB_g[Mod_id][CC_id]->rx_total_gain_eNB_dB;
+  int i;
+
+  LOG_D(PHY,"[eNB%d] CCid %d: Applying radioResourceConfigCommon\n",Mod_id,CC_id);
+
+  fp->prach_config_common.rootSequenceIndex                           =radioResourceConfigCommon->prach_Config.rootSequenceIndex;
+  LOG_D(PHY,"prach_config_common.rootSequenceIndex = %d\n",fp->prach_config_common.rootSequenceIndex );
+
+  fp->prach_config_common.prach_Config_enabled=1;
+
+  fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex          =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.prach_ConfigIndex;
+  LOG_D(PHY,"prach_config_common.prach_ConfigInfo.prach_ConfigIndex = %d\n",fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex);
+
+  fp->prach_config_common.prach_ConfigInfo.highSpeedFlag              =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.highSpeedFlag;
+  LOG_D(PHY,"prach_config_common.prach_ConfigInfo.highSpeedFlag = %d\n",fp->prach_config_common.prach_ConfigInfo.highSpeedFlag);
+  fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig  =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.zeroCorrelationZoneConfig;
+  LOG_D(PHY,"prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig = %d\n",fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig);
+  fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset           =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.prach_FreqOffset;
+  LOG_D(PHY,"prach_config_common.prach_ConfigInfo.prach_FreqOffset = %d\n",fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset);
+  compute_prach_seq(&fp->prach_config_common,fp->frame_type,
+                    PHY_vars_eNB_g[Mod_id][CC_id]->X_u);
+
+  fp->pucch_config_common.deltaPUCCH_Shift = 1+radioResourceConfigCommon->pucch_ConfigCommon.deltaPUCCH_Shift;
+  fp->pucch_config_common.nRB_CQI          = radioResourceConfigCommon->pucch_ConfigCommon.nRB_CQI;
+  fp->pucch_config_common.nCS_AN           = radioResourceConfigCommon->pucch_ConfigCommon.nCS_AN;
+  fp->pucch_config_common.n1PUCCH_AN       = radioResourceConfigCommon->pucch_ConfigCommon.n1PUCCH_AN;
+
+
+
+  fp->pdsch_config_common.referenceSignalPower = radioResourceConfigCommon->pdsch_ConfigCommon.referenceSignalPower;
+  fp->pdsch_config_common.p_b                  = radioResourceConfigCommon->pdsch_ConfigCommon.p_b;
+
+
+  fp->pusch_config_common.n_SB                                         = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.n_SB;
+  LOG_D(PHY,"pusch_config_common.n_SB = %d\n",fp->pusch_config_common.n_SB );
+
+  fp->pusch_config_common.hoppingMode                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode;
+  LOG_D(PHY,"pusch_config_common.hoppingMode = %d\n",fp->pusch_config_common.hoppingMode);
+
+  fp->pusch_config_common.pusch_HoppingOffset                          = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset;
+  LOG_D(PHY,"pusch_config_common.pusch_HoppingOffset = %d\n",fp->pusch_config_common.pusch_HoppingOffset);
+
+  fp->pusch_config_common.enable64QAM                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM;
+  LOG_D(PHY,"pusch_config_common.enable64QAM = %d\n",fp->pusch_config_common.enable64QAM );
+
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled    = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled;
+  LOG_D(PHY,"pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled = %d\n",fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled);
+
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH   = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH;
+  LOG_D(PHY,"pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH = %d\n",fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH);
+
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled;
+  LOG_D(PHY,"pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = %d\n",fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled);
+
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift            = dmrs1_tab[radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift];
+  LOG_D(PHY,"pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift = %d\n",fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift);
+
+  init_ul_hopping(fp);
+
+  fp->soundingrs_ul_config_common.enabled_flag                        = 0;
+
+  if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.present==SoundingRS_UL_ConfigCommon_PR_setup) {
+    fp->soundingrs_ul_config_common.enabled_flag                        = 1;
+    fp->soundingrs_ul_config_common.srs_BandwidthConfig                 = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_BandwidthConfig;
+    fp->soundingrs_ul_config_common.srs_SubframeConfig                  = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_SubframeConfig;
+    fp->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission;
+
+    if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts)
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 1;
+    else
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 0;
+  }
+
+
+
+  fp->ul_power_control_config_common.p0_NominalPUSCH       = radioResourceConfigCommon->uplinkPowerControlCommon.p0_NominalPUSCH;
+  fp->ul_power_control_config_common.alpha                 = radioResourceConfigCommon->uplinkPowerControlCommon.alpha;
+  fp->ul_power_control_config_common.p0_NominalPUCCH       = radioResourceConfigCommon->uplinkPowerControlCommon.p0_NominalPUCCH;
+  fp->ul_power_control_config_common.deltaPreambleMsg3     = radioResourceConfigCommon->uplinkPowerControlCommon.deltaPreambleMsg3;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format1  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format1b  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1b;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2a  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2a;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2b  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2b;
+
+  fp->maxHARQ_Msg3Tx = radioResourceConfigCommon->rach_ConfigCommon.maxHARQ_Msg3Tx;
+
+
+  // Now configure some of the Physical Channels
+
+  // PUCCH
+
+  init_ncs_cell(fp,PHY_vars_eNB_g[Mod_id][CC_id]->ncs_cell);
+
+  init_ul_hopping(fp);
+
+
+  // MBSFN
+  if (mbsfn_SubframeConfigList != NULL) {
+    fp->num_MBSFN_config = mbsfn_SubframeConfigList->list.count;
+
+    for (i=0; i<mbsfn_SubframeConfigList->list.count; i++) {
+      fp->MBSFN_config[i].radioframeAllocationPeriod = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationPeriod;
+      fp->MBSFN_config[i].radioframeAllocationOffset = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationOffset;
+
+      if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) {
+        fp->MBSFN_config[i].fourFrames_flag = 0;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig = mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]; // 6-bit subframe configuration
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      } else if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_fourFrames) { // 24-bit subframe configuration
+        fp->MBSFN_config[i].fourFrames_flag = 1;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig =
+          mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[1]<<8)|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[2]<<16);
+
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      }
+    }
+
+  } else
+    fp->num_MBSFN_config = 0;
+}
+
+
+void phy_config_sib2_ue(uint8_t Mod_id,int CC_id,
+                        uint8_t eNB_id,
+                        RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
+                        ARFCN_ValueEUTRA_t *ul_CarrierFreq,
+                        long *ul_Bandwidth,
+                        AdditionalSpectrumEmission_t *additionalSpectrumEmission,
+                        struct MBSFN_SubframeConfigList *mbsfn_SubframeConfigList)
+{
+
+  PHY_VARS_UE *ue        = PHY_vars_UE_g[Mod_id][CC_id];
+  LTE_DL_FRAME_PARMS *fp = &ue->frame_parms;
+  int i;
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_UE_CONFIG_SIB2, VCD_FUNCTION_IN);
+
+  LOG_I(PHY,"[UE%d] Applying radioResourceConfigCommon from eNB%d\n",Mod_id,eNB_id);
+
+  fp->prach_config_common.rootSequenceIndex                           =radioResourceConfigCommon->prach_Config.rootSequenceIndex;
+
+  fp->prach_config_common.prach_Config_enabled=1;
+  fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex          =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.prach_ConfigIndex;
+  fp->prach_config_common.prach_ConfigInfo.highSpeedFlag              =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.highSpeedFlag;
+  fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig  =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.zeroCorrelationZoneConfig;
+  fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset           =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.prach_FreqOffset;
+
+  compute_prach_seq(&fp->prach_config_common,fp->frame_type,ue->X_u);
+
+
+
+  fp->pucch_config_common.deltaPUCCH_Shift = 1+radioResourceConfigCommon->pucch_ConfigCommon.deltaPUCCH_Shift;
+  fp->pucch_config_common.nRB_CQI          = radioResourceConfigCommon->pucch_ConfigCommon.nRB_CQI;
+  fp->pucch_config_common.nCS_AN           = radioResourceConfigCommon->pucch_ConfigCommon.nCS_AN;
+  fp->pucch_config_common.n1PUCCH_AN       = radioResourceConfigCommon->pucch_ConfigCommon.n1PUCCH_AN;
+
+
+
+  fp->pdsch_config_common.referenceSignalPower = radioResourceConfigCommon->pdsch_ConfigCommon.referenceSignalPower;
+  fp->pdsch_config_common.p_b                  = radioResourceConfigCommon->pdsch_ConfigCommon.p_b;
+
+
+  fp->pusch_config_common.n_SB                                         = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.n_SB;
+  fp->pusch_config_common.hoppingMode                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode;
+  fp->pusch_config_common.pusch_HoppingOffset                          = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset;
+  fp->pusch_config_common.enable64QAM                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled    = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH   = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift            = dmrs1_tab[radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift];
+
+
+  init_ul_hopping(fp);
+  fp->soundingrs_ul_config_common.enabled_flag                        = 0;
+
+  if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.present==SoundingRS_UL_ConfigCommon_PR_setup) {
+    fp->soundingrs_ul_config_common.enabled_flag                        = 1;
+    fp->soundingrs_ul_config_common.srs_BandwidthConfig                 = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_BandwidthConfig;
+    fp->soundingrs_ul_config_common.srs_SubframeConfig                  = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_SubframeConfig;
+    fp->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission;
+
+    if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts)
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 1;
+    else
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 0;
+  }
+
+
+
+  fp->ul_power_control_config_common.p0_NominalPUSCH   = radioResourceConfigCommon->uplinkPowerControlCommon.p0_NominalPUSCH;
+  fp->ul_power_control_config_common.alpha             = radioResourceConfigCommon->uplinkPowerControlCommon.alpha;
+  fp->ul_power_control_config_common.p0_NominalPUCCH   = radioResourceConfigCommon->uplinkPowerControlCommon.p0_NominalPUCCH;
+  fp->ul_power_control_config_common.deltaPreambleMsg3 = radioResourceConfigCommon->uplinkPowerControlCommon.deltaPreambleMsg3;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format1  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format1b  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1b;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2a  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2a;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2b  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2b;
+
+  fp->maxHARQ_Msg3Tx = radioResourceConfigCommon->rach_ConfigCommon.maxHARQ_Msg3Tx;
+
+  // Now configure some of the Physical Channels
+
+  // PUCCH
+  init_ncs_cell(fp,ue->ncs_cell);
+
+  init_ul_hopping(fp);
+
+  // PCH
+  init_ue_paging_info(ue,radioResourceConfigCommon->pcch_Config.defaultPagingCycle,radioResourceConfigCommon->pcch_Config.nB);
+
+  // MBSFN
+
+  if (mbsfn_SubframeConfigList != NULL) {
+    fp->num_MBSFN_config = mbsfn_SubframeConfigList->list.count;
+
+    for (i=0; i<mbsfn_SubframeConfigList->list.count; i++) {
+      fp->MBSFN_config[i].radioframeAllocationPeriod = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationPeriod;
+      fp->MBSFN_config[i].radioframeAllocationOffset = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationOffset;
+
+      if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) {
+        fp->MBSFN_config[i].fourFrames_flag = 0;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig = mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]; // 6-bit subframe configuration
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      } else if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_fourFrames) { // 24-bit subframe configuration
+        fp->MBSFN_config[i].fourFrames_flag = 1;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig =
+          mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[1]<<8)|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[2]<<16);
+
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      }
+    }
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_UE_CONFIG_SIB2, VCD_FUNCTION_OUT);
+
+}
+
+void phy_config_sib13_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,int mbsfn_Area_idx,
+                         long mbsfn_AreaId_r9)
+{
+
+  LTE_DL_FRAME_PARMS *fp = &PHY_vars_UE_g[Mod_id][CC_id]->frame_parms;
+
+
+  LOG_I(PHY,"[UE%d] Applying MBSFN_Area_id %ld for index %d\n",Mod_id,mbsfn_AreaId_r9,mbsfn_Area_idx);
+
+  if (mbsfn_Area_idx == 0) {
+    fp->Nid_cell_mbsfn = (uint16_t)mbsfn_AreaId_r9;
+    LOG_N(PHY,"Fix me: only called when mbsfn_Area_idx == 0)\n");
+  }
+
+  lte_gold_mbsfn(fp,PHY_vars_UE_g[Mod_id][CC_id]->lte_gold_mbsfn_table,fp->Nid_cell_mbsfn);
+
+}
+
+
+void phy_config_sib13_eNB(uint8_t Mod_id,int CC_id,int mbsfn_Area_idx,
+                          long mbsfn_AreaId_r9)
+{
+
+  LTE_DL_FRAME_PARMS *fp = &PHY_vars_eNB_g[Mod_id][CC_id]->frame_parms;
+
+
+  LOG_I(PHY,"[eNB%d] Applying MBSFN_Area_id %ld for index %d\n",Mod_id,mbsfn_AreaId_r9,mbsfn_Area_idx);
+
+  if (mbsfn_Area_idx == 0) {
+    fp->Nid_cell_mbsfn = (uint16_t)mbsfn_AreaId_r9;
+    LOG_N(PHY,"Fix me: only called when mbsfn_Area_idx == 0)\n");
+  }
+
+  lte_gold_mbsfn(fp,PHY_vars_eNB_g[Mod_id][CC_id]->lte_gold_mbsfn_table,fp->Nid_cell_mbsfn);
+}
+
+
+void phy_config_dedicated_eNB_step2(PHY_VARS_eNB *eNB)
+{
+
+  uint8_t UE_id;
+  struct PhysicalConfigDedicated *physicalConfigDedicated;
+  LTE_DL_FRAME_PARMS *fp=&eNB->frame_parms;
+
+  for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+    physicalConfigDedicated = eNB->physicalConfigDedicated[UE_id];
+
+    if (physicalConfigDedicated != NULL) {
+      LOG_I(PHY,"[eNB %d] Sent physicalConfigDedicated=%p for UE %d\n",eNB->Mod_id,physicalConfigDedicated,UE_id);
+      LOG_D(PHY,"------------------------------------------------------------------------\n");
+
+      if (physicalConfigDedicated->pdsch_ConfigDedicated) {
+        eNB->pdsch_config_dedicated[UE_id].p_a=physicalConfigDedicated->pdsch_ConfigDedicated->p_a;
+        LOG_D(PHY,"pdsch_config_dedicated.p_a %d\n",eNB->pdsch_config_dedicated[UE_id].p_a);
+        LOG_D(PHY,"\n");
+      }
+
+      if (physicalConfigDedicated->pucch_ConfigDedicated) {
+        if (physicalConfigDedicated->pucch_ConfigDedicated->ackNackRepetition.present==PUCCH_ConfigDedicated__ackNackRepetition_PR_release)
+          eNB->pucch_config_dedicated[UE_id].ackNackRepetition=0;
+        else {
+          eNB->pucch_config_dedicated[UE_id].ackNackRepetition=1;
+        }
+
+        if (fp->frame_type == FDD) {
+          eNB->pucch_config_dedicated[UE_id].tdd_AckNackFeedbackMode = multiplexing;
+        } else {
+          if (physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode)
+            eNB->pucch_config_dedicated[UE_id].tdd_AckNackFeedbackMode = *physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode;
+          else
+            eNB->pucch_config_dedicated[UE_id].tdd_AckNackFeedbackMode = bundling;
+        }
+
+        if ( eNB->pucch_config_dedicated[UE_id].tdd_AckNackFeedbackMode == multiplexing)
+          LOG_D(PHY,"pucch_config_dedicated.tdd_AckNackFeedbackMode = multiplexing\n");
+        else
+          LOG_D(PHY,"pucch_config_dedicated.tdd_AckNackFeedbackMode = bundling\n");
+
+      }
+
+      if (physicalConfigDedicated->pusch_ConfigDedicated) {
+        eNB->pusch_config_dedicated[UE_id].betaOffset_ACK_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_ACK_Index;
+        eNB->pusch_config_dedicated[UE_id].betaOffset_RI_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_RI_Index;
+        eNB->pusch_config_dedicated[UE_id].betaOffset_CQI_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_CQI_Index;
+
+        LOG_D(PHY,"pusch_config_dedicated.betaOffset_ACK_Index %d\n",eNB->pusch_config_dedicated[UE_id].betaOffset_ACK_Index);
+        LOG_D(PHY,"pusch_config_dedicated.betaOffset_RI_Index %d\n",eNB->pusch_config_dedicated[UE_id].betaOffset_RI_Index);
+        LOG_D(PHY,"pusch_config_dedicated.betaOffset_CQI_Index %d\n",eNB->pusch_config_dedicated[UE_id].betaOffset_CQI_Index);
+        LOG_D(PHY,"\n");
+
+
+      }
+
+      if (physicalConfigDedicated->uplinkPowerControlDedicated) {
+
+        eNB->ul_power_control_dedicated[UE_id].p0_UE_PUSCH = physicalConfigDedicated->uplinkPowerControlDedicated->p0_UE_PUSCH;
+        eNB->ul_power_control_dedicated[UE_id].deltaMCS_Enabled= physicalConfigDedicated->uplinkPowerControlDedicated->deltaMCS_Enabled;
+        eNB->ul_power_control_dedicated[UE_id].accumulationEnabled= physicalConfigDedicated->uplinkPowerControlDedicated->accumulationEnabled;
+        eNB->ul_power_control_dedicated[UE_id].p0_UE_PUCCH= physicalConfigDedicated->uplinkPowerControlDedicated->p0_UE_PUCCH;
+        eNB->ul_power_control_dedicated[UE_id].pSRS_Offset= physicalConfigDedicated->uplinkPowerControlDedicated->pSRS_Offset;
+        eNB->ul_power_control_dedicated[UE_id].filterCoefficient= *physicalConfigDedicated->uplinkPowerControlDedicated->filterCoefficient;
+        LOG_D(PHY,"ul_power_control_dedicated.p0_UE_PUSCH %d\n",eNB->ul_power_control_dedicated[UE_id].p0_UE_PUSCH);
+        LOG_D(PHY,"ul_power_control_dedicated.deltaMCS_Enabled %d\n",eNB->ul_power_control_dedicated[UE_id].deltaMCS_Enabled);
+        LOG_D(PHY,"ul_power_control_dedicated.accumulationEnabled %d\n",eNB->ul_power_control_dedicated[UE_id].accumulationEnabled);
+        LOG_D(PHY,"ul_power_control_dedicated.p0_UE_PUCCH %d\n",eNB->ul_power_control_dedicated[UE_id].p0_UE_PUCCH);
+        LOG_D(PHY,"ul_power_control_dedicated.pSRS_Offset %d\n",eNB->ul_power_control_dedicated[UE_id].pSRS_Offset);
+        LOG_D(PHY,"ul_power_control_dedicated.filterCoefficient %d\n",eNB->ul_power_control_dedicated[UE_id].filterCoefficient);
+        LOG_D(PHY,"\n");
+      }
+
+      if (physicalConfigDedicated->antennaInfo) {
+        eNB->transmission_mode[UE_id] = 1+(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode);
+        LOG_D(PHY,"Transmission Mode (phy_config_dedicated_eNB_step2) %d\n",eNB->transmission_mode[UE_id]);
+        LOG_D(PHY,"\n");
+      }
+
+      if (physicalConfigDedicated->schedulingRequestConfig) {
+        if (physicalConfigDedicated->schedulingRequestConfig->present == SchedulingRequestConfig_PR_setup) {
+          eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex = physicalConfigDedicated->schedulingRequestConfig->choice.setup.sr_PUCCH_ResourceIndex;
+          eNB->scheduling_request_config[UE_id].sr_ConfigIndex=physicalConfigDedicated->schedulingRequestConfig->choice.setup.sr_ConfigIndex;
+          eNB->scheduling_request_config[UE_id].dsr_TransMax=physicalConfigDedicated->schedulingRequestConfig->choice.setup.dsr_TransMax;
+
+          LOG_D(PHY,"scheduling_request_config.sr_PUCCH_ResourceIndex %d\n",eNB->scheduling_request_config[UE_id].sr_PUCCH_ResourceIndex);
+          LOG_D(PHY,"scheduling_request_config.sr_ConfigIndex %d\n",eNB->scheduling_request_config[UE_id].sr_ConfigIndex);
+          LOG_D(PHY,"scheduling_request_config.dsr_TransMax %d\n",eNB->scheduling_request_config[UE_id].dsr_TransMax);
+        }
+
+        LOG_D(PHY,"------------------------------------------------------------\n");
+
+      }
+
+      if (physicalConfigDedicated->soundingRS_UL_ConfigDedicated) {
+        if (physicalConfigDedicated->soundingRS_UL_ConfigDedicated->present == SoundingRS_UL_ConfigDedicated_PR_setup) {
+	  
+	  eNB->soundingrs_ul_config_dedicated[UE_id].srsConfigDedicatedSetup = 1;
+          eNB->soundingrs_ul_config_dedicated[UE_id].duration             = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.duration;
+          eNB->soundingrs_ul_config_dedicated[UE_id].cyclicShift          = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.cyclicShift;
+          eNB->soundingrs_ul_config_dedicated[UE_id].freqDomainPosition   = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.freqDomainPosition;
+          eNB->soundingrs_ul_config_dedicated[UE_id].srs_Bandwidth        = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_Bandwidth;
+          eNB->soundingrs_ul_config_dedicated[UE_id].srs_ConfigIndex      = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_ConfigIndex;
+          eNB->soundingrs_ul_config_dedicated[UE_id].srs_HoppingBandwidth = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_HoppingBandwidth;
+          eNB->soundingrs_ul_config_dedicated[UE_id].transmissionComb     = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.transmissionComb;
+
+
+          LOG_D(PHY,"soundingrs_ul_config_dedicated.srs_ConfigIndex %d\n",eNB->soundingrs_ul_config_dedicated[UE_id].srs_ConfigIndex);
+
+        }
+
+        LOG_D(PHY,"------------------------------------------------------------\n");
+
+      }
+
+      eNB->physicalConfigDedicated[UE_id] = NULL;
+    }
+  }
+}
+
+/*
+ * Configures UE MAC and PHY with radioResourceCommon received in mobilityControlInfo IE during Handover
+ */
+void phy_config_afterHO_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_id, MobilityControlInfo_t *mobilityControlInfo, uint8_t ho_failed)
+{
+
+  if(mobilityControlInfo!=NULL) {
+    RadioResourceConfigCommon_t *radioResourceConfigCommon = &mobilityControlInfo->radioResourceConfigCommon;
+    LOG_I(PHY,"radioResourceConfigCommon %p\n", radioResourceConfigCommon);
+    memcpy((void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms_before_ho,
+           (void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms,
+           sizeof(LTE_DL_FRAME_PARMS));
+    PHY_vars_UE_g[Mod_id][CC_id]->ho_triggered = 1;
+    //PHY_vars_UE_g[UE_id]->UE_mode[0] = PRACH;
+
+    LTE_DL_FRAME_PARMS *fp = &PHY_vars_UE_g[Mod_id][CC_id]->frame_parms;
+    //     int N_ZC;
+    //     uint8_t prach_fmt;
+    //     int u;
+
+    LOG_I(PHY,"[UE%d] Handover triggered: Applying radioResourceConfigCommon from eNB %d\n",
+          Mod_id,eNB_id);
+
+    fp->prach_config_common.rootSequenceIndex                           =radioResourceConfigCommon->prach_Config.rootSequenceIndex;
+    fp->prach_config_common.prach_Config_enabled=1;
+    fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex          =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->prach_ConfigIndex;
+    fp->prach_config_common.prach_ConfigInfo.highSpeedFlag              =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->highSpeedFlag;
+    fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig  =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->zeroCorrelationZoneConfig;
+    fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset           =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->prach_FreqOffset;
+
+    //     prach_fmt = get_prach_fmt(radioResourceConfigCommon->prach_Config.prach_ConfigInfo->prach_ConfigIndex,fp->frame_type);
+    //     N_ZC = (prach_fmt <4)?839:139;
+    //     u = (prach_fmt < 4) ? prach_root_sequence_map0_3[fp->prach_config_common.rootSequenceIndex] :
+    //       prach_root_sequence_map4[fp->prach_config_common.rootSequenceIndex];
+
+    //compute_prach_seq(u,N_ZC, PHY_vars_UE_g[Mod_id]->X_u);
+    compute_prach_seq(&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms.prach_config_common,
+                      fp->frame_type,
+                      PHY_vars_UE_g[Mod_id][CC_id]->X_u);
+
+
+    fp->pucch_config_common.deltaPUCCH_Shift = 1+radioResourceConfigCommon->pucch_ConfigCommon->deltaPUCCH_Shift;
+    fp->pucch_config_common.nRB_CQI          = radioResourceConfigCommon->pucch_ConfigCommon->nRB_CQI;
+    fp->pucch_config_common.nCS_AN           = radioResourceConfigCommon->pucch_ConfigCommon->nCS_AN;
+    fp->pucch_config_common.n1PUCCH_AN       = radioResourceConfigCommon->pucch_ConfigCommon->n1PUCCH_AN;
+    fp->pdsch_config_common.referenceSignalPower = radioResourceConfigCommon->pdsch_ConfigCommon->referenceSignalPower;
+    fp->pdsch_config_common.p_b                  = radioResourceConfigCommon->pdsch_ConfigCommon->p_b;
+
+
+    fp->pusch_config_common.n_SB                                         = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.n_SB;
+    fp->pusch_config_common.hoppingMode                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode;
+    fp->pusch_config_common.pusch_HoppingOffset                          = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset;
+    fp->pusch_config_common.enable64QAM                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled    = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH   = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift            = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift;
+
+    init_ul_hopping(fp);
+    fp->soundingrs_ul_config_common.enabled_flag                        = 0;
+
+    if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon->present==SoundingRS_UL_ConfigCommon_PR_setup) {
+      fp->soundingrs_ul_config_common.enabled_flag                        = 1;
+      fp->soundingrs_ul_config_common.srs_BandwidthConfig                 = radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.srs_BandwidthConfig;
+      fp->soundingrs_ul_config_common.srs_SubframeConfig                  = radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.srs_SubframeConfig;
+      fp->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission = radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.ackNackSRS_SimultaneousTransmission;
+
+      if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.srs_MaxUpPts)
+        fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 1;
+      else
+        fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 0;
+    }
+
+    fp->ul_power_control_config_common.p0_NominalPUSCH   = radioResourceConfigCommon->uplinkPowerControlCommon->p0_NominalPUSCH;
+    fp->ul_power_control_config_common.alpha             = radioResourceConfigCommon->uplinkPowerControlCommon->alpha;
+    fp->ul_power_control_config_common.p0_NominalPUCCH   = radioResourceConfigCommon->uplinkPowerControlCommon->p0_NominalPUCCH;
+    fp->ul_power_control_config_common.deltaPreambleMsg3 = radioResourceConfigCommon->uplinkPowerControlCommon->deltaPreambleMsg3;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format1  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format1;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format1b  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format1b;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format2  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format2;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format2a  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format2a;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format2b  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format2b;
+
+    fp->maxHARQ_Msg3Tx = radioResourceConfigCommon->rach_ConfigCommon->maxHARQ_Msg3Tx;
+
+    // Now configure some of the Physical Channels
+    if (radioResourceConfigCommon->antennaInfoCommon)
+      fp->nb_antennas_tx                     = (1<<radioResourceConfigCommon->antennaInfoCommon->antennaPortsCount);
+    else
+      fp->nb_antennas_tx                     = 1;
+
+    //PHICH
+    if (radioResourceConfigCommon->antennaInfoCommon) {
+      fp->phich_config_common.phich_resource = radioResourceConfigCommon->phich_Config->phich_Resource;
+      fp->phich_config_common.phich_duration = radioResourceConfigCommon->phich_Config->phich_Duration;
+    }
+
+    //Target CellId
+    fp->Nid_cell = mobilityControlInfo->targetPhysCellId;
+    fp->nushift  = fp->Nid_cell%6;
+
+    // PUCCH
+    init_ncs_cell(fp,PHY_vars_UE_g[Mod_id][CC_id]->ncs_cell);
+
+    init_ul_hopping(fp);
+
+    // RNTI
+
+
+    PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_id]->crnti = mobilityControlInfo->newUE_Identity.buf[0]|(mobilityControlInfo->newUE_Identity.buf[1]<<8);
+    PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_id]->crnti = mobilityControlInfo->newUE_Identity.buf[0]|(mobilityControlInfo->newUE_Identity.buf[1]<<8);
+
+    LOG_I(PHY,"SET C-RNTI %x %x\n",PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_id]->crnti,
+                                   PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_id]->crnti);
+  }
+
+  if(ho_failed) {
+    LOG_D(PHY,"[UE%d] Handover failed, triggering RACH procedure\n",Mod_id);
+    memcpy((void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms,(void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms_before_ho, sizeof(LTE_DL_FRAME_PARMS));
+    PHY_vars_UE_g[Mod_id][CC_id]->UE_mode[eNB_id] = PRACH;
+  }
+}
+
+void phy_config_meas_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index,uint8_t n_adj_cells,unsigned int *adj_cell_id)
+{
+
+  PHY_MEASUREMENTS *phy_meas = &PHY_vars_UE_g[Mod_id][CC_id]->measurements;
+  int i;
+
+  LOG_I(PHY,"Configuring inter-cell measurements for %d cells, ids: \n",n_adj_cells);
+
+  for (i=0; i<n_adj_cells; i++) {
+    LOG_I(PHY,"%d\n",adj_cell_id[i]);
+    lte_gold(&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms,PHY_vars_UE_g[Mod_id][CC_id]->lte_gold_table[i+1],adj_cell_id[i]);
+  }
+
+  phy_meas->n_adj_cells = n_adj_cells;
+  memcpy((void*)phy_meas->adj_cell_id,(void *)adj_cell_id,n_adj_cells*sizeof(unsigned int));
+
+}
+
+void phy_config_dedicated_eNB(uint8_t Mod_id,
+                              int CC_id,
+                              uint16_t rnti,
+                              struct PhysicalConfigDedicated *physicalConfigDedicated)
+{
+
+  PHY_VARS_eNB *eNB = PHY_vars_eNB_g[Mod_id][CC_id];
+  int8_t UE_id = find_ue(rnti,eNB);
+
+  if (UE_id == -1) {
+    LOG_E( PHY, "[eNB %"PRIu8"] find_ue() returns -1\n", Mod_id);
+    return;
+  }
+
+
+  if (physicalConfigDedicated) {
+    eNB->physicalConfigDedicated[UE_id] = physicalConfigDedicated;
+    LOG_I(PHY,"phy_config_dedicated_eNB: physicalConfigDedicated=%p\n",physicalConfigDedicated);
+
+    if (physicalConfigDedicated->antennaInfo) {
+      switch(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode) {
+      case AntennaInfoDedicated__transmissionMode_tm1:
+        eNB->transmission_mode[UE_id] = 1;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm2:
+        eNB->transmission_mode[UE_id] = 2;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm3:
+        eNB->transmission_mode[UE_id] = 3;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm4:
+        eNB->transmission_mode[UE_id] = 4;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm5:
+        eNB->transmission_mode[UE_id] = 5;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm6:
+        eNB->transmission_mode[UE_id] = 6;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm7:
+        lte_gold_ue_spec_port5(eNB->lte_gold_uespec_port5_table[0],eNB->frame_parms.Nid_cell,rnti);
+        eNB->do_precoding = 1;
+        eNB->transmission_mode[UE_id] = 7;
+        break;
+      default:
+        LOG_E(PHY,"Unknown transmission mode!\n");
+        break;
+      }
+      LOG_I(PHY,"Transmission Mode (phy_config_dedicated_eNB) %d\n",eNB->transmission_mode[UE_id]);
+
+    } else {
+      LOG_D(PHY,"[eNB %d] : Received NULL radioResourceConfigDedicated->antennaInfo from eNB %d\n",Mod_id,UE_id);
+    }
+  } else {
+    LOG_E(PHY,"[eNB %d] Received NULL radioResourceConfigDedicated from eNB %d\n",Mod_id, UE_id);
+    return;
+  }
+
+}
+#if defined(Rel10) || defined(Rel14)
+void phy_config_dedicated_scell_ue(uint8_t Mod_id,
+                                   uint8_t eNB_index,
+                                   SCellToAddMod_r10_t *sCellToAddMod_r10,
+                                   int CC_id)
+{
+
+}
+void phy_config_dedicated_scell_eNB(uint8_t Mod_id,
+                                    uint16_t rnti,
+                                    SCellToAddMod_r10_t *sCellToAddMod_r10,
+                                    int CC_id)
+{
+
+
+  uint8_t UE_id = find_ue(rnti,PHY_vars_eNB_g[Mod_id][0]);
+  struct PhysicalConfigDedicatedSCell_r10 *physicalConfigDedicatedSCell_r10 = sCellToAddMod_r10->radioResourceConfigDedicatedSCell_r10->physicalConfigDedicatedSCell_r10;
+  //struct RadioResourceConfigCommonSCell_r10 *physicalConfigCommonSCell_r10 = sCellToAddMod_r10->radioResourceConfigCommonSCell_r10;
+  //PhysCellId_t physCellId_r10 = sCellToAddMod_r10->cellIdentification_r10->physCellId_r10;
+  ARFCN_ValueEUTRA_t dl_CarrierFreq_r10 = sCellToAddMod_r10->cellIdentification_r10->dl_CarrierFreq_r10;
+  uint32_t carrier_freq_local;
+
+  if ((dl_CarrierFreq_r10>=36000) && (dl_CarrierFreq_r10<=36199)) {
+    carrier_freq_local = 1900000000 + (dl_CarrierFreq_r10-36000)*100000; //band 33 from 3GPP 36.101 v 10.9 Table 5.7.3-1
+    LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,/*eNB->frame*/0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id);
+  } else if ((dl_CarrierFreq_r10>=6150) && (dl_CarrierFreq_r10<=6449)) {
+    carrier_freq_local = 832000000 + (dl_CarrierFreq_r10-6150)*100000; //band 20 from 3GPP 36.101 v 10.9 Table 5.7.3-1
+    // this is actually for the UL only, but we use it for DL too, since there is no TDD mode for this band
+    LOG_I(PHY,"[eNB %d] Frame %d: Configured SCell %d to frequency %d (ARFCN %ld) for UE %d\n",Mod_id,/*eNB->frame*/0,CC_id,carrier_freq_local,dl_CarrierFreq_r10,UE_id);
+  } else {
+    LOG_E(PHY,"[eNB %d] Frame %d: ARFCN %ld of SCell %d for UE %d not supported\n",Mod_id,/*eNB->frame*/0,dl_CarrierFreq_r10,CC_id,UE_id);
+  }
+
+  if (physicalConfigDedicatedSCell_r10) {
+//#warning " eNB->physicalConfigDedicatedSCell_r10 does not exist in eNB"
+    //  eNB->physicalConfigDedicatedSCell_r10[UE_id] = physicalConfigDedicatedSCell_r10;
+    LOG_I(PHY,"[eNB %d] Frame %d: Configured phyConfigDedicatedSCell with CC_id %d for UE %d\n",Mod_id,/*eNB->frame*/0,CC_id,UE_id);
+  } else {
+    LOG_E(PHY,"[eNB %d] Frame %d: Received NULL radioResourceConfigDedicated (CC_id %d, UE %d)\n",Mod_id, /*eNB->frame*/0,CC_id,UE_id);
+    return;
+  }
+
+}
+#endif
+
+void phy_config_harq_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
+                        uint16_t max_harq_tx )
+{
+
+  PHY_VARS_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
+  phy_vars_ue->ulsch[eNB_id]->Mlimit = max_harq_tx;
+}
+
+void phy_config_dedicated_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
+                             struct PhysicalConfigDedicated *physicalConfigDedicated )
+{
+
+  PHY_VARS_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
+
+  phy_vars_ue->total_TBS[eNB_id]=0;
+  phy_vars_ue->total_TBS_last[eNB_id]=0;
+  phy_vars_ue->bitrate[eNB_id]=0;
+  phy_vars_ue->total_received_bits[eNB_id]=0;
+  phy_vars_ue->dlsch_errors[eNB_id]=0;
+  phy_vars_ue->dlsch_errors_last[eNB_id]=0;
+  phy_vars_ue->dlsch_received[eNB_id]=0;
+  phy_vars_ue->dlsch_received_last[eNB_id]=0;
+  phy_vars_ue->dlsch_fer[eNB_id]=0;
+
+  phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex = -1;
+  phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex = -1;
+
+  if (physicalConfigDedicated) {
+    LOG_D(PHY,"[UE %d] Received physicalConfigDedicated from eNB %d\n",Mod_id, eNB_id);
+    LOG_D(PHY,"------------------------------------------------------------------------\n");
+
+    if (physicalConfigDedicated->pdsch_ConfigDedicated) {
+      phy_vars_ue->pdsch_config_dedicated[eNB_id].p_a=physicalConfigDedicated->pdsch_ConfigDedicated->p_a;
+      LOG_D(PHY,"pdsch_config_dedicated.p_a %d\n",phy_vars_ue->pdsch_config_dedicated[eNB_id].p_a);
+      LOG_D(PHY,"\n");
+    }
+
+    if (physicalConfigDedicated->pucch_ConfigDedicated) {
+      if (physicalConfigDedicated->pucch_ConfigDedicated->ackNackRepetition.present==PUCCH_ConfigDedicated__ackNackRepetition_PR_release)
+        phy_vars_ue->pucch_config_dedicated[eNB_id].ackNackRepetition=0;
+      else {
+        phy_vars_ue->pucch_config_dedicated[eNB_id].ackNackRepetition=1;
+      }
+
+      if (physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode)
+        phy_vars_ue->pucch_config_dedicated[eNB_id].tdd_AckNackFeedbackMode = *physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode;
+      else
+        phy_vars_ue->pucch_config_dedicated[eNB_id].tdd_AckNackFeedbackMode = bundling;
+
+      if ( phy_vars_ue->pucch_config_dedicated[eNB_id].tdd_AckNackFeedbackMode == multiplexing)
+        LOG_D(PHY,"pucch_config_dedicated.tdd_AckNackFeedbackMode = multiplexing\n");
+      else
+        LOG_D(PHY,"pucch_config_dedicated.tdd_AckNackFeedbackMode = bundling\n");
+    }
+
+    if (physicalConfigDedicated->pusch_ConfigDedicated) {
+      phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_ACK_Index;
+      phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_RI_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_RI_Index;
+      phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_CQI_Index;
+
+
+      LOG_D(PHY,"pusch_config_dedicated.betaOffset_ACK_Index %d\n",phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index);
+      LOG_D(PHY,"pusch_config_dedicated.betaOffset_RI_Index %d\n",phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_RI_Index);
+      LOG_D(PHY,"pusch_config_dedicated.betaOffset_CQI_Index %d\n",phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index);
+      LOG_D(PHY,"\n");
+
+
+    }
+
+    if (physicalConfigDedicated->uplinkPowerControlDedicated) {
+
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUSCH = physicalConfigDedicated->uplinkPowerControlDedicated->p0_UE_PUSCH;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].deltaMCS_Enabled= physicalConfigDedicated->uplinkPowerControlDedicated->deltaMCS_Enabled;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].accumulationEnabled= physicalConfigDedicated->uplinkPowerControlDedicated->accumulationEnabled;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUCCH= physicalConfigDedicated->uplinkPowerControlDedicated->p0_UE_PUCCH;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].pSRS_Offset= physicalConfigDedicated->uplinkPowerControlDedicated->pSRS_Offset;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].filterCoefficient= *physicalConfigDedicated->uplinkPowerControlDedicated->filterCoefficient;
+      LOG_D(PHY,"ul_power_control_dedicated.p0_UE_PUSCH %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUSCH);
+      LOG_D(PHY,"ul_power_control_dedicated.deltaMCS_Enabled %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].deltaMCS_Enabled);
+      LOG_D(PHY,"ul_power_control_dedicated.accumulationEnabled %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].accumulationEnabled);
+      LOG_D(PHY,"ul_power_control_dedicated.p0_UE_PUCCH %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUCCH);
+      LOG_D(PHY,"ul_power_control_dedicated.pSRS_Offset %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].pSRS_Offset);
+      LOG_D(PHY,"ul_power_control_dedicated.filterCoefficient %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].filterCoefficient);
+      LOG_D(PHY,"\n");
+    }
+
+    if (physicalConfigDedicated->antennaInfo) {
+      phy_vars_ue->transmission_mode[eNB_id] = 1+(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode);
+      LOG_I(PHY,"Transmission Mode %d\n",phy_vars_ue->transmission_mode[eNB_id]);
+      switch(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode) {
+      case AntennaInfoDedicated__transmissionMode_tm1:
+        phy_vars_ue->transmission_mode[eNB_id] = 1;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm2:
+        phy_vars_ue->transmission_mode[eNB_id] = 2;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm3:
+        phy_vars_ue->transmission_mode[eNB_id] = 3;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm4:
+        phy_vars_ue->transmission_mode[eNB_id] = 4;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm5:
+        phy_vars_ue->transmission_mode[eNB_id] = 5;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm6:
+        phy_vars_ue->transmission_mode[eNB_id] = 6;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm7:
+        lte_gold_ue_spec_port5(phy_vars_ue->lte_gold_uespec_port5_table, phy_vars_ue->frame_parms.Nid_cell, phy_vars_ue->pdcch_vars[0][eNB_id]->crnti);
+        phy_vars_ue->transmission_mode[eNB_id] = 7;
+        break;
+      default:
+        LOG_E(PHY,"Unknown transmission mode!\n");
+        break;
+      }
+    } else {
+      LOG_D(PHY,"[UE %d] Received NULL physicalConfigDedicated->antennaInfo from eNB %d\n",Mod_id, eNB_id);
+    }
+
+    if (physicalConfigDedicated->schedulingRequestConfig) {
+      if (physicalConfigDedicated->schedulingRequestConfig->present == SchedulingRequestConfig_PR_setup) {
+        phy_vars_ue->scheduling_request_config[eNB_id].sr_PUCCH_ResourceIndex = physicalConfigDedicated->schedulingRequestConfig->choice.setup.sr_PUCCH_ResourceIndex;
+        phy_vars_ue->scheduling_request_config[eNB_id].sr_ConfigIndex=physicalConfigDedicated->schedulingRequestConfig->choice.setup.sr_ConfigIndex;
+        phy_vars_ue->scheduling_request_config[eNB_id].dsr_TransMax=physicalConfigDedicated->schedulingRequestConfig->choice.setup.dsr_TransMax;
+
+        LOG_D(PHY,"scheduling_request_config.sr_PUCCH_ResourceIndex %d\n",phy_vars_ue->scheduling_request_config[eNB_id].sr_PUCCH_ResourceIndex);
+        LOG_D(PHY,"scheduling_request_config.sr_ConfigIndex %d\n",phy_vars_ue->scheduling_request_config[eNB_id].sr_ConfigIndex);
+        LOG_D(PHY,"scheduling_request_config.dsr_TransMax %d\n",phy_vars_ue->scheduling_request_config[eNB_id].dsr_TransMax);
+      }
+
+      LOG_D(PHY,"------------------------------------------------------------\n");
+
+    }
+
+    if (physicalConfigDedicated->soundingRS_UL_ConfigDedicated) {
+
+      phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srsConfigDedicatedSetup = 0;
+      if (physicalConfigDedicated->soundingRS_UL_ConfigDedicated->present == SoundingRS_UL_ConfigDedicated_PR_setup) {
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srsConfigDedicatedSetup = 1;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].duration             = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.duration;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].cyclicShift          = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.cyclicShift;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].freqDomainPosition   = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.freqDomainPosition;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_Bandwidth        = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_Bandwidth;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_ConfigIndex      = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_ConfigIndex;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_HoppingBandwidth = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_HoppingBandwidth;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].transmissionComb     = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.transmissionComb;
+
+
+        LOG_D(PHY,"soundingrs_ul_config_dedicated.srs_ConfigIndex %d\n",phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_ConfigIndex);
+      }
+
+      LOG_D(PHY,"------------------------------------------------------------\n");
+
+    }
+
+
+    if (physicalConfigDedicated->cqi_ReportConfig) {
+      if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportModeAperiodic) {
+        // configure PUSCH CQI reporting
+        phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic = *physicalConfigDedicated->cqi_ReportConfig->cqi_ReportModeAperiodic;
+        if ((phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic != rm12) &&
+            (phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic != rm30) &&
+            (phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic != rm31))
+          LOG_E(PHY,"Unsupported Aperiodic CQI Feedback Mode : %d\n",phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic);
+      }
+      if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic) {
+        if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->present == CQI_ReportPeriodic_PR_setup) {
+        // configure PUCCH CQI reporting
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PUCCH_ResourceIndex = physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.cqi_PUCCH_ResourceIndex;
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex     = physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.cqi_pmi_ConfigIndex;
+          if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.ri_ConfigIndex)
+            phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex = *physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.ri_ConfigIndex;
+        }
+        else if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->present == CQI_ReportPeriodic_PR_release) {
+          // handle release
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex = -1;
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex = -1;
+        }
+      }
+    }
+
+#ifdef CBA
+
+    if (physicalConfigDedicated->pusch_CBAConfigDedicated_vlola) {
+      phy_vars_ue->pusch_ca_config_dedicated[eNB_id].betaOffset_CA_Index = (uint16_t) *physicalConfigDedicated->pusch_CBAConfigDedicated_vlola->betaOffset_CBA_Index;
+      phy_vars_ue->pusch_ca_config_dedicated[eNB_id].cShift = (uint16_t) *physicalConfigDedicated->pusch_CBAConfigDedicated_vlola->cShift_CBA;
+      LOG_D(PHY,"[UE %d ] physicalConfigDedicated pusch CBA config dedicated: beta offset %d cshift %d \n",Mod_id,
+            phy_vars_ue->pusch_ca_config_dedicated[eNB_id].betaOffset_CA_Index,
+            phy_vars_ue->pusch_ca_config_dedicated[eNB_id].cShift);
+    }
+
+#endif
+  } else {
+    LOG_D(PHY,"[PHY][UE %d] Received NULL radioResourceConfigDedicated from eNB %d\n",Mod_id,eNB_id);
+    return;
+  }
+
+  // fill cqi parameters for periodic CQI reporting
+  get_cqipmiri_params(phy_vars_ue,eNB_id);
+
+  // disable MIB SIB decoding once we are on connected mode
+  LOG_I(PHY,"Disabling SIB MIB decoding \n");
+  phy_vars_ue->decode_SIB = 0;
+  phy_vars_ue->decode_MIB = 0;
+  //phy_vars_ue->pdcch_vars[1][eNB_id]->crnti = phy_vars_ue->pdcch_vars[0][eNB_id]->crnti;
+  if(phy_vars_ue->pdcch_vars[0][eNB_id]->crnti == 0x1234)
+      phy_vars_ue->pdcch_vars[0][eNB_id]->crnti = phy_vars_ue->pdcch_vars[1][eNB_id]->crnti;
+  else
+      phy_vars_ue->pdcch_vars[1][eNB_id]->crnti = phy_vars_ue->pdcch_vars[0][eNB_id]->crnti;
+
+  LOG_I(PHY,"C-RNTI %x %x \n", phy_vars_ue->pdcch_vars[0][eNB_id]->crnti,
+                               phy_vars_ue->pdcch_vars[1][eNB_id]->crnti);
+
+}
+
+void  phy_config_cba_rnti (module_id_t Mod_id,int CC_id,eNB_flag_t eNB_flag, uint8_t index, rnti_t cba_rnti, uint8_t cba_group_id, uint8_t num_active_cba_groups)
+{
+  //   uint8_t i;
+
+  if (eNB_flag == 0 ) {
+    //LOG_D(PHY,"[UE %d] configure cba group %d with rnti %x, num active cba grp %d\n", index, index, cba_rnti, num_active_cba_groups);
+    PHY_vars_UE_g[Mod_id][CC_id]->ulsch[index]->num_active_cba_groups=num_active_cba_groups;
+    PHY_vars_UE_g[Mod_id][CC_id]->ulsch[index]->cba_rnti[cba_group_id]=cba_rnti;
+  } else {
+    //for (i=index; i < NUMBER_OF_UE_MAX; i+=num_active_cba_groups){
+    //  LOG_D(PHY,"[eNB %d] configure cba group %d with rnti %x for UE %d, num active cba grp %d\n",Mod_id, i%num_active_cba_groups, cba_rnti, i, num_active_cba_groups);
+    PHY_vars_eNB_g[Mod_id][CC_id]->ulsch[index]->num_active_cba_groups=num_active_cba_groups;
+    PHY_vars_eNB_g[Mod_id][CC_id]->ulsch[index]->cba_rnti[cba_group_id] = cba_rnti;
+    //}
+  }
+}
+
+void phy_init_lte_top(LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+  crcTableInit();
+
+  ccodedot11_init();
+  ccodedot11_init_inv();
+
+  ccodelte_init();
+  ccodelte_init_inv();
+
+  treillis_table_init();
+
+  phy_generate_viterbi_tables();
+  phy_generate_viterbi_tables_lte();
+
+  init_td8();
+  init_td16();
+#ifdef __AVX2__
+  init_td16avx2();
+#endif
+
+  lte_sync_time_init(frame_parms);
+
+  generate_ul_ref_sigs();
+  generate_ul_ref_sigs_rx();
+
+  generate_64qam_table();
+  generate_16qam_table();
+  generate_RIV_tables();
+
+  init_unscrambling_lut();
+  init_scrambling_lut();
+  //set_taus_seed(1328);
+
+}
+
+/*! \brief Helper function to allocate memory for DLSCH data structures.
+ * \param[out] pdsch Pointer to the LTE_UE_PDSCH structure to initialize.
+ * \param[in] frame_parms LTE_DL_FRAME_PARMS structure.
+ * \note This function is optimistic in that it expects malloc() to succeed.
+ */
+void phy_init_lte_ue__PDSCH( LTE_UE_PDSCH* const pdsch, const LTE_DL_FRAME_PARMS* const fp )
+{
+  AssertFatal( pdsch, "pdsch==0" );
+
+  pdsch->pmi_ext = (uint8_t*)malloc16_clear( fp->N_RB_DL );
+  pdsch->llr[0] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+  pdsch->llr128 = (int16_t**)malloc16_clear( sizeof(int16_t*) );
+  // FIXME! no further allocation for (int16_t*)pdsch->llr128 !!! expect SIGSEGV
+  // FK, 11-3-2015: this is only as a temporary pointer, no memory is stored there
+
+
+  pdsch->rxdataF_ext            = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->rxdataF_uespec_pilots  = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->rxdataF_comp0          = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->rho                    = (int32_t**)malloc16_clear( fp->nb_antennas_rx*sizeof(int32_t*) );
+  pdsch->dl_ch_estimates_ext    = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_bf_ch_estimates     = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_bf_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  //pdsch->dl_ch_rho_ext          = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  //pdsch->dl_ch_rho2_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_ch_mag0             = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_ch_magb0            = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+
+
+  // the allocated memory size is fixed:
+  AssertFatal( fp->nb_antennas_rx <= 2, "nb_antennas_rx > 2" );
+
+  for (int i=0; i<fp->nb_antennas_rx; i++) {
+    pdsch->rho[i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*7*2) );
+
+    for (int j=0; j<4; j++) { //fp->nb_antennas_tx; j++)
+      const int idx = (j<<1)+i;
+      const size_t num = 7*2*fp->N_RB_DL*12;
+      pdsch->rxdataF_ext[idx]             = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->rxdataF_uespec_pilots[idx]   = (int32_t*)malloc16_clear( sizeof(int32_t) * fp->N_RB_DL*12);
+      pdsch->rxdataF_comp0[idx]           = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_estimates_ext[idx]     = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_bf_ch_estimates[idx]      = (int32_t*)malloc16_clear( sizeof(int32_t) * fp->ofdm_symbol_size*7*2);
+      pdsch->dl_bf_ch_estimates_ext[idx]  = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      //pdsch->dl_ch_rho_ext[idx]           = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      //pdsch->dl_ch_rho2_ext[idx]          = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_mag0[idx]              = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_magb0[idx]             = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+    }
+  }
+}
+
+int phy_init_lte_ue(PHY_VARS_UE *ue,
+                    int nb_connected_eNB,
+                    uint8_t abstraction_flag)
+{
+
+  // create shortcuts
+  LTE_DL_FRAME_PARMS* const fp            = &ue->frame_parms;
+  LTE_UE_COMMON* const common_vars        = &ue->common_vars;
+  LTE_UE_PDSCH** const pdsch_vars_th0     = ue->pdsch_vars[0];
+  LTE_UE_PDSCH** const pdsch_vars_th1     = ue->pdsch_vars[1];
+  LTE_UE_PDSCH** const pdsch_vars_SI      = ue->pdsch_vars_SI;
+  LTE_UE_PDSCH** const pdsch_vars_ra      = ue->pdsch_vars_ra;
+  LTE_UE_PDSCH** const pdsch_vars_mch     = ue->pdsch_vars_MCH;
+  LTE_UE_PBCH** const pbch_vars           = ue->pbch_vars;
+  LTE_UE_PDCCH** const pdcch_vars_th0     = ue->pdcch_vars[0];
+  LTE_UE_PDCCH** const pdcch_vars_th1     = ue->pdcch_vars[1];
+  LTE_UE_PRACH** const prach_vars         = ue->prach_vars;
+
+  int i,j,k,l;
+  int eNB_id;
+
+  printf("Initializing UE vars (abstraction %"PRIu8") for eNB TXant %"PRIu8", UE RXant %"PRIu8"\n",abstraction_flag,fp->nb_antennas_tx,fp->nb_antennas_rx);
+  LOG_D(PHY,"[MSC_NEW][FRAME 00000][PHY_UE][MOD %02u][]\n", ue->Mod_id+NB_eNB_INST);
+
+  // many memory allocation sizes are hard coded
+  AssertFatal( fp->nb_antennas_rx <= 2, "hard coded allocation for ue_common_vars->dl_ch_estimates[eNB_id]" );
+  AssertFatal( ue->n_connected_eNB <= NUMBER_OF_CONNECTED_eNB_MAX, "n_connected_eNB is too large" );
+  // init phy_vars_ue
+
+  for (i=0; i<4; i++) {
+    ue->rx_gain_max[i] = 135;
+    ue->rx_gain_med[i] = 128;
+    ue->rx_gain_byp[i] = 120;
+  }
+
+  ue->n_connected_eNB = nb_connected_eNB;
+
+  for(eNB_id = 0; eNB_id < ue->n_connected_eNB; eNB_id++) {
+    ue->total_TBS[eNB_id] = 0;
+    ue->total_TBS_last[eNB_id] = 0;
+    ue->bitrate[eNB_id] = 0;
+    ue->total_received_bits[eNB_id] = 0;
+  }
+
+  for (i=0;i<10;i++)
+    ue->tx_power_dBm[i]=-127;
+
+  if (abstraction_flag == 0) {
+
+    // init TX buffers
+
+    common_vars->txdata  = (int32_t**)malloc16( fp->nb_antennas_tx*sizeof(int32_t*) );
+    common_vars->txdataF = (int32_t **)malloc16( fp->nb_antennas_tx*sizeof(int32_t*) );
+
+    for (i=0; i<fp->nb_antennas_tx; i++) {
+
+      common_vars->txdata[i]  = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) );
+      common_vars->txdataF[i] = (int32_t *)malloc16_clear( fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t) );
+    }
+
+    // init RX buffers
+
+    common_vars->rxdata   = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+    common_vars->common_vars_rx_data_per_thread[0].rxdataF  = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+    common_vars->common_vars_rx_data_per_thread[1].rxdataF  = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+
+    for (i=0; i<fp->nb_antennas_rx; i++) {
+      common_vars->rxdata[i] = (int32_t*) malloc16_clear( (fp->samples_per_tti*10+2048)*sizeof(int32_t) );
+      common_vars->common_vars_rx_data_per_thread[0].rxdataF[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*14) );
+      common_vars->common_vars_rx_data_per_thread[1].rxdataF[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*14) );
+    }
+  }
+
+  // Channel estimates
+  for (eNB_id=0; eNB_id<7; eNB_id++) {
+    common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id]      = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+    common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates[eNB_id]      = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+    common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates_time[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+    common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates_time[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+
+    for (i=0; i<fp->nb_antennas_rx; i++)
+      for (j=0; j<4; j++) {
+        int idx = (j<<1) + i;
+        common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_tti*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) );
+        common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_tti*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) );
+        common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates_time[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
+        common_vars->common_vars_rx_data_per_thread[1].dl_ch_estimates_time[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
+      }
+  }
+
+  // DLSCH
+  for (eNB_id=0; eNB_id<ue->n_connected_eNB; eNB_id++) {
+    pdsch_vars_th0[eNB_id]     = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdsch_vars_th1[eNB_id]     = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdsch_vars_SI[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdsch_vars_ra[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdsch_vars_mch[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdcch_vars_th0[eNB_id] = (LTE_UE_PDCCH *)malloc16_clear(sizeof(LTE_UE_PDCCH));
+    pdcch_vars_th1[eNB_id] = (LTE_UE_PDCCH *)malloc16_clear(sizeof(LTE_UE_PDCCH));
+    prach_vars[eNB_id]     = (LTE_UE_PRACH *)malloc16_clear(sizeof(LTE_UE_PRACH));
+    pbch_vars[eNB_id]      = (LTE_UE_PBCH *)malloc16_clear(sizeof(LTE_UE_PBCH));
+
+    if (abstraction_flag == 0) {
+      phy_init_lte_ue__PDSCH( pdsch_vars_th0[eNB_id], fp );
+      phy_init_lte_ue__PDSCH( pdsch_vars_th1[eNB_id], fp );
+
+      // thread 0
+      pdsch_vars_th0[eNB_id]->llr_shifts      = (uint8_t*)malloc16_clear(7*2*fp->N_RB_DL*12);
+      pdsch_vars_th0[eNB_id]->llr_shifts_p        = pdsch_vars_th0[eNB_id]->llr_shifts;
+      pdsch_vars_th0[eNB_id]->llr[1]              = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+      pdsch_vars_th0[eNB_id]->llr128_2ndstream    = (int16_t**)malloc16_clear( sizeof(int16_t*) );
+      pdsch_vars_th0[eNB_id]->rho                 = (int32_t**)malloc16_clear( fp->nb_antennas_rx*sizeof(int32_t*) );
+
+       // thread 0
+      pdsch_vars_th1[eNB_id]->llr_shifts      = (uint8_t*)malloc16_clear(7*2*fp->N_RB_DL*12);
+      pdsch_vars_th1[eNB_id]->llr_shifts_p        = pdsch_vars_th0[eNB_id]->llr_shifts;
+      pdsch_vars_th1[eNB_id]->llr[1]              = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+      pdsch_vars_th1[eNB_id]->llr128_2ndstream    = (int16_t**)malloc16_clear( sizeof(int16_t*) );
+      pdsch_vars_th1[eNB_id]->rho                 = (int32_t**)malloc16_clear( fp->nb_antennas_rx*sizeof(int32_t*) );
+
+
+
+
+      for (int i=0; i<fp->nb_antennas_rx; i++){
+        pdsch_vars_th0[eNB_id]->rho[i]     = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+        pdsch_vars_th1[eNB_id]->rho[i]     = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+        }
+
+      pdsch_vars_th0[eNB_id]->dl_ch_rho2_ext      = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pdsch_vars_th1[eNB_id]->dl_ch_rho2_ext      = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+
+      for (i=0; i<fp->nb_antennas_rx; i++)
+        for (j=0; j<4; j++) {
+          const int idx = (j<<1)+i;
+          const size_t num = 7*2*fp->N_RB_DL*12+4;
+          pdsch_vars_th0[eNB_id]->dl_ch_rho2_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+          pdsch_vars_th1[eNB_id]->dl_ch_rho2_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+        }
+
+
+      //const size_t num = 7*2*fp->N_RB_DL*12+4;
+      for (k=0;k<8;k++) { //harq_pid
+        for (l=0;l<8;l++) { //round
+          pdsch_vars_th0[eNB_id]->rxdataF_comp1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+          pdsch_vars_th0[eNB_id]->dl_ch_rho_ext[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+          pdsch_vars_th0[eNB_id]->dl_ch_mag1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+          pdsch_vars_th0[eNB_id]->dl_ch_magb1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+
+          pdsch_vars_th1[eNB_id]->rxdataF_comp1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+          pdsch_vars_th1[eNB_id]->dl_ch_rho_ext[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+          pdsch_vars_th1[eNB_id]->dl_ch_mag1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+          pdsch_vars_th1[eNB_id]->dl_ch_magb1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+
+
+          for (int i=0; i<fp->nb_antennas_rx; i++)
+            for (int j=0; j<4; j++) { //frame_parms->nb_antennas_tx; j++)
+              const int idx = (j<<1)+i;
+              pdsch_vars_th0[eNB_id]->dl_ch_rho_ext[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+              pdsch_vars_th0[eNB_id]->rxdataF_comp1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+              pdsch_vars_th0[eNB_id]->dl_ch_mag1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+              pdsch_vars_th0[eNB_id]->dl_ch_magb1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+
+              pdsch_vars_th1[eNB_id]->dl_ch_rho_ext[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+              pdsch_vars_th1[eNB_id]->rxdataF_comp1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+              pdsch_vars_th1[eNB_id]->dl_ch_mag1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+              pdsch_vars_th1[eNB_id]->dl_ch_magb1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+                }
+        }
+      }
+      phy_init_lte_ue__PDSCH( pdsch_vars_SI[eNB_id], fp );
+      phy_init_lte_ue__PDSCH( pdsch_vars_ra[eNB_id], fp );
+      phy_init_lte_ue__PDSCH( pdsch_vars_mch[eNB_id], fp );
+
+      // 100 PRBs * 12 REs/PRB * 4 PDCCH SYMBOLS * 2 LLRs/RE
+      pdcch_vars_th0[eNB_id]->llr   = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      pdcch_vars_th0[eNB_id]->llr16 = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      pdcch_vars_th0[eNB_id]->wbar  = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      pdcch_vars_th0[eNB_id]->e_rx  = (int8_t*)malloc16_clear( 4*2*100*12 );
+
+      pdcch_vars_th0[eNB_id]->rxdataF_comp        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pdcch_vars_th0[eNB_id]->dl_ch_rho_ext       = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pdcch_vars_th0[eNB_id]->rho                 = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+      pdcch_vars_th0[eNB_id]->rxdataF_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pdcch_vars_th0[eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+
+      pdcch_vars_th1[eNB_id]->llr   = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      pdcch_vars_th1[eNB_id]->llr16 = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      pdcch_vars_th1[eNB_id]->wbar  = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      pdcch_vars_th1[eNB_id]->e_rx  = (int8_t*)malloc16_clear( 4*2*100*12 );
+
+      pdcch_vars_th1[eNB_id]->rxdataF_comp        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pdcch_vars_th1[eNB_id]->dl_ch_rho_ext       = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pdcch_vars_th1[eNB_id]->rho                 = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+      pdcch_vars_th1[eNB_id]->rxdataF_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pdcch_vars_th1[eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+
+      for (i=0; i<fp->nb_antennas_rx; i++) {
+        //ue_pdcch_vars[eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*7*2) );
+        pdcch_vars_th0[eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(100*12*4) );
+        pdcch_vars_th1[eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(100*12*4) );
+
+        for (j=0; j<4; j++) { //fp->nb_antennas_tx; j++)
+          int idx = (j<<1)+i;
+          //  size_t num = 7*2*fp->N_RB_DL*12;
+          size_t num = 4*100*12;  // 4 symbols, 100 PRBs, 12 REs per PRB
+          pdcch_vars_th0[eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+          pdcch_vars_th0[eNB_id]->dl_ch_rho_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+          pdcch_vars_th0[eNB_id]->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+          pdcch_vars_th0[eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+
+          pdcch_vars_th1[eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+          pdcch_vars_th1[eNB_id]->dl_ch_rho_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+          pdcch_vars_th1[eNB_id]->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+          pdcch_vars_th1[eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+        }
+      }
+
+      // PBCH
+      pbch_vars[eNB_id]->rxdataF_ext         = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+      pbch_vars[eNB_id]->rxdataF_comp        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pbch_vars[eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      pbch_vars[eNB_id]->llr                 = (int8_t*)malloc16_clear( 1920 );
+      prach_vars[eNB_id]->prachF             = (int16_t*)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
+      prach_vars[eNB_id]->prach              = (int16_t*)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
+
+      for (i=0; i<fp->nb_antennas_rx; i++) {
+        pbch_vars[eNB_id]->rxdataF_ext[i]    = (int32_t*)malloc16_clear( sizeof(int32_t)*6*12*4 );
+
+        for (j=0; j<4; j++) {//fp->nb_antennas_tx;j++) {
+          int idx = (j<<1)+i;
+          pbch_vars[eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t)*6*12*4 );
+          pbch_vars[eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*6*12*4 );
+        }
+      }
+    }
+
+    pbch_vars[eNB_id]->decoded_output = (uint8_t*)malloc16_clear( 64 );
+  }
+
+  // initialization for the last instance of pdsch_vars (used for MU-MIMO)
+
+  pdsch_vars_th0[eNB_id]     = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+  pdsch_vars_th1[eNB_id]     = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+  pdsch_vars_SI[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+  pdsch_vars_ra[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+
+  if (abstraction_flag == 0) {
+    phy_init_lte_ue__PDSCH( pdsch_vars_th0[eNB_id], fp );
+    pdsch_vars_th0[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+
+    phy_init_lte_ue__PDSCH( pdsch_vars_th1[eNB_id], fp );
+    pdsch_vars_th1[eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+  } else { //abstraction == 1
+    ue->sinr_dB = (double*) malloc16_clear( fp->N_RB_DL*12*sizeof(double) );
+  }
+
+  ue->sinr_CQI_dB = (double*) malloc16_clear( fp->N_RB_DL*12*sizeof(double) );
+
+  ue->init_averaging = 1;
+  // default value until overwritten by RRCConnectionReconfiguration
+  if (fp->nb_antenna_ports_eNB==2)
+    ue->pdsch_config_dedicated->p_a = dBm3;
+  else
+    ue->pdsch_config_dedicated->p_a = dB0;
+
+  // set channel estimation to do linear interpolation in time
+  ue->high_speed_flag = 1;
+  ue->ch_est_alpha    = 24576;
+
+  // enable MIB/SIB decoding by default
+  ue->decode_MIB = 1;
+  ue->decode_SIB = 1;
+
+  init_prach_tables(839);
+
+
+  return 0;
+}
+
+int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
+                     unsigned char is_secondary_eNB,
+                     unsigned char abstraction_flag)
+{
+
+  // shortcuts
+  LTE_DL_FRAME_PARMS* const fp      = &eNB->frame_parms;
+  LTE_eNB_COMMON* const common_vars = &eNB->common_vars;
+  LTE_eNB_PUSCH** const pusch_vars  = eNB->pusch_vars;
+  LTE_eNB_SRS* const srs_vars       = eNB->srs_vars;
+  LTE_eNB_PRACH* const prach_vars   = &eNB->prach_vars;
+
+  int i, j, eNB_id, UE_id;
+  int re;
+
+
+  eNB->total_dlsch_bitrate = 0;
+  eNB->total_transmitted_bits = 0;
+  eNB->total_system_throughput = 0;
+  eNB->check_for_MUMIMO_transmissions=0;
+  LOG_I(PHY,"[eNB %"PRIu8"] Initializing DL_FRAME_PARMS : N_RB_DL %"PRIu8", PHICH Resource %d, PHICH Duration %d\n",
+        eNB->Mod_id,
+        fp->N_RB_DL,fp->phich_config_common.phich_resource,
+        fp->phich_config_common.phich_duration);
+  LOG_D(PHY,"[MSC_NEW][FRAME 00000][PHY_eNB][MOD %02"PRIu8"][]\n", eNB->Mod_id);
+
+  if (eNB->node_function != NGFI_RRU_IF4p5) {
+    lte_gold(fp,eNB->lte_gold_table,fp->Nid_cell);
+    generate_pcfich_reg_mapping(fp);
+    generate_phich_reg_mapping(fp);
+
+    for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+      eNB->first_run_timing_advance[UE_id] =
+        1; ///This flag used to be static. With multiple eNBs this does no longer work, hence we put it in the structure. However it has to be initialized with 1, which is performed here.
+
+      // clear whole structure
+      bzero( &eNB->UE_stats[UE_id], sizeof(LTE_eNB_UE_stats) );
+
+      eNB->physicalConfigDedicated[UE_id] = NULL;
+    }
+
+    eNB->first_run_I0_measurements = 1; ///This flag used to be static. With multiple eNBs this does no longer work, hence we put it in the structure. However it has to be initialized with 1, which is performed here.
+  }
+
+  //  for (eNB_id=0; eNB_id<3; eNB_id++) {
+  {
+    eNB_id=0;
+    if (abstraction_flag==0) {
+
+      // TX vars
+      if (eNB->node_function != NGFI_RCC_IF4p5)
+
+        common_vars->txdata[eNB_id]  = (int32_t**)malloc16(fp->nb_antennas_tx*sizeof(int32_t*));
+      common_vars->txdataF[eNB_id] = (int32_t **)malloc16(NB_ANTENNA_PORTS_ENB*sizeof(int32_t*));
+      common_vars->txdataF_BF[eNB_id] = (int32_t **)malloc16(fp->nb_antennas_tx*sizeof(int32_t*));
+
+      if (eNB->node_function != NGFI_RRU_IF5) {
+        for (i=0; i<NB_ANTENNA_PORTS_ENB; i++) {
+          if (i<fp->nb_antenna_ports_eNB || i==5) {
+            common_vars->txdataF[eNB_id][i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t) );
+#ifdef DEBUG_PHY
+            printf("[openair][LTE_PHY][INIT] common_vars->txdataF[%d][%d] = %p (%lu bytes)\n",
+                   eNB_id,i,common_vars->txdataF[eNB_id][i],
+                   fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t));
+#endif
+          }
+        }
+      }
+
+      for (i=0; i<fp->nb_antennas_tx; i++) {
+        common_vars->txdataF_BF[eNB_id][i] = (int32_t*)malloc16_clear(fp->ofdm_symbol_size*sizeof(int32_t) );
+        if (eNB->node_function != NGFI_RCC_IF4p5)
+
+          // Allocate 10 subframes of I/Q TX signal data (time) if not
+          common_vars->txdata[eNB_id][i]  = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) );
+
+#ifdef DEBUG_PHY
+        printf("[openair][LTE_PHY][INIT] common_vars->txdata[%d][%d] = %p (%lu bytes)\n",eNB_id,i,common_vars->txdata[eNB_id][i],
+               fp->samples_per_tti*10*sizeof(int32_t));
+#endif
+      }
+
+      for (i=0; i<NB_ANTENNA_PORTS_ENB; i++) {
+        if (i<fp->nb_antenna_ports_eNB || i==5) {
+          common_vars->beam_weights[eNB_id][i] = (int32_t **)malloc16_clear(fp->nb_antennas_tx*sizeof(int32_t*));
+          for (j=0; j<fp->nb_antennas_tx; j++) {
+            common_vars->beam_weights[eNB_id][i][j] = (int32_t *)malloc16_clear(fp->ofdm_symbol_size*sizeof(int32_t));
+            // antenna ports 0-3 are mapped on antennas 0-3
+            // antenna port 4 is mapped on antenna 0
+            // antenna ports 5-14 are mapped on all antennas
+            if (((i<4) && (i==j)) || ((i==4) && (j==0))) {
+              for (re=0; re<fp->ofdm_symbol_size; re++)
+                common_vars->beam_weights[eNB_id][i][j][re] = 0x00007fff;
+            }
+            else if (i>4) {
+              for (re=0; re<fp->ofdm_symbol_size; re++)
+                common_vars->beam_weights[eNB_id][i][j][re] = 0x00007fff/fp->nb_antennas_tx;
+            }
+#ifdef DEBUG_PHY
+            msg("[openair][LTE_PHY][INIT] lte_common_vars->beam_weights[%d][%d][%d] = %p (%zu bytes)\n",
+                eNB_id,i,j,common_vars->beam_weights[eNB_id][i][j],
+                fp->ofdm_symbol_size*sizeof(int32_t));
+#endif
+          }
+        }
+      }
+
+
+      // RX vars
+      if (eNB->node_function != NGFI_RCC_IF4p5) {
+        common_vars->rxdata[eNB_id]        = (int32_t**)malloc16(fp->nb_antennas_rx*sizeof(int32_t*) );
+        common_vars->rxdata_7_5kHz[eNB_id] = (int32_t**)malloc16(fp->nb_antennas_rx*sizeof(int32_t*) );
+      }
+
+      common_vars->rxdataF[eNB_id]       = (int32_t**)malloc16(fp->nb_antennas_rx*sizeof(int32_t*) );
+
+
+      for (i=0; i<fp->nb_antennas_rx; i++) {
+        if (eNB->node_function != NGFI_RCC_IF4p5) {
+          // allocate 2 subframes of I/Q signal data (time) if not an RCC (no time-domain signals)
+          common_vars->rxdata[eNB_id][i] = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) );
+
+          if (eNB->node_function != NGFI_RRU_IF5)
+            // allocate 2 subframes of I/Q signal data (time, 7.5 kHz offset)
+            common_vars->rxdata_7_5kHz[eNB_id][i] = (int32_t*)malloc16_clear( 2*fp->samples_per_tti*2*sizeof(int32_t) );
+        }
+
+        if (eNB->node_function != NGFI_RRU_IF5)
+          // allocate 2 subframes of I/Q signal data (frequency)
+          common_vars->rxdataF[eNB_id][i] = (int32_t*)malloc16_clear(sizeof(int32_t)*(2*fp->ofdm_symbol_size*fp->symbols_per_tti) );
+
+#ifdef DEBUG_PHY
+        printf("[openair][LTE_PHY][INIT] common_vars->rxdata[%d][%d] = %p (%lu bytes)\n",eNB_id,i,common_vars->rxdata[eNB_id][i],fp->samples_per_tti*10*sizeof(int32_t));
+        if (eNB->node_function != NGFI_RRU_IF5)
+          printf("[openair][LTE_PHY][INIT] common_vars->rxdata_7_5kHz[%d][%d] = %p (%lu bytes)\n",eNB_id,i,common_vars->rxdata_7_5kHz[eNB_id][i],fp->samples_per_tti*2*sizeof(int32_t));
+#endif
+        common_vars->rxdataF[eNB_id][i] = (int32_t*)malloc16_clear(sizeof(int32_t)*(fp->ofdm_symbol_size*fp->symbols_per_tti) );
+      }
+
+
+      if ((eNB->node_function != NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5)) {
+
+        // Channel estimates for SRS
+        for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+
+          srs_vars[UE_id].srs_ch_estimates[eNB_id]      = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+          srs_vars[UE_id].srs_ch_estimates_time[eNB_id] = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+
+          for (i=0; i<fp->nb_antennas_rx; i++) {
+            srs_vars[UE_id].srs_ch_estimates[eNB_id][i]      = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size );
+            srs_vars[UE_id].srs_ch_estimates_time[eNB_id][i] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
+          }
+        } //UE_id
+
+        common_vars->sync_corr[eNB_id] = (uint32_t*)malloc16_clear( LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(uint32_t)*fp->samples_per_tti );
+      }
+    } // abstraction_flag = 0
+    else { //UPLINK abstraction = 1
+      eNB->sinr_dB = (double*) malloc16_clear( fp->N_RB_DL*12*sizeof(double) );
+    }
+  } //eNB_id
+
+
+
+  if (abstraction_flag==0) {
+    if ((eNB->node_function != NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5)) {
+      generate_ul_ref_sigs_rx();
+
+      // SRS
+      for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+        srs_vars[UE_id].srs = (int32_t*)malloc16_clear(2*fp->ofdm_symbol_size*sizeof(int32_t));
+      }
+    }
+  }
+
+
+
+  // ULSCH VARS, skip if NFGI_RRU_IF4
+
+
+  if ((eNB->node_function!=NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5))
+
+    prach_vars->prachF = (int16_t*)malloc16_clear( 1024*2*sizeof(int16_t) );
+
+  /* number of elements of an array X is computed as sizeof(X) / sizeof(X[0]) */
+  AssertFatal(fp->nb_antennas_rx <= sizeof(prach_vars->rxsigF) / sizeof(prach_vars->rxsigF[0]),
+              "nb_antennas_rx too large");
+  for (i=0; i<fp->nb_antennas_rx; i++) {
+    prach_vars->rxsigF[i] = (int16_t*)malloc16_clear( fp->ofdm_symbol_size*12*2*sizeof(int16_t) );
+#ifdef DEBUG_PHY
+    printf("[openair][LTE_PHY][INIT] prach_vars->rxsigF[%d] = %p\n",i,prach_vars->rxsigF[i]);
+#endif
+  }
+
+  if ((eNB->node_function != NGFI_RRU_IF4p5)&&(eNB->node_function != NGFI_RRU_IF5)) {
+
+    AssertFatal(fp->nb_antennas_rx <= sizeof(prach_vars->prach_ifft) / sizeof(prach_vars->prach_ifft[0]),
+                "nb_antennas_rx too large");
+    for (i=0; i<fp->nb_antennas_rx; i++) {
+      prach_vars->prach_ifft[i] = (int16_t*)malloc16_clear(1024*2*sizeof(int16_t));
+#ifdef DEBUG_PHY
+      printf("[openair][LTE_PHY][INIT] prach_vars->prach_ifft[%d] = %p\n",i,prach_vars->prach_ifft[i]);
+#endif
+    }
+
+    for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++) {
+
+      //FIXME
+      pusch_vars[UE_id] = (LTE_eNB_PUSCH*)malloc16_clear( NUMBER_OF_UE_MAX*sizeof(LTE_eNB_PUSCH) );
+
+      if (abstraction_flag==0) {
+        for (eNB_id=0; eNB_id<3; eNB_id++) {
+
+          pusch_vars[UE_id]->rxdataF_ext[eNB_id]      = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+          pusch_vars[UE_id]->rxdataF_ext2[eNB_id]     = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+          pusch_vars[UE_id]->drs_ch_estimates[eNB_id] = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+          pusch_vars[UE_id]->drs_ch_estimates_time[eNB_id] = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+          pusch_vars[UE_id]->rxdataF_comp[eNB_id]     = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+          pusch_vars[UE_id]->ul_ch_mag[eNB_id]  = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+          pusch_vars[UE_id]->ul_ch_magb[eNB_id] = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+
+          for (i=0; i<fp->nb_antennas_rx; i++) {
+            // RK 2 times because of output format of FFT!
+            // FIXME We should get rid of this
+            pusch_vars[UE_id]->rxdataF_ext[eNB_id][i]      = (int32_t*)malloc16_clear( 2*sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
+            pusch_vars[UE_id]->rxdataF_ext2[eNB_id][i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
+            pusch_vars[UE_id]->drs_ch_estimates[eNB_id][i] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
+            pusch_vars[UE_id]->drs_ch_estimates_time[eNB_id][i] = (int32_t*)malloc16_clear( 2*2*sizeof(int32_t)*fp->ofdm_symbol_size );
+            pusch_vars[UE_id]->rxdataF_comp[eNB_id][i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->N_RB_UL*12*fp->symbols_per_tti );
+            pusch_vars[UE_id]->ul_ch_mag[eNB_id][i]  = (int32_t*)malloc16_clear( fp->symbols_per_tti*sizeof(int32_t)*fp->N_RB_UL*12 );
+            pusch_vars[UE_id]->ul_ch_magb[eNB_id][i] = (int32_t*)malloc16_clear( fp->symbols_per_tti*sizeof(int32_t)*fp->N_RB_UL*12 );
+          }
+        } //eNB_id
+
+        pusch_vars[UE_id]->llr = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+      } // abstraction_flag
+    } //UE_id
+
+
+    if (abstraction_flag==0) {
+      if (is_secondary_eNB) {
+        for (eNB_id=0; eNB_id<3; eNB_id++) {
+          eNB->dl_precoder_SeNB[eNB_id] = (int **)malloc16(4*sizeof(int*));
+
+          if (eNB->dl_precoder_SeNB[eNB_id]) {
+#ifdef DEBUG_PHY
+            printf("[openair][SECSYS_PHY][INIT] eNB->dl_precoder_SeNB[%d] allocated at %p\n",eNB_id,
+                eNB->dl_precoder_SeNB[eNB_id]);
+#endif
+          } else {
+            printf("[openair][SECSYS_PHY][INIT] eNB->dl_precoder_SeNB[%d] not allocated\n",eNB_id);
+            return(-1);
+          }
+
+          for (j=0; j<fp->nb_antennas_tx; j++) {
+            eNB->dl_precoder_SeNB[eNB_id][j] = (int *)malloc16(2*sizeof(int)*(fp->ofdm_symbol_size)); // repeated format (hence the '2*')
+
+            if (eNB->dl_precoder_SeNB[eNB_id][j]) {
+#ifdef DEBUG_PHY
+              printf("[openair][LTE_PHY][INIT] eNB->dl_precoder_SeNB[%d][%d] allocated at %p\n",eNB_id,j,
+                  eNB->dl_precoder_SeNB[eNB_id][j]);
+#endif
+              memset(eNB->dl_precoder_SeNB[eNB_id][j],0,2*sizeof(int)*(fp->ofdm_symbol_size));
+            } else {
+              printf("[openair][LTE_PHY][INIT] eNB->dl_precoder_SeNB[%d][%d] not allocated\n",eNB_id,j);
+              return(-1);
+            }
+          } //for(j=...nb_antennas_tx
+
+        } //for(eNB_id...
+      }
+    }
+
+    for (UE_id=0; UE_id<NUMBER_OF_UE_MAX; UE_id++)
+      eNB->UE_stats_ptr[UE_id] = &eNB->UE_stats[UE_id];
+
+    //defaul value until overwritten by RRCConnectionReconfiguration
+    if (fp->nb_antenna_ports_eNB==2)
+      eNB->pdsch_config_dedicated->p_a = dBm3;
+    else
+      eNB->pdsch_config_dedicated->p_a = dB0;
+
+    init_prach_tables(839);
+  } // node_function != NGFI_RRU_IF4p5
+
+  return (0);
+
+}
diff --git a/openair1/PHY/impl_defs_lte-nb.h b/openair1/PHY/impl_defs_lte-nb.h
new file mode 100644
index 0000000000..d8d2aa90f4
--- /dev/null
+++ b/openair1/PHY/impl_defs_lte-nb.h
@@ -0,0 +1,222 @@
+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file PHY/impl_defs_lte.h
+* \brief LTE Physical channel configuration and variable structure definitions
+* \author R. Knopp, F. Kaltenberger
+* \date 2011
+* \version 0.1
+* \company Eurecom
+* \email: knopp@eurecom.fr,florian.kaltenberger@eurecom.fr
+* \note
+* \warning
+*/
+
+
+
+#include "types.h"
+//#include "defs.h"
+
+#define	A_SEQUENCE_OF(type)	A_SET_OF(type)
+
+#define	A_SET_OF(type)					\
+	struct {					\
+		type **array;				\
+		int count;	/* Meaningful size */	\
+		int size;	/* Allocated size */	\
+		void (*free)(type *);			\
+	}
+
+
+/// NPRACH-ParametersList-NB-r13 from 36.331 RRC spec
+typedef struct {
+  /// the period time for nprach
+  uint8_t nprach_Periodicity;
+  /// for the start time for the NPRACH resource from 40ms-2560ms
+  uint8_t nprach_StartTime;	
+  /// for the subcarrier of set to the NPRACH preamble from n0 - n34
+  uint8_t nprach_SubcarrierOffset;
+  /// where is the region that in NPRACH resource to indicate if this UE support MSG3 for multi-tone or not. from 0 - 1
+  uint8_t nprach_SubcarrierMSG3_RangeStart;
+  /// The max preamble transmission attempt for the CE level from 1 - 128
+  uint8_t maxNumPreambleAttemptCE;
+  /// The number of the repetition for DCI use in RAR/MSG3/MSG4 from 1 - 2048
+  uint8_t npdcch_NumRepetitions_RA;
+  /// Starting subframe for NPDCCH Common searching space for (RAR/MSG3/MSG4)
+  uint8_t npdcch_StartSF_CSS_RA;
+  /// Fractional period offset of starting subframe for NPDCCH common search space
+  uint8_t npdcch_Offset_RA;
+} nprach_parameters_NB_t;
+
+typedef struct{
+  A_SEQUENCE_OF(struct NPRACH_Parameters_NB) list;
+}NPRACH_List_NB_t;
+
+typedef long RSRP_Range_t;
+
+typedef struct {
+  A_SEQUENCE_OF(RSRP_Range_t) list;
+}rsrp_ThresholdsNPrachInfoList;
+
+
+/// NPRACH_ConfigSIB-NB from 36.331 RRC spec
+typedef struct {
+  /// nprach_CP_Length_r13, for the CP length(unit us) only 66.7 and 266.7 is implemented
+  uint8_t nprach_CP_Length;
+  /// The criterion for UEs to select a NPRACH resource. Up to 2 RSRP threshold values can be signalled.  \vr{[1..2]}
+  struct rsrp_ThresholdsNPrachInfoList *rsrp_ThresholdsPrachInfoList;
+  /// NPRACH Parameters List
+  NPRACH_List_NB_t nprach_ParametersList;
+} NPRACH_CONFIG_COMMON;
+
+/// NPDSCH-ConfigCommon from 36.331 RRC spec
+typedef struct {
+  ///see TS 36.213 (16.2). \vr{[-60..50]}\n Provides the downlink reference-signal EPRE. The actual value in dBm.
+  int8_t nrs_Power;
+} NPDSCH_CONFIG_COMMON;
+
+typedef struct{
+  /// The base sequence of DMRS sequence in a cell for 3 tones transmission; see TS 36.211 [21, 10.1.4.1.2]. If absent, it is given by NB-IoT CellID mod 12. Value 12 is not used.
+  uint8_t threeTone_BaseSequence;
+  /// Define 3 cyclic shifts for the 3-tone case, see TS 36.211 [21, 10.1.4.1.2].
+  uint8_t threeTone_CyclicShift;
+  /// The base sequence of DMRS sequence in a cell for 6 tones transmission; see TS 36.211 [21, 10.1.4.1.2]. If absent, it is given by NB-IoT CellID mod 14. Value 14 is not used.
+  uint8_t sixTone_BaseSequence;
+  /// Define 4 cyclic shifts for the 6-tone case, see TS 36.211 [21, 10.1.4.1.2].
+  uint8_t sixTone_CyclicShift;
+  /// The base sequence of DMRS sequence in a cell for 12 tones transmission; see TS 36.211 [21, 10.1.4.1.2]. If absent, it is given by NB-IoT CellID mod 30. Value 30 is not used.
+  uint8_t twelveTone_BaseSequence;
+
+}DMRS_CONFIG_t;
+
+/// UL-ReferenceSignalsNPUSCH from 36.331 RRC spec
+typedef struct {
+  /// Parameter: Group-hopping-enabled, see TS 36.211 (5.5.1.3). \vr{[0..1]}
+  uint8_t groupHoppingEnabled;
+  /// , see TS 36.211 (5.5.1.3). \vr{[0..29]}
+  uint8_t groupAssignmentNPUSCH;
+} UL_REFERENCE_SIGNALS_NPUSCH_t;
+
+
+/// PUSCH-ConfigCommon from 36.331 RRC spec.
+typedef struct {
+  /// Number of repetitions for ACK/NACK HARQ response to NPDSCH containing Msg4 per NPRACH resource, see TS 36.213 [23, 16.4.2].
+  uint8_t ack_NACK_NumRepetitions_Msg4[3];
+  /// SRS SubframeConfiguration. See TS 36.211 [21, table 5.5.3.3-1]. Value sc0 corresponds to value 0, sc1 to value 1 and so on.
+  uint8_t srs_SubframeConfig;
+  /// Parameter: \f$N^{HO}_{RB}\f$, see TS 36.211 (5.3.4). \vr{[0..98]}
+  DMRS_CONFIG_t dmrs_Config;
+  /// Ref signals configuration
+  UL_REFERENCE_SIGNALS_NPUSCH_t ul_ReferenceSignalsNPUSCH;
+} NPUSCH_CONFIG_COMMON;
+
+
+typedef struct{
+  /// See TS 36.213 [23, 16.2.1.1], unit dBm.
+  uint8_t p0_NominalNPUSCH;
+  /// See TS 36.213 [23, 16.2.1.1] where al0 corresponds to 0, al04 corresponds to value 0.4, al05 to 0.5, al06 to 0.6, al07 to 0.7, al08 to 0.8, al09 to 0.9 and al1 corresponds to 1. 
+  uint8_t alpha;
+  /// See TS 36.213 [23, 16.2.1.1]. Actual value = IE value * 2 [dB].
+  uint8_t deltaPreambleMsg3;
+}UplinkPowerControlCommon_NB;
+
+
+/* DL-GapConfig-NB-r13 */
+typedef struct {
+	uint8_t	 dl_GapThreshold;
+	uint8_t	 dl_GapPeriodicity;
+	uint8_t	 dl_GapDurationCoeff;
+} DL_GapConfig_NB;
+
+typedef struct {
+  /// Cell ID
+  uint16_t Nid_cell;
+  /// Cyclic Prefix for DL (0=Normal CP, 1=Extended CP)
+  lte_prefix_type_t Ncp;
+  /// Cyclic Prefix for UL (0=Normal CP, 1=Extended CP)
+  lte_prefix_type_t Ncp_UL;
+  /// shift of pilot position in one RB
+  uint8_t nushift;
+  /// indicates if node is a UE (NODE=2) or eNB (PRIMARY_CH=0).
+  uint8_t node_id;
+  /// Frequency index of CBMIMO1 card
+  uint8_t freq_idx;
+  /// RX Frequency for ExpressMIMO/LIME
+  uint32_t carrier_freq[4];
+  /// TX Frequency for ExpressMIMO/LIME
+  uint32_t carrier_freqtx[4];
+  /// RX gain for ExpressMIMO/LIME
+  uint32_t rxgain[4];
+  /// TX gain for ExpressMIMO/LIME
+  uint32_t txgain[4];
+  /// RF mode for ExpressMIMO/LIME
+  uint32_t rfmode[4];
+  /// RF RX DC Calibration for ExpressMIMO/LIME
+  uint32_t rxdc[4];
+  /// RF TX DC Calibration for ExpressMIMO/LIME
+  uint32_t rflocal[4];
+  /// RF VCO calibration for ExpressMIMO/LIME
+  uint32_t rfvcolocal[4];
+  /// Turns on second TX of CBMIMO1 card
+  uint8_t dual_tx;
+  /// flag to indicate SISO transmission
+  uint8_t mode1_flag;
+  /// Indicator that 20 MHz channel uses 3/4 sampling frequency
+  //uint8_t threequarter_fs;
+  /// Size of FFT
+  uint16_t ofdm_symbol_size;
+  /// Number of prefix samples in all but first symbol of slot
+  uint16_t nb_prefix_samples;
+  /// Number of prefix samples in first symbol of slot
+  uint16_t nb_prefix_samples0;
+  /// Carrier offset in FFT buffer for first RE in PRB0
+  uint16_t first_carrier_offset;
+  /// Number of samples in a subframe
+  uint32_t samples_per_tti;
+  /// Number of OFDM/SC-FDMA symbols in one subframe (to be modified to account for potential different in UL/DL)
+  uint16_t symbols_per_tti;
+  /// Number of Physical transmit antennas in node
+  uint8_t nb_antennas_tx;
+  /// Number of Receive antennas in node
+  uint8_t nb_antennas_rx;
+  /// Number of common transmit antenna ports in eNodeB (1 or 2)
+  uint8_t nb_antenna_ports_eNB;
+  /// NPRACH Config Common (from 36-331 RRC spec)
+  NPRACH_CONFIG_COMMON nprach_config_common;
+  /// NPDSCH Config Common (from 36-331 RRC spec)
+  NPDSCH_CONFIG_COMMON npdsch_config_common;
+  /// PUSCH Config Common (from 36-331 RRC spec)
+  NPUSCH_CONFIG_COMMON npusch_config_common;
+  /// UL Power Control (from 36-331 RRC spec)
+  UplinkPowerControlCommon_NB ul_power_control_config_common;
+  /// DL Gap
+  DL_GapConfig_NB DL_gap_config;
+  /// Size of SI windows used for repetition of one SI message (in frames)
+  uint8_t SIwindowsize;
+  /// Period of SI windows used for repetition of one SI message (in frames)
+  uint16_t SIPeriod;
+  int                 eutra_band;
+  uint32_t            dl_CarrierFreq;
+  uint32_t            ul_CarrierFreq;
+  uint8_t             CE;// CE level to determine the NPRACH Configuration
+
+} NB_DL_FRAME_PARMS;
+
-- 
2.26.2