MU-MIMO STREAM_MANAGEMENT and channel

[cacent96]

Hello,

I'm simulating a MU-MIMO downlink case with one BS and 4 UE, each with one antenna. I'm not sure if I have the stream correctly. Apart from this, if I would like to apply different channel to different stream, how could I do that?

NUM_TX = 1
NUM_RX = 4
batch_size = 1

NUM_STREAMS_PER_TX = 4 #BS with 4 antenna each to each user
RX_TX_ASSOCIATION = np.zeros([NUM_RX, NUM_TX]) #receiver, transmitter
RX_TX_ASSOCIATION[:, 0] = 1 #One BS send one stream to each receiver

STREAM_MANAGEMENT = sionna.mimo.StreamManagement(RX_TX_ASSOCIATION, NUM_STREAMS_PER_TX)
`

[jhoydis]

Hi,

The StreamManagement looks correct.

If you want to apply a different channel model for each receiver, you can do so by simply creating four different channel model instances, e.g., TDL with different parameters or antenna correlation.

Then you can generate a batch of channel impulse responses for each receiver which you concatenate to a larger tensor that you then use in the cir_to_ofdm_channel or cir_to_time_channel.

Below is a code skeleton that explains the idea:

# Each a has shape [batch size, 1, 1, 1, 4, num_paths, num_time_steps]
# Each tau has shape [batch size, 1, 1, num_paths]
a_1, tau_1  = model_1(batch_size,...)
a_2, tau_2  = model_2(batch_size,...)
a_3, tau_3  = model_3(batch_size,...)
a_4, tau_4  = model_4(batch_size,...)

# Final shape of a [batch size, 4, 1, 1, 4, num_paths, num_time_steps]
a = tf.concat([a_1, a_2, a_3, a_4], axis=1)

# Final shape of tau [batch size, 4, 1, num_paths]
tau = tf.concat([tau_1, tau_2, tau_3, tau_4], axis=1)

# Generate channel frequency response
frequencies = subcarrier_frequencies(num_subcarriers, subcarrier_spacing)
h_freq = cir_to_ofdm_channel(frequencies, a, tau)

# Use e.g., ApplyOFDMChannel() to compute the channel output

[cacent96]

Yes the modulator is the OFDMModulator.

As per my resource grid, the ofdm symbol is 14.
The num_time_steps=RESOURCE_GRID.num_ofdm_symbols is also 14.

But the RESOURCE_GRID.num_time_samples is essentially the samples the resource grid will use, the number is 3668. It shouldn't be matching as there are two different thing.

RESOURCE_GRID = sionna.ofdm.ResourceGrid(num_ofdm_symbols=14,
                                      fft_size=256,
                                      subcarrier_spacing=15e3,
                                      num_tx=NUM_TX,
                                      num_guard_carriers=[5,6],
                                      num_streams_per_tx=NUM_STREAMS_PER_TX,
                                      cyclic_prefix_length=6,
                                      pilot_pattern="kronecker",
                                      dc_null=True,
                                      pilot_ofdm_symbol_indices=[2,11])

[cacent96]

I found the problem, the continuous-time channel impulse response must be sampled at the Nyquist rate. We also need now num_ofdm_symbols x (fft_size + cyclic_prefix_length) + l_tot-1. Totally miss this part.

[cacent96]

After the change in the channel response, I get an error on the precoding, the shape of the two input are different,

frequencies = sionna.channel.subcarrier_frequencies(RESOURCE_GRID.fft_size, RESOURCE_GRID.subcarrier_spacing)
x_rg = zf_precoder([x_rg, h_freq])
h_freq = sionna.channel.cir_to_ofdm_channel(frequencies, a, tau, normalize=True)

(1, 1, 4, 14, 256)
(1, 4, 1, 1, 4, 3692, 256)

[jhoydis]

Could it be that you are sampling the channel impulse response at the Nyquist rate? In the frequency domain, you assume that you sample the channel once every (fft_size+cyclic_prefix_length) samples. You could simply downsample h_freq as shown in this example:

if self._domain == "time":
    # Time-domain simulations

    a, tau = self._cdl(batch_size, self._rg.num_time_samples+self._l_tot-1, self._rg.bandwidth)
    h_time = cir_to_time_channel(self._rg.bandwidth, a, tau,
                                         l_min=self._l_min, l_max=self._l_max, normalize=True)

    # As precoding is done in the frequency domain, we need to downsample
    # the path gains `a` to the OFDM symbol rate prior to converting the CIR
    # to the channel frequency response.
    a_freq = a[...,self._rg.cyclic_prefix_length:-1:(self._rg.fft_size+self._rg.cyclic_prefix_length)]
    a_freq = a_freq[...,:self._rg.num_ofdm_symbols]
    h_freq = cir_to_ofdm_channel(self._frequencies, a_freq, tau, normalize=True)

    if self._direction == "downlink":
        x_rg, g = self._zf_precoder([x_rg, h_freq])

[cacent96]

Thank you Jakob for the quick explanation. Really appreciate it!