OFDMEqualizer#

class sionna.phy.ofdm.OFDMEqualizer(equalizer: Callable, resource_grid: sionna.phy.ofdm.resource_grid.ResourceGrid, stream_management: sionna.phy.mimo.stream_management.StreamManagement, precision: Literal['single', 'double'] | None = None, device: str | None = None, **kwargs)[source]#

Bases: sionna.phy.block.Block

Block that wraps a MIMO equalizer for use with the OFDM waveform.

The parameter equalizer is a callable (e.g., a function) that implements a MIMO equalization algorithm for arbitrary batch dimensions.

This class pre-processes the received resource grid y and channel estimate h_hat, and computes for each receiver the noise-plus-interference covariance matrix according to the OFDM and stream configuration provided by the resource_grid and stream_management, which also accounts for the channel estimation error variance err_var. These quantities serve as input to the equalization algorithm that is implemented by the callable equalizer. This block computes soft-symbol estimates together with effective noise variances for all streams which can, e.g., be used by a Demapper to obtain LLRs.

Notes

The callable equalizer must take three inputs:

y ([…,num_rx_ant], torch.complex) – 1+D tensor containing the received signals.
h ([…,num_rx_ant,num_streams_per_rx], torch.complex) – 2+D tensor containing the channel matrices.
s ([…,num_rx_ant,num_rx_ant], torch.complex) – 2+D tensor containing the noise-plus-interference covariance matrices.

It must generate two outputs:

x_hat ([…,num_streams_per_rx], torch.complex) – 1+D tensor representing the estimated symbol vectors.
no_eff (torch.float) – Tensor of the same shape as x_hat containing the effective noise variance estimates.

Parameters:

equalizer (Callable) – Callable object (e.g., a function) that implements a MIMO equalization algorithm for arbitrary batch dimensions.
resource_grid (sionna.phy.ofdm.resource_grid.ResourceGrid) – ResourceGrid to be used
stream_management (sionna.phy.mimo.stream_management.StreamManagement) – StreamManagement to be used
precision (Literal['single', 'double'] | None) – Precision used for internal calculations and outputs. If set to None, precision is used.
device (str | None) – Device for tensor operations. If None, device is used.

Inputs:

y – [batch_size, num_rx, num_rx_ant, num_ofdm_symbols, fft_size], torch.complex. Received OFDM resource grid after cyclic prefix removal and FFT.
h_hat – [batch_size, num_rx, num_rx_ant, num_tx, num_streams_per_tx, num_ofdm_symbols, num_effective_subcarriers], torch.complex. Channel estimates for all streams from all transmitters.
err_var – [Broadcastable to shape of h_hat], torch.float. Variance of the channel estimation error.
no – [batch_size, num_rx, num_rx_ant] (or only the first n dims), torch.float. Variance of the AWGN.

Outputs:

x_hat – [batch_size, num_tx, num_streams, num_data_symbols], torch.complex. Estimated symbols.
no_eff – [batch_size, num_tx, num_streams, num_data_symbols], torch.float. Effective noise variance for each estimated symbol.

Examples

import numpy as np
import torch
from sionna.phy.ofdm import ResourceGrid, LMMSEEqualizer
from sionna.phy.mimo import StreamManagement

rg = ResourceGrid(num_ofdm_symbols=14,
                  fft_size=64,
                  subcarrier_spacing=30e3,
                  num_tx=2,
                  num_streams_per_tx=2,
                  pilot_pattern="kronecker",
                  pilot_ofdm_symbol_indices=[2, 11])
sm = StreamManagement(np.ones([1, 2]), 2)
equalizer = LMMSEEqualizer(rg, sm)

batch_size = 16
y = torch.randn(batch_size, 1, 4, 14, 64, dtype=torch.complex64)
h_hat = torch.randn(batch_size, 1, 4, 2, 2, 14, 60, dtype=torch.complex64)
err_var = torch.ones(1) * 0.01
no = torch.ones(1) * 0.1

x_hat, no_eff = equalizer(y, h_hat, err_var, no)
print(x_hat.shape, no_eff.shape)
# torch.Size([16, 2, 2, 840]) torch.Size([16, 2, 2, 840])

OFDMEqualizer#

This Page