MMSEPICDetector#

class sionna.phy.mimo.MMSEPICDetector(output: str, demapping_method: str = 'maxlog', num_iter: int = 1, constellation_type: str | None = None, num_bits_per_symbol: int | None = None, constellation: sionna.phy.mapping.Constellation | None = None, hard_out: bool = False, precision: Literal['single', 'double'] | None = None, device: str | None = None, **kwargs)[source]#

Bases: sionna.phy.block.Block

Minimum mean square error (MMSE) with parallel interference cancellation (PIC) detector.

This block implements the MMSE PIC detector, as proposed in [CST2011]. For num_iter>1, this implementation performs MMSE PIC self-iterations. MMSE PIC self-iterations can be understood as a concatenation of MMSE PIC detectors from [CST2011], which forward intrinsic LLRs to the next self-iteration.

Compared to [CST2011], this implementation also accepts priors on the constellation symbols as an alternative to priors on the bits.

This block assumes the following channel model:

\[\mathbf{y} = \mathbf{H}\mathbf{x} + \mathbf{n}\]

where \(\mathbf{y}\in\mathbb{C}^M\) is the received signal vector, \(\mathbf{x}\in\mathcal{C}^S\) is the vector of transmitted symbols which are uniformly and independently drawn from the constellation \(\mathcal{C}\), \(\mathbf{H}\in\mathbb{C}^{M\times S}\) is the known channel matrix, and \(\mathbf{n}\in\mathbb{C}^M\) is a complex Gaussian noise vector. It is assumed that \(\mathbb{E}\left[\mathbf{n}\right]=\mathbf{0}\) and \(\mathbb{E}\left[\mathbf{n}\mathbf{n}^{\mathsf{H}}\right]=\mathbf{S}\), where \(\mathbf{S}\) has full rank.

The algorithm starts by computing the soft symbols \(\bar{x}_s=\mathbb{E}\left[ x_s \right]\) and variances \(v_s=\mathbb{E}\left[ |e_s|^2\right]\) from the priors, where \(e_s = x_s - \bar{x}_s\), for all \(s=1,\dots,S\).

Next, for each stream, the interference caused by all other streams is cancelled from the observation \(\mathbf{y}\), leading to

\[\hat{\mathbf{y}}_s = \mathbf{y} - \sum_{j\neq s} \mathbf{h}_j x_j = \mathbf{h}_s x_s + \tilde{\mathbf{n}}_s,\quad s=1,\dots,S\]

where \(\tilde{\mathbf{n}}_s=\sum_{j\neq s} \mathbf{h}_j e_j + \mathbf{n}\).

Then, a linear MMSE filter \(\mathbf{w}_s\) is computed to reduce the residual noise for each observation \(\hat{\mathbf{y}}_s\), which is given as

\[\mathbf{w}_s = \mathbf{h}_s^{\mathsf{H}}\left( \mathbf{H} \mathbf{D}_s\mathbf{H}^{\mathsf{H}} +\mathbf{S} \right)^{-1}\]

where \(\mathbf{D}_s \in \mathbb{C}^{S\times S}\) is diagonal with entries

\[\begin{split}\left[\mathbf{D}_s\right]_{i,i} = \begin{cases} v_i & i\neq s \\ 1 & i=s. \end{cases}\end{split}\]

The filtered observations

\[\tilde{z}_s = \mathbf{w}_s^{\mathsf{H}} \hat{\mathbf{y}}_s = \tilde{\mu}_s x_s + \mathbf{w}_s^{\mathsf{H}}\tilde{\mathbf{n}}_s\]

where \(\tilde{\mu}_s=\mathbf{w}_s^{\mathsf{H}} \mathbf{h}_s\), are then demapped to either symbol logits or LLRs, assuming that the remaining noise is Gaussian with variance

\[\nu_s^2 = \mathop{\text{Var}}\left[\tilde{z}_s\right] = \mathbf{w}_s^{\mathsf{H}} \left(\sum_{j\neq s} \mathbf{h}_j \mathbf{h}_j^{\mathsf{H}} v_j +\mathbf{S} \right)\mathbf{w}_s.\]

The resulting soft-symbols can then be used for the next self-iteration of the algorithm.

Note that this algorithm can be substantially simplified as described in [CST2011] to avoid the computation of different matrix inverses for each stream. This is the version which is implemented.

Parameters:

  • output (str) – Type of output, either "bit" for LLRs on bits or "symbol" for logits on constellation symbols

  • demapping_method (str) – Demapping method, either "maxlog" (default) or "app"

  • num_iter (int) – Number of MMSE PIC iterations. Defaults to 1.

  • constellation_type (str | None) – Constellation type, one of "qam", "pam", or "custom". For "custom", an instance of Constellation must be provided.

  • num_bits_per_symbol (int | None) – Number of bits per constellation symbol, e.g., 4 for QAM16. Only required for constellation_type in ["qam", "pam"].

  • constellation (sionna.phy.mapping.Constellation | None) – An instance of Constellation or None. If None, constellation_type and num_bits_per_symbol must be provided.

  • hard_out (bool) – If True, the detector computes hard-decided bit values or constellation point indices instead of soft-values. Defaults to False.

  • precision (Literal['single', 'double'] | None) – Precision used for internal calculations and outputs. If set to None, precision is used.

  • device (str | None) – Device for computations

Inputs:

  • y – […,M], torch.complex. Received signals.

  • h – […,M,num_streams], torch.complex. Channel matrices.

  • s – […,M,M], torch.complex. Noise covariance matrices.

  • prior – […,num_streams,num_bits_per_symbol] or […,num_streams,num_points], torch.float. Prior of the transmitted signals. If output equals "bit", then LLRs of the transmitted bits are expected. If output equals "symbol", then logits of the transmitted constellation points are expected.

One of:

Outputs:

  • llr – […, num_streams, num_bits_per_symbol], torch.float. LLRs or hard-decisions for every bit of every stream, if output equals "bit".

  • logits – […, num_streams, num_points], torch.float or […, num_streams], torch.int32. Logits or hard-decisions for constellation symbols for every stream, if output equals "symbol". Hard-decisions correspond to the symbol indices.

Parameters:

Examples

detector = MMSEPICDetector(
    output="bit",
    demapping_method="maxlog",
    num_iter=3,
    constellation_type="qam",
    num_bits_per_symbol=4
)
llr = detector(y, h, s, prior)
On this page

This Page