Receiver · MFM

Subclasses: Hybrid Digital/Analog Receiver

About
Creating a Receiver
Key Properties
Setting the Number of Receive Streams
Setting the Symbol Bandwidth
Setting the Noise Power
Example Setup
Setting the Received Signal
Setting/Realizing Noise
Setting the Combiner
Getting the Receive Symbol
Shorthand Methods
List of Properties
List of Methods
Methods Documentation

About

The receiver object captures the properties and responsibilities of reception—the estimation of a symbol vector. Its primary responsibility lay in introducing additive noise and executing MIMO combining to retrieve a symbol vector from a captured received signal vector.

The $N_{\mathrm{s}} \times 1$ received symbol vector $\hat{\mathbf{s}}$ after applying the receiver’s combiner can be written as

$\hat{\mathbf{s}} = \mathbf{W}^{*} (\mathbf{y} + \mathbf{n})$

where $\mathbf{y}$ is the $N_{\mathrm{r}} \times 1$ complex received signal vector striking the receive array, $\mathbf{n}$ is the $N_{\mathrm{r}} \times 1$ complex noise vector added per-antenna, and $\mathbf{W}$ is the $N_{\mathrm{r}} \times N_{\mathrm{s}}$ combining matrix.

The receiver object is used to represent the portion of a device responsible for reception, including MIMO combining.

The receiver object is responsible for incorporating additive noise (which, in practice, is primarily introduced and amplified by components in the receive chain). Currently, MFM only supports additive white Gaussian noise (AWGN) introduced i.i.d. per-antenna.

Creating a Receiver

To create a receiver object rx, a convenient way is to use

rx = receiver.create();

Key Properties

The combining matrix $\mathbf{W}$ of a receiver object rx is captured by the property

rx.combiner

Its receive symbol $\hat{\mathbf{s}}$ is represented by

rx.receive_symbol

The symbol bandwidth $B$ (in Hz) and symbol period $T$ (in seconds) are captured by

rx.symbol_bandwidth
rx.symbol_period

The noise power spectral density (in watts per Hz) is captured by

rx.noise_power_per_Hz

The integrated noise power (in watts) is captured by

rx.noise_power

The noise energy per symbol (in joules) is captured by

rx.noise_energy_per_symbol

Setting the Number of Receive Streams

To set the number of streams multiplexed at the receiver $N_{\mathrm{s}}$ , one can use

rx.set_num_streams(Ns)

where the number of streams Ns should be a positive integer.

Setting the Symbol Bandwidth

To set the symbol bandwidth at a receiver rx, use

rx.set_symbol_bandwidth(B)

where B is the symbol bandwidth in Hz.

This automatically updates the receiver’s symbol period according to

$B = T^{-1}$

Setting the Noise Level

Additive noise is introduced per-antenna. Currently, only Gaussian noise is supported in MFM. The noise vector $\mathbf{n}$ is drawn from the complex Gaussian distribution as

$\mathbf{n} \sim \mathcal{N}_{\mathbb{C}}(\mathbf{0},\sigma_{\mathrm{n}}^2 \cdot \mathbf{I})$

where $\sigma_{\mathrm{n}}^2$ is the noise energy per symbol (in joules).

Rather than set the noise energy per symbol directly, it is more practical to set the noise power spectral density and symbol bandwidth, which togther define the noise power and noise energy per symbol.

To set the noise power spectral density of the additive noise at receiver object rx, use

rx.set_noise_power_per_Hz(noise_psd,unit)

where noise_psd is the noise power per Hz and unit is an optional string specifying the units of noise_psd (default of watts per Hz).

For example, to set the noise power spectral density to -174 dBm/Hz, used

rx.set_noise_power_per_Hz(-174,'dBm_Hz')

Based on the current symbol bandwidth, this will automatically update the noise energy per symbol and noise power properties.

Since MFM assumes the relationship $B = T^{-1}$ , the noise power spectral density (power per Hz) is equal to the noise energy per symbol.

The noise power (in watts) is equal to the noise power spectral density times the bandwidth as

$\sigma_{\mathrm{n}}^2 \cdot B$

Example Setup

Setting up a receiver object rx typically looks something similar to

rx = receiver.create()
rx.set_num_streams(Ns)
rx.set_symbol_bandwidth(B)
rx.set_noise_power_per_Hz(noise_psd,unit)

Setting the Received Signal

To set the received signal vector $\mathbf{y}$ striking the receive array, use

rx.set_received_signal(y)

Setting/Realizing Noise

A new noise vector $\mathbf{n}$ can be realized, according to the current noise level, via

rx.set_noise()

which is reflected in the property rx.noise.

If desired, the noise vector can be set manually to a vector n via

rx.set_noise(n)

Setting the Combiner

To set the combiner $\mathbf{W}$ of a receiver, use

rx.set_combiner(W)

where W is a combining matrix.

Getting the Receive Symbol

The receive symbol $\hat{\mathbf{s}}$ can be fetched via

s = rx.get_receive_symbol()

where s is the receive symbol vector.

List of Properties

The receiver object contains the following properties:

receiver.name
receiver.type
receiver.array
receiver.num_antennas
receiver.num_streams
receiver.symbol_bandwidth
receiver.symbol_period
receiver.combiner
receiver.noise
receiver.received_signal
receiver.receive_symbol
receiver.channel_state_information
receiver.noise_power
receiver.noise_energy_per_symbol
receiver.noise_power_per_Hz
receiver.noise_covariance
receiver.receive_strategy
receiver.source

List of Methods

The receiver object contains the following methods:

receiver.N0 Returns the noise energy per symbol.
receiver.Nr Returns the number of receive antennas.
receiver.Ns Returns the number of streams.
receiver.Rn Returns the noise covariance matrix.
receiver.W Returns the combining matrix.
receiver.check_combiner_dimensions Checks to see if the combining matrix has dimensions appropriate for the current number of antennas and streams.
receiver.check_receive_strategy Returns a boolean indicating if a receive strategy is valid.
receiver.configure_receiver Configures the receiver’s combiner according to the current/specified receive strategy, incorporating channel state information as applicable.
receiver.configure_receiver_eigen Configures the receiver to receive along the strongest components of the desired channel, neglecting interference, etc.
receiver.configure_receiver_identity Configures the receive combiner to an identity matrix.
receiver.configure_receiver_mmse_desired Configures the receiver in an LMMSE fashion to reject noise. Does not reject interference.
receiver.configure_receiver_mmse_interference Configures the receiver in an LMMSE fashion to reject noise and interference.
receiver.create Creates a receiver.
receiver.get_receive_symbol Returns the receive symbol based on the curent received signal vector, noise, and combiner.
receiver.get_source_channel_state_information_index Returns the index of the receive CSI entry whose transmit device corresponds to the receiver’s source device.
receiver.get_valid_receive_strategies Returns a cell containing all valid receive strategy strings.
receiver.initialize Executes initializations for a receiver.
receiver.n Returns the noise vector (per-antenna).
receiver.parse_channel_state_information Splits the CSI into two components: (i) a struct containing CSI for receiving from the source and (ii) a cell of structs containing CSI for all other links (e.g., interference channels).
receiver.receiver Creates an instance of a receiver object.
receiver.s Returns the receive symbol vector.
receiver.set_array Sets the receiver’s array object and updates the number of receive antennas.
receiver.set_channel_state_information Sets the receive channel state information (CSI).
receiver.set_combiner Sets the receive combining matrix.
receiver.set_name Sets the name of the receiver.
receiver.set_noise Sets the noise vector at the receive array.
receiver.set_noise_covariance Sets the noise covariance matrix.
receiver.set_noise_power_per_Hz Sets the noise power per Hz based for a given noise power spectral density.
receiver.set_num_streams Sets the number of data streams being received.
receiver.set_receive_strategy Sets the receive strategy.
receiver.set_receive_symbol Sets the receive symbol.
receiver.set_received_signal Sets the received signal vector.
receiver.set_source Sets the source (device the receiver aims to serve).
receiver.set_symbol_bandwidth Sets the receive symbol bandwidth.
receiver.set_type Sets the type of the receiver.
receiver.turn_off Turns off the receiver by setting its combiner to a zeros matrix.
receiver.update_noise_covariance Updates the noise covariance matrix based on the current number of antennas and noise power.
receiver.update_noise_power Updates the noise power based on the current noise power per Hz and symbol bandwidth.
receiver.update_receive_symbol Updates the receive symbol (after combiner) based on the current received signal and noise.
receiver.y Returns the received signal vector.

Methods Documentation

`N0()`

Returns the noise energy per symbol.

Usage:: val = N0()
Return Values:: val — the noise energy per symbol

On This Page

About

Creating a Receiver

Key Properties

Setting the Number of Receive Streams

Setting the Symbol Bandwidth

Setting the Noise Level

Example Setup

Setting the Received Signal

Setting/Realizing Noise

Setting the Combiner

Getting the Receive Symbol

List of Properties

List of Methods

Methods Documentation

N0()

Nr()

Ns()

Rn()

W()

check_combiner_dimensions(W)

check_receive_strategy(strategy)

configure_receiver(strategy)

configure_receiver_eigen()

configure_receiver_identity()

configure_receiver_mmse_desired()

configure_receiver_mmse_interference()

create(type)

get_receive_symbol()

get_source_channel_state_information_index()

get_valid_receive_strategies()

initialize()

n()

parse_channel_state_information()

receiver(name)

s()

set_array(array)

set_channel_state_information(csi)

set_combiner(W)

set_name(name)

set_noise(n)

set_noise_covariance(Rn)

set_noise_power_per_Hz(noise_psd,unit)

set_num_streams(Ns)

set_receive_strategy(strategy)

set_receive_symbol(s)

set_received_signal(y)

set_source(device_source)

set_symbol_bandwidth(B)

set_type(type)

turn_off()

update_noise_covariance()

update_noise_power()

update_receive_symbol()

y()

`N0()`

`Nr()`

`Ns()`

`Rn()`

`W()`

`check_combiner_dimensions(W)`

`check_receive_strategy(strategy)`

`configure_receiver(strategy)`

`configure_receiver_eigen()`

`configure_receiver_identity()`

`configure_receiver_mmse_desired()`

`configure_receiver_mmse_interference()`

`create(type)`

`get_receive_symbol()`

`get_source_channel_state_information_index()`

`get_valid_receive_strategies()`

`initialize()`

`n()`

`parse_channel_state_information()`

`receiver(name)`

`s()`

`set_array(array)`

`set_channel_state_information(csi)`

`set_combiner(W)`

`set_name(name)`

`set_noise(n)`

`set_noise_covariance(Rn)`

`set_noise_power_per_Hz(noise_psd,unit)`

`set_num_streams(Ns)`

`set_receive_strategy(strategy)`

`set_receive_symbol(s)`

`set_received_signal(y)`

`set_source(device_source)`

`set_symbol_bandwidth(B)`

`set_type(type)`

`turn_off()`

`update_noise_covariance()`

`update_noise_power()`

`update_receive_symbol()`

`y()`