Error in BER plot for channel dataset generated using SionnaRT and OpenStreetMap

[AnikRoy1997]

Hello everyone,
I have imported a map from OpenStreetMap into blender, followed the steps as shown in the SionnaRT tutorial video to get the mitsuba file for importing in Sionna. In Sionna, I am using the following configuration to get the CIR,

# Configure an OFDM resource grid
scene.frequency = 2e9
rg = ResourceGrid(num_ofdm_symbols=14,
                  fft_size=120,
                  subcarrier_spacing=15e3)  #change subcarrier spacing based on 2^\mu * 15kHz
frequencies = subcarrier_frequencies(rg.fft_size, rg.subcarrier_spacing)
# Configure antenna array for all receiver(=base station)
scene.rx_array = PlanarArray(num_rows=1,
                        num_cols=options['num_ant'],
                        vertical_spacing=0.5,
                        horizontal_spacing=0.5,
                        pattern="tr38901",
                        polarization="V")

# Configure antenna array for all transmitters
scene.tx_array = PlanarArray(num_rows=1,
                        num_cols=1,
                        vertical_spacing=0.5,
                        horizontal_spacing=0.5,
                        pattern="tr38901",
                        polarization="V")

Simultaneously, I am simulating a vehicle traffic simulation (a 4 vehicle platoon) using SUMO and PLEXE. From the PLEXE, I am getting the positions of the vehicles and am placing the transmitters at those locations in the map. For the receiver, I have placed it in close vicinity of the vehicles. The ray traces look like this,

Then I create a link level model using the following code,

class LinkModel(tf.keras.Model):
    def __init__(self,
                 bf_vec,
                 ch_ul,
                 options,
                 scene,
                 carrier_frequency=2e9,
                 cyclic_prefix_length=10,
                 pilot_ofdm_symbol_indices=[2,3,10,11],
                 subcarrier_spacing = 15e3,
                 batch_size = 64
                ):
        super().__init__()

        self._batch_size = batch_size
        self._cyclic_prefix_length = cyclic_prefix_length
        self._pilot_ofdm_symbol_indices = pilot_ofdm_symbol_indices

        # CIRDataset to parse the dataset
        self._ofdm_channel_ul = ch_ul  #ofdm channel
        self._scene = scene

        self.num_tx_ant = 1
        self.num_rx_ant = options['num_ant']

        # System parameters
        self._carrier_frequency = carrier_frequency
        self._subcarrier_spacing = subcarrier_spacing
        self._fft_size = 120  
        self._num_ofdm_symbols = 14  
        self._num_streams_per_tx = 1 
        self._dc_null = False
        self._num_guard_carriers = [0, 0]
        self._pilot_pattern = "kronecker"
        self._pilot_ofdm_symbol_indices = pilot_ofdm_symbol_indices
        self._num_bits_per_symbol = 6
        self._coderate = 2/3
        self._options = options

        # Setup the OFDM resource grid and stream management
        self._sm = StreamManagement(np.ones((1,1), int), self._num_streams_per_tx)
        self._rg = ResourceGrid(num_ofdm_symbols=self._num_ofdm_symbols,
                                fft_size=self._fft_size,
                                subcarrier_spacing = self._subcarrier_spacing,
                                num_tx=1,
                                num_streams_per_tx=self._num_streams_per_tx,
                                cyclic_prefix_length=self._cyclic_prefix_length,
                                num_guard_carriers=self._num_guard_carriers,
                                dc_null=self._dc_null,
                                pilot_pattern=self._pilot_pattern,
                                pilot_ofdm_symbol_indices=self._pilot_ofdm_symbol_indices)

        # Codeword length n
        self._n = int(self._rg.num_data_symbols * self._num_bits_per_symbol)
        # Number of information bits per codeword k
        self._k = int(self._n * self._coderate)

        self._frequencies = subcarrier_frequencies(self._rg.fft_size, self._rg.subcarrier_spacing)
        self._channel_freq = ApplyOFDMChannel(add_awgn=True)

        # Transmitter
        self._binary_source = BinaryRep()
        self._encoder = LDPC5GEncoder(self._k, self._n)
        self._interleaver = sionna.fec.interleaving.RowColumnInterleaver(
                                        row_depth=self._num_bits_per_symbol)
        self._deinterleaver = sionna.fec.interleaving.Deinterleaver(self._interleaver)
        self._mapper = Mapper("qam", self._num_bits_per_symbol)
        self._rg_mapper = ResourceGridMapper(self._rg)
        self._zf_precoder = ZFPrecoder(self._rg, self._sm, return_effective_channel=True)

        # Receiver
        self._ls_est = LSChannelEstimator(self._rg, interpolation_type="lin_time_avg")
        self._lmmse_equ = LMMSEEqualizer(self._rg, self._sm)
        self._demapper = Demapper("app", "qam", self._num_bits_per_symbol)
        self._decoder = LDPC5GDecoder(self._encoder, hard_out=False)
        self._remove_nulled_scs = RemoveNulledSubcarriers(self._rg)

  def call(self, batch_size, ebno_db, bin_data):
          # Transmitter Veh
          b = self._binary_source.call(bin_data, [batch_size, self._num_streams_per_tx, self._k])
          c = self._encoder(b)
          c = self._interleaver(c)
          x = self._mapper(c)
          x_rg = self._rg_mapper(x)
          # Generate the OFDM UL channel
          h_freq = self._ofdm_channel_ul
          # Apply OFDM channel
          no = ebnodb2no(ebno_db, self._num_bits_per_symbol, self._coderate, self._rg)
          y = self._channel_freq([x_rg, h_freq, no])
  
          # Receiver BS
          h_hat, err_var = self._ls_est([y, no])
          x_hat, no_eff = self._lmmse_equ([y, h_hat, err_var, no])
          llr = self._demapper([x_hat, no_eff])
          llr=self._deinterleaver(llr)
          b_hat = self._decoder(llr)
  
          return b, b_hat, y, x_rg

Here, the "BinaryRep()" takes as input the vehicle's data (position, velocity, acceleration), converts them to 32-bit binary representations for transmission over the link model. For each vehicle's data transmission to the base station, I am plotting the BER over the set of Eb/No (dB) values [-20,-10,0,10,20,30,40,50]. I have set the batch_size as 100, maximum iterations as 100, number of target bloack errors as 10, and soft_estimates=True. For this i am getting the BER plot as,

The BER values at 10dB are as high as 0.5, which is not usual for a given ofdm channel. Can you suggest where am I going wrong in this?

[jhoydis]

Hi @AnikRoy1997,

I cannot see from your example how the channels are generated. If they are not normalized, such a behavior can happen. It is also not clear from your code how many antennas you have to spatially separate the users. Could you provide a full code example that we can execute?

[AnikRoy1997]

ExampleCode.zip
The main file is named as "TD-INVASE_BFforPlatooning_withLinkMod.py". I have normalized the channels during the generation process, still the BER performance is poor. Because vehicles have a certain speed, I have added doppler effect on the channels generated. The above code contains channel normalization and doppler effect addition. The BER values I am getting are as follows,