The link object is used to represent the physical connection (i.e., propagation) between one device object and another.

$\hat{\mathbf{s}} = \mathbf{W}^{*} \left( \sqrt{P_{\mathrm{tx}}} \cdot \underbrace{G \cdot \mathbf{H}}_{\mathrm{link}} \mathbf{F} \mathbf{s} + \mathbf{n} \right)$

Propagation from one device to another is modeled by two components, as evidenced by common MIMO formulations:

a channel matrix $\mathbf{H}$
a large-scale gain $G$

The link object uses a channel object—more likely, one of its subclasses—to handle generation of the channel matrix $\mathbf{H}$ .

The link object uses a path_loss object—again, one of its subclasses—to handle generation of the large-scale gain $G$ .

In general, it may be the case that the channel and large-scale gain between two devices is not symmetric—or reciprocal—meaning that the link observered in one direction from the first device to the second is not necessarily the link observed from the second device to the first. This can be due to a variety of factors including separate arrays used for transmission and reception or separate bands for uplink and downlink, for example.

To capture this assymetry, the link object actually contains two links:

a forward link
a reverse link

To define these two links, we must also introduce the nomenclature for the two devices connected by a link:

a “head” device
a “tail” device

The head of the link is a device with transmit capability—either a transmitter or a transceiver. The tail of the link is a device with receive capability—either a receiver or transceiver.

If both devices only had transmit capability or only had receive capability, a physical link may exist but would be immaterial. This motivates our “head” and “tail” conventions.

An example of a link between two transceivers.

The forward link is defined as from the head to the tail and always has some practical meaning given the fact that the head can transmit and the tail can receive.

The reverse link is defined as from the tail to the head but only has a a practical meaning if both the head and the tail are transceivers.

Propagation between two devices is largely characterized by the carrier frequency of the signal propagating from one device to the other. In some cases, the link is “symmetric”—or “reciprocal”—where a signal going from one device to the other sees the same environment as if it had traveled in the reverse fashion. This is common for time-division duplex systems where transmission by two devices takes place on the same frequency resources (with sufficient stationarity) and thus experiences symmetric transmit and receive channels.

Creating a Link

A link object can be created in the follow fashion

lnk = link.create(head,tail)

where head is a device object with transmit capability and tail is a device object with receive capability.

Key Properties

A link object lnk contains the following important properties, among others.

The head and tail devices are captured by

lnk.head
lnk.tail

The channel object representing the channel model used on the forward link is

lnk.channel_forward

The channel object representing the channel model used on the reverse link is

lnk.channel_reverse

The actual channel matrices for the forward and reverse links, respectively, are stored in

lnk.channel_matrix_forward
lnk.channel_matrix_reverse

The path_loss object representing the path loss model used on the forward link is

lnk.path_loss_forward

The path_loss object representing the path loss model used on the reverse link is

lnk.path_loss_reverse

The large-scale gain on the forward link—which is a product of lnk.path_loss_forward—is

lnk.large_scale_gain_foward

and likewise the large-scale gain on the reverse link is

lnk.large_scale_gain_reverse

The distance of the link in meters—the separation of the head and tail devices—is critical to most path loss models and is stored in

lnk.distance

and is automatically calculated based on the locations of the head and tail devices.

Symmetric Forward and Reverse Channels

Sometimes it is the case that the forward and reverse channels should be symmetric, meaning reverse channel matrix is equal to the Hermitian of the forward channel matrix.

To achieve this, simply use

lnk.set_channel_symmetric(true)

which will be reflected in the property

lnk.channel_symmetric

Note that this is only possible when the transmit and receive arrays at the head are equal in size and likewise at the tail (and the head and tail are both transceivers). This is often the case in practical transceivers since the same antennas are used for transmission and reception.

This will ensure that lnk.channel_matrix_forward is always the Hermitian of lnk.channel_matrix_reverse.

Symmetric Forward and Reverse Path Loss

Sometimes it is the case that the forward and reverse path losses should be symmetric, meaning reverse path loss (and thus the reverse large-scale gain) is equal to that of the forward link.

To achieve this, simply use

lnk.set_path_loss_symmetric(true)

which will be reflected in the property

lnk.path_loss_symmetric

This will ensure that lnk.large_scale_gain_forward is always equal to lnk.large_scale_gain_reverse.

Setting the Forward and Reverse Channel Models

To set the channel model used on the forward and reverse links of a link object lnk, use

lnk.set_channel(chan_fwd,chan_rev)

where chan_fwd and chan_rev are channel objects to use on the forward and reverse links, respectively. Note that chan_fwd and chan_rev can be different channel models if desired.

To set the forward and reverse links to use the same channel model—but not necessarily the same realizations—a simpler method is

lnk.set_channel(chan)

where chan is of course a channel object.

Note that, in all cases, the channel objects that are passed to the link are deep copied before using them, meaning the same chan, chan_fwd, and chan_rev can be used when setting multiple links if desired.

Also, note that the transmit and receive arrays of the head and tail devices are automatically used to set up the forward and reverse channel objects.

Setting the Forward and Reverse Path Loss Models

To set the path loss model used on the forward and reverse links of a link object lnk, use

lnk.set_channel(path_fwd,path_rev)

where path_fwd and path_rev are path_loss objects to use on the forward and reverse links, respectively. Note that path_fwd and path_rev can be different path loss models if desired.

To set the forward and reverse links to use the same path loss model—but not necessarily the same realizations—a simpler method is

lnk.set_path_loss(path)

where path is of course a path_loss object.

Note that, in all cases, the path_loss objects that are passed to the link are deep copied before using them, meaning the same path, path_fwd, and path_rev can be used when setting multiple links if desired.

Forward and Reverse SNR

A link object lnk also has properties

lnk.snr_forward
lnk.snr_reverse

which are “large-scale” signal-to-noise ratios (SNRs) defined as

$\mathrm{SNR}_{\mathrm{fwd}} = \frac{P_{\mathrm{tx,head}} \cdot G_{\mathrm{fwd}}^2}{\sigma_{\mathrm{n,tail}}^2} \\ \mathrm{SNR}_{\mathrm{rev}} = \frac{P_{\mathrm{tx,tail}} \cdot G_{\mathrm{rev}}^2}{\sigma_{\mathrm{n,head}}^2}$

where $P_{\mathrm{tx,head}}$ and $P_{\mathrm{tx,tail}}$ are the transmit energy per symbol at the head and tail devices, respectively; $G_{\mathrm{fwd}}$ and $G_{\mathrm{rev}}$ are the forward and reverse large-scale gains, respectively; and $\sigma_{\mathrm{n,head}}^2$ and $\sigma_{\mathrm{n,tail}}^2$ are the noise energy per symbol at the receiver of the head and tail devices, respectively.

Note that the reverse link SNR is only applicable when the head and tail devices are both transceivers.

Setting the Forward and Reverse SNR

It is common in MIMO research to evaluate performance for various large-scale SNR values.

Rather than force the user to find a triplet of transmit power, distance/path loss, and noise power to achieve a desired SNR, the user can force the SNR on a link to be a desired value using

lnk.set_snr(snr_fwd,snr_rev,unit)

where snr_fwd and snr_rev are large-scale SNR values and unit is an optional string to specify the units of snr_fwd and snr_rev. If snr_rev = [], then snr_fwd will be set on the forward and reverse links.

For example, to set the large-scale SNR to 10 dB on the forward and reverse links, one would use

lnk.set_snr(10,[],'dB')

The set_snr function adjusts the large-scale gain $G$ to be achieve a desired $\mathrm{SNR}$ based on the transmit energy per symbol and noise energy per symbol. Thus, to use this method, it is essential that the transmit energy per symbol and noise energy per symbol be set as desired and that the path loss not overwrite the newly set large-scale gain.

List of Properties

The link object contains the following properties:

link.name
link.head
link.tail
link.channel_symmetric
link.channel_forward
link.channel_reverse
link.channel_matrix_forward
link.channel_matrix_reverse
link.large_scale_gain_forward
link.large_scale_gain_reverse
link.path_loss_forward
link.path_loss_reverse
link.path_loss_symmetric
link.snr_forward
link.snr_reverse
link.distance
link.line_style
link.color

List of Methods

The link object contains the following methods:

link.compute_channel_state_information Constrcuts a struct containing channel state information for the forward and reverse links.
link.compute_channel_state_information_forward Constrcuts a struct containing channel state information for the forward link.
link.compute_channel_state_information_reverse Constrcuts a struct containing channel state information for the reverse link.
link.compute_covariance_forward Computes the covariance of the received symbols at the tail device from the head device. Also returns the covariance of received noise.
link.compute_covariance_reverse Computes the covariance of the received symbols at the head device from the tail device. Also returns the covariance of received noise.
link.compute_link_budget Returns a struct of values used for a link budget, in log-scale (e.g., dB, dBm), of the forward link and reverse link.
link.compute_link_budget_forward Returns a struct of values used for a link budget, in log-scale (e.g., dB, dBm), of the forward link.
link.compute_link_budget_reverse Returns a struct of values used for a link budget, in log-scale (e.g., dB, dBm), of the reverse link.
link.compute_received_signal Computes the received signal on the forward link and reverse link.
link.compute_received_signal_forward Computes the received signal at the tail device from the head device.
link.compute_received_signal_reverse Computes the received signal at the head device from the tail device.
link.configure_receiver Configures each device’s receiver according to the current/specified receive strategy, incorporating channel state information as applicable.
link.configure_transmitter Configures each device’s transmitter according to the current/specified transmit strategy, incorporating channel state information as applicable.
link.create Creates a link between two devices: a head device (which has transmit capability) and a tail device (which has receive capability).
link.initialize Executes intialization steps to set up a link.
link.isbidirectional Returns a boolean indicating if the link is bidirectional (i.e., if the head device has receive capability and the tail device has transmit capability).
link.link Creates an instance of a link object.
link.realization Invokes a complete realization of the link.
link.realization_channel Invokes a channel realization on the forward and reverse links.
link.realization_channel_forward Invokes a realization of the forward channel and sets the forward channel matrix.
link.realization_channel_reverse Invokes a realization of the reverse channel and sets the reverse channel matrix. If the channel is set to symmetric, the reverse channel will be set to the conjugate transpose of the current forward channel matrix instead of invoking a realization of the reverse channel. Therefore, a forward channel realization should be invoked before a reverse channel realization if the channel is symmetric.
link.realization_path_loss Invokes a realization fo the forward and reverse path loss.
link.realization_path_loss_forward Invokes a realization of the path loss model on the forward link.
link.realization_path_loss_reverse Invokes a realization of the path loss model on the reverse link. If the link is set to have symmetric path loss, the current forward path loss is used.
link.report_mutual_information_forward Reports the Gaussian mutual information achieved between the head and tail devices based on the current link realization and transmit-receive configurations. Returns the mutual information in bps/Hz. Discards any residual imaginary component.
link.report_mutual_information_reverse Reports the Gaussian mutual information achieved between the tail and head devices based on the current link realization and transmit-receive configurations. Returns the mutual information in bps/Hz. Discards any residual imaginary component.
link.report_symbol_estimation_error_forward Returns the squared-error in the estimated receive symbol at the tail compared to the transmit symbol at the head.
link.report_symbol_estimation_error_reverse Returns the squared-error in the estimated receive symbol at the head compared to the transmit symbol at the tail.
link.set_arrays Sets the transmit and receive arrays at the head and tail devices.
link.set_carrier_frequency Sets the carrier frequency of the link. Also sets the carrier frequency of the head and tail devices.
link.set_channel Sets the channel used on the forward and reverse channels.
link.set_channel_forward Sets the channel used on the forward link.
link.set_channel_matrices Sets the forward and reverse channel matrices.
link.set_channel_matrix_forward Sets the channel matrix of the forward link.
link.set_channel_matrix_reverse Sets the channel matrix of the reverse link.
link.set_channel_reverse Sets the channel used on the reverse link.
link.set_channel_symmetric Sets the symmetry of the forward and reverse channels. Note that this is only possible if the transmit array and receive array at the head are equal in size and likewise at the tail.
link.set_color Sets the color used when plotting the link.
link.set_distance Sets the distance of the link (in meters).
link.set_duplexing Sets the duplexing method at the head and tail devices.
link.set_head Sets the head device of the link.
link.set_large_scale_gain Sets the large-scale gain of the forward and reverse links to the same value.
link.set_large_scale_gain_forward Sets the large-scale gain of the forward link.
link.set_large_scale_gain_reverse Sets the large-scale gain of the reverse link.
link.set_line_style Sets the line style used when plotting the link.
link.set_marker Sets the marker used by the head and tail devices.
link.set_name Sets the name of the link.
link.set_noise_power_per_Hz Sets the noise power per Hz at the receiver of the head and tail devices.
link.set_num_rf_chains Sets the number of transmit and receive RF chains at the head and tail devices.
link.set_num_streams Sets the number of streams at the head and tail devices.
link.set_path_loss Sets the path loss model used on the link.
link.set_path_loss_forward Sets the path loss model used on the forward link.
link.set_path_loss_reverse Sets the path loss model used on the reverse link.
link.set_path_loss_symmetric Sets the symmetry of the forward and reverse path loss.
link.set_propagation_velocity Sets the propagation velocity of the link. Also sets the propagation velocity of the head and tail devices.
link.set_receive_strategy Sets the receive strategy to use at the head and tail devices.
link.set_snr Sets the SNR of the forward and reverse links.
link.set_snr_forward Sets the SNR of the forward link.
link.set_snr_reverse Sets the SNR of the reverse link.
link.set_symbol_bandwidth Sets the symbol bandwidth at the head and tail devices.
link.set_tail Sets the tail device of the link.
link.set_transmit_power Sets the transmit power at the transmitter of the head and tail devices.
link.set_transmit_strategy Sets the transmit strategy to use at the head and tail devices.
link.set_transmit_symbol Sets the transmit symbol at the head and tail devices.
link.set_transmit_symbol_covariance Sets the transmit covariance of the device.
link.show_2d Displays the link in 2-D.
link.show_3d Displays the link in 3-D.

`compute_channel_state_information()`

Constrcuts a struct containing channel state information for the forward and reverse links.

Usage:: [csi_forward,csi_reverse] = compute_channel_state_information()
Return Values:: csi_forward — a struct containing CSI values for the forward link; csi_reverse — a struct containing CSI values for the reverse link

On This Page

Creating a Link

Key Properties

Symmetric Forward and Reverse Channels

Symmetric Forward and Reverse Path Loss

Setting the Forward and Reverse Channel Models

Setting the Forward and Reverse Path Loss Models

Forward and Reverse SNR

Setting the Forward and Reverse SNR

List of Properties

List of Methods

compute_channel_state_information()

compute_channel_state_information_forward()

compute_channel_state_information_reverse()

compute_covariance_forward()

compute_covariance_reverse()

compute_link_budget()

compute_link_budget_forward()

compute_link_budget_reverse()

compute_received_signal()

compute_received_signal_forward()

compute_received_signal_reverse()

configure_receiver(strategy)

configure_transmitter(strategy)

create(head,tail)

initialize()

isbidirectional()

link(head,tail)

realization()

realization_channel()

realization_channel_forward()

realization_channel_reverse()

realization_path_loss()

realization_path_loss_forward()

realization_path_loss_reverse()

report_mutual_information_forward()

report_mutual_information_reverse()

report_symbol_estimation_error_forward()

report_symbol_estimation_error_reverse()

set_arrays(transmit_array,receive_array)

set_carrier_frequency(fc)

set_channel(channel_forward,channel_reverse)

set_channel_forward(channel)

set_channel_matrices(H_forward,H_forward)

set_channel_matrix_forward(H)

set_channel_matrix_reverse(H)

set_channel_reverse(channel)

set_channel_symmetric(symmetric)

set_color(color)

set_distance(d)

set_duplexing(duplex)

set_head(head)

set_large_scale_gain(G_forward,G_reverse)

set_large_scale_gain_forward(G)

set_large_scale_gain_reverse(G)

set_line_style(line_style,(dashed), ')

set_marker(marker_head,marker_tail)

set_name(name)

set_noise_power_per_Hz(noise_psd,unit)

set_num_rf_chains(Lt,Lr)

set_num_streams(num_streams)

set_path_loss(path_loss_forward,path_loss_reverse)

set_path_loss_forward(path_loss)

set_path_loss_reverse(path_loss)

set_path_loss_symmetric(symmetric)

set_propagation_velocity(vel)

set_receive_strategy(strategy)

set_snr(snr_forward,snr_reverse)

set_snr_forward(snr,unit)

set_snr_reverse(snr,unit)

set_symbol_bandwidth(B)

set_tail(head)

set_transmit_power(P,unit)

set_transmit_strategy(strategy)

set_transmit_symbol(s)

set_transmit_symbol_covariance(Rs)

show_2d(fignum)

show_3d(fignum)

Source

`compute_channel_state_information()`

`compute_channel_state_information_forward()`

`compute_channel_state_information_reverse()`

`compute_covariance_forward()`

`compute_covariance_reverse()`

`compute_link_budget()`

`compute_link_budget_forward()`

`compute_link_budget_reverse()`

`compute_received_signal()`

`compute_received_signal_forward()`

`compute_received_signal_reverse()`

`configure_receiver(strategy)`

`configure_transmitter(strategy)`

`create(head,tail)`

`initialize()`

`isbidirectional()`

`link(head,tail)`

`realization()`

`realization_channel()`

`realization_channel_forward()`

`realization_channel_reverse()`

`realization_path_loss()`

`realization_path_loss_forward()`

`realization_path_loss_reverse()`

`report_mutual_information_forward()`

`report_mutual_information_reverse()`

`report_symbol_estimation_error_forward()`

`report_symbol_estimation_error_reverse()`

`set_arrays(transmit_array,receive_array)`

`set_carrier_frequency(fc)`

`set_channel(channel_forward,channel_reverse)`

`set_channel_forward(channel)`

`set_channel_matrices(H_forward,H_forward)`

`set_channel_matrix_forward(H)`

`set_channel_matrix_reverse(H)`

`set_channel_reverse(channel)`

`set_channel_symmetric(symmetric)`

`set_color(color)`

`set_distance(d)`

`set_duplexing(duplex)`

`set_head(head)`

`set_large_scale_gain(G_forward,G_reverse)`

`set_large_scale_gain_forward(G)`

`set_large_scale_gain_reverse(G)`

`set_line_style(line_style,(dashed), ')`

`set_marker(marker_head,marker_tail)`

`set_name(name)`

`set_noise_power_per_Hz(noise_psd,unit)`

`set_num_rf_chains(Lt,Lr)`

`set_num_streams(num_streams)`

`set_path_loss(path_loss_forward,path_loss_reverse)`

`set_path_loss_forward(path_loss)`

`set_path_loss_reverse(path_loss)`

`set_path_loss_symmetric(symmetric)`

`set_propagation_velocity(vel)`

`set_receive_strategy(strategy)`

`set_snr(snr_forward,snr_reverse)`

`set_snr_forward(snr,unit)`

`set_snr_reverse(snr,unit)`

`set_symbol_bandwidth(B)`

`set_tail(head)`

`set_transmit_power(P,unit)`

`set_transmit_strategy(strategy)`

`set_transmit_symbol(s)`

`set_transmit_symbol_covariance(Rs)`

`show_2d(fignum)`

`show_3d(fignum)`