# Hybrid Digital/Analog Transmitter

*A MIMO transmitter employing hybrid digital/analog precoding.*

`obj/transmitter/transmitter_hybrid.m`

Superclass: Transmitter

#### On This Page

- About
- Creating a Hybrid Digital/Analog Transmitter
- Key Properties
- Limited Phase Control
- Limited Amplitude Control
- Connected-ness of the Hybrid Transmitter
- Example Setup
- Digital Precoding Power Budget
- Setting the Digital Precoder
- Setting the Analog Precoder
- Shorthand Methods
- List of Properties
- List of Methods
- Methods Documentation

### About

The `transmitter_hybrid`

object captures transmission from a hybrid digital/analog precoding transmitter. In addition to that of the `transmitter`

object, a `transmitter_hybrid`

object is responsible for achieving transmission via the combination of digital and analog precoding (rather than solely digital precoding like in the `transmitter`

object).

The signal vector leaving the hybrid transmitter and entering the channel can be written as

where is the complex transmit symbol vector, is the analog precoding matrix, is the digital precoding matrix, and is the transmit energy per symbol.

Digital precoding—represented by the matrix —takes place in the digital domain at baseband (hence “BB”).

Analog precoding—represented by the matrix —takes place in the analog domain via a network of phase shifters and possibly attenuators at radio frequency (hence “RF”).

This staged approach to precoding is common for practical transceivers with many antennas (e.g., massive MIMO, millimeter-wave communication) to reduce the number of costly and power hungry RF chains while still supplying high beamforming gains and supporting spatial multiplexing.

Transmit symbols are mixed with the digital precoding matrix before being physically realized by RF chains. In order to support spatial multiplexing of streams, it should be such that

The signals from each RF chain are then distributed throughout the analog precoding network—how this is done varies depending on the architecture.

### Creating a Hybrid Digital/Analog Transmitter

To create a hybrid digital/analog transmitter, a convenient way is to use

```
tx = transmitter.create('hybrid')
```

This will instantiate a `transmitter_hybrid`

object, which is inherited from the `transmitter`

object definition.

As such, the `transmitter_hybrid`

object inherits all properties and methods of the `transmitter`

object. However, some methods are overwritten in the `transmitter_hybrid`

object definition to appropriately accommodate the nature of hybrid digital/analog beamforming.

### Key Properties

A `transmitter_hybrid`

object inherits all properties of the `transmitter`

object. We summarize the key properties of such as follows; please see documentation on the `transmitter`

object for more details.

```
tx.precoder
tx.transmit_symbol
tx.transmit_power
tx.symbol_bandwidth
tx.symbol_period
tx.array
```

Naturally, the biggest difference between a fully-digital `transmitter`

object and a hybrid digital/analog `transmitter_hybrid`

object lay in precoding. Recall, however, the effective precoding matrix of a hybrid digital/analog transmitter is the product of its digital and analog precoders.

To capture the digital precoding matrix and the analog precoding matrix , the `transmitter_hybrid`

object has the following properties

```
tx.precoder_digital
tx.precoder_analog
```

Their product is captured by the inherited property

```
tx.precoder
```

from the `transmitter`

object.

Capturing the number of RF chains at the hybrid transmitter is the property

```
tx.num_rf_chains
```

It is common for practical analog beamforming networks to be controlled digitally using limited-resolution phase shifters and attenuators. To capture this, MFM’s `transmitter_hybrid`

object has the following properties

```
tx.precoder_analog_phase_resolution_bits
tx.precoder_analog_amplitude_resolution_bits
tx.precoder_analog_amplitude_quantization_law
```

As their names suggest `tx.precoder_analog_phase_resolution_bits`

and `tx.precoder_analog_amplitude_resolution_bits`

are the number of bits used to control each phase shifter and each attenuator, respectively. The property `tx.precoder_analog_amplitude_quantization_law`

provides some freedom in how MFM captures finite-resolution attenuators. We discuss more on phase and amplitude control in Limited Phase Control and Limited Amplitude Control.

### Limited Phase Control

To set the number of bits used to configure each phase shifter in the analog beamforming network to `bits`

, use

```
tx.set_precoder_analog_amplitude_resolution_bits(bits)
```

MFM assumes uniform phase shifter quantization, meaning the phases it can implement are on the range with step size , where each phase shifter has bits of phase control.

To check to see if an analog precoding matrix `F_RF`

satisfies the phase contraints of the hybrid transmitter’s analog beamforming network, one can use

```
out = check_precoder_analog_phase_constraint(F_RF)
```

where `out`

is `true`

if satisfied and `false`

if any entries of `F_RF`

violate the phase constraints.

It is also common in academic research to assume phase shifters can take on any value to remove the impact of having limited phase resolution. To realize this in MFM, simply use

```
tx.set_precoder_analog_amplitude_resolution_bits(Inf)
```

This removes any phase constraint on the entries of the analog precoder.

### Limited Amplitude Control

To set the number of bits used to configure each attenuator in the analog beamforming network to `bits`

, use

```
tx.set_precoder_analog_amplitude_resolution_bits(bits)
```

To capture the case where there are no attenuators in the analog precoding network, use

```
tx.set_precoder_analog_amplitude_resolution_bits(0)
```

which will impose a unit amplitude constraint on the entries of the analog precoding matrix.

To capture the case where the attenuators are not faced with amplitude quantization, use

```
tx.set_precoder_analog_amplitude_resolution_bits(Inf)
```

which allows the magnitude of the entries of the analog precoding matrix to take on any value between .

In a similar fashion, MFM assumes uniform attenuator quantization offers users two options: linear quantization or logarithmic quantization.

### Connected-ness of the Hybrid Transmitter

Fully-connected architectures, for example, supply each transmit antenna with a weighted version of each RF chain’s signal. In other words, each RF chain is connected to each antenna.

Partially-connected architectures, on the other hand, only supply certain transmit antennas (often groups of antennas) with a weighted version of the signals from certain RF chains.

The connected-ness of a hybrid digital/analog architecture is reflected by the structure of the analog precoding matrix . The -th entry is only nonzero if there exists a weighted connection between the -th antenna and the -th RF chain.

To set which RF chains are connected to which antennas, MFM supplies the function

```
tx.set_precoder_hybrid_connections(M)
```

where `M`

is an matrix (like the analog precoding matrix) whose -th entry is `1`

if there exists a weighted connection between the -th antenna and the -th RF chain and `0`

if not.

Fully-connected architectures, which are assumed by default, have an `M`

matrix of all ones.

Sub-array architectures, for example, have an `M`

matrix with a block diagonal of ones.

### Example Setup

A typical `transmitter`

setup looks something similar to

```
tx = transmitter.create()
tx.set_symbol_bandwidth(B)
tx.set_num_streams(Ns)
tx.set_set_array(a)
tx.set_transmit_power(Ptx,'dBm')
```

where `B`

is the bandwidth in Hz, `Ns`

is the number of streams to multiplex, `a`

is an `array`

object, and `Ptx`

is the transmit power in dBm.

After this initial setup, the transmitter `tx`

can be configured to transmit symbol vectors using its precoder.

### Digital Precoding Power Budget

MFM supports the enforcement of a power budget on the digital precoding matrix, similar to what was placed on the precoding matrix in the `transmitter`

.

A digital precoding power budget takes the form

where is the maximum power of the digital precoding matrix.

To set this, use

```
tx.set_precoder_digital_power_budget(P)
```

### Setting the Digital Precoder

The most straightforward way to set the digital precoding matrix is to use

```
tx.set_precoder_digital(F_BB)
```

where `F_BB`

is an precoding matrix; if the precoding matrix is not of appropriate size based on the current number of RF chains and number of streams, MFM will alert the user and it will not set the digital precoder.

### Setting the Analog Precoder

The most straightforward way to set the analog precoding matrix is to use

```
tx.set_precoder_analog(F_RF)
```

where `F_RF`

is an precoding matrix; if the precoding matrix is not of appropriate size based on the current number of antennas and number of RF chains, MFM will alert the user and it will not set the analog precoder.

Additionally, MFM will require that `F_RF`

satisfy the analog precoding constraints associated with phase and amplitude control.

### Shorthand Methods

To provide convenient ways to retrieve common MIMO-related quantities from a `transmitter_hybrid`

object `tx`

, there exist the following so-called shorthand methods.

`tx.F`

— Returns the precoding matrix.`tx.F_RF`

— Returns the analog precoding matrix.`tx.F_BB`

— Returns the digital precoding matrix.`tx.Ns`

— Returns the number of streams.`tx.Lt`

— Returns the number of RF chains.`tx.Nt`

— Returns the number of transmit antennas.`tx.Ptx`

— Returns the transmit energy per symbol (joules per symbol).`tx.Rs`

— Returns the transmit symbol covariance matrix.`tx.s`

— Returns the transmit symbol.`tx.x`

— Returns the signal vector transmitted from the transmitter.

### List of Properties

The `transmitter_hybrid`

object contains the following properties:

`transmitter_hybrid.num_rf_chains`

`transmitter_hybrid.precoder_digital`

`transmitter_hybrid.precoder_analog`

`transmitter_hybrid.precoder_digital_power_budget`

`transmitter_hybrid.precoder_analog_phase_resolution_bits`

`transmitter_hybrid.precoder_analog_amplitude_resolution_bits`

`transmitter_hybrid.precoder_analog_amplitude_quantization_law`

`transmitter_hybrid.precoder_hybrid_connections`

`transmitter_hybrid.name`

`transmitter_hybrid.type`

`transmitter_hybrid.array`

`transmitter_hybrid.num_antennas`

`transmitter_hybrid.num_streams`

`transmitter_hybrid.symbol_bandwidth`

`transmitter_hybrid.symbol_period`

`transmitter_hybrid.transmit_power`

`transmitter_hybrid.transmit_energy_per_symbol`

`transmitter_hybrid.transmitted_signal`

`transmitter_hybrid.transmit_symbol`

`transmitter_hybrid.transmit_symbol_covariance`

`transmitter_hybrid.precoder`

`transmitter_hybrid.precoder_power_budget`

`transmitter_hybrid.channel_state_information`

`transmitter_hybrid.transmit_strategy`

`transmitter_hybrid.destination`

### List of Methods

The `transmitter_hybrid`

object contains the following methods:

`transmitter_hybrid.F`

Returns the precoding matrix.`transmitter_hybrid.F_BB`

Returns the digital precoding matrix.`transmitter_hybrid.F_RF`

Returns the analog precoding matrix.`transmitter_hybrid.Lt`

Returns the number of transmit RF chains.`transmitter_hybrid.Ns`

Returns the number of streams.`transmitter_hybrid.Nt`

Returns the number of transmit antennas.`transmitter_hybrid.P`

Returns the transmit energy per symbol (joules per symbol).`transmitter_hybrid.Ptx`

Returns the transmit energy per symbol (joules per symbol).`transmitter_hybrid.Rs`

Returns the transmit symbol covariance matrix.`transmitter_hybrid.check_precoder_analog_amplitude_constraint`

Checks if the analog precoder has entries whose amplitudes have been quantized to the appropriate resolution.`transmitter_hybrid.check_precoder_analog_dimensions`

Checks to see if the analog precoding matrix has dimensions appropriate for the current number of RF chains and antennas.`transmitter_hybrid.check_precoder_analog_phase_constraint`

Checks if the analog precoder has entries whose phases have been quantized to the appropriate resolution.`transmitter_hybrid.check_precoder_digital_dimensions`

Checks to see if the digital precoding matrix has dimensions appropriate for the current number of RF chains and streams.`transmitter_hybrid.check_precoder_digital_power_budget`

Checks to see if the digital precoding matrix meets the allotted digital precoding power budget.`transmitter_hybrid.check_precoder_dimensions`

Checks to see if the precoding matrix has dimensions appropriate for the current number of antennas and streams.`transmitter_hybrid.check_precoder_hybrid_connections`

Checks to see if the analog precoder satisfies the constraints imposed by the connectivity between antennas and RF chains.`transmitter_hybrid.check_precoder_hybrid_connections_dimensions`

Checks to see if the hybrid connections matrix has dimensions appropriate for the current number of RF chains and antennas.`transmitter_hybrid.check_precoder_hybrid_dimensions`

Checks to see if the analog and digital precoders have appropriate dimensions.`transmitter_hybrid.check_precoder_power_budget`

Checks to see if the precoding matrix meets the allotted precoding power budget.`transmitter_hybrid.check_transmit_strategy`

Returns a boolean indicating if a transmit strategy is valid.`transmitter_hybrid.configure_transmitter`

Configures the transmitter’s precoder according to the current/specified transmit strategy, incorporating channel state information as applicable.`transmitter_hybrid.configure_transmitter_eigen`

Configures the transmitter to transmit along the strongest components of the desired channel, neglecting interference, etc.`transmitter_hybrid.configure_transmitter_identity`

Configures the transmit precoder to an identity matrix.`transmitter_hybrid.create`

Creates a transmitter.`transmitter_hybrid.enforce_precoder_digital_power_budget`

Ensures that the digital precoder is normalized such that the digital precoding power budget is satisfied.`transmitter_hybrid.enforce_precoder_hybrid_connections`

Ensures that the analog precoder is constructed in accordance with the connectivity offered between antennas and RF chains.`transmitter_hybrid.enforce_precoder_power_budget`

Ensures that the digital precoder is normalized such that the total precoding power budget is satisfied.`transmitter_hybrid.get_destination_channel_state_information_index`

Returns the index of the transmit CSI entry whose receive device corresponds to the transmitter’s destination device.`transmitter_hybrid.get_valid_transmit_strategies`

Returns a cell containing all valid transmit strategy strings.`transmitter_hybrid.hybrid_approximation`

Performs hybrid approximation of a fully-digital beamforming matrix based on the hybrid approximation method and any associated options.`transmitter_hybrid.impose_beamformer_power_constraint`

Imposes the power constraint to the digital beamformer such that each stream’s beamformer has Frobenius norm of square root of the number of transmit antennas.`transmitter_hybrid.initialize`

Executes initializations for a transmitter.`transmitter_hybrid.initialize_hybrid`

Executes initializations for a hybrid digital/analog transmitter.`transmitter_hybrid.omp_based_hybrid_approximation`

`transmitter_hybrid.parse_channel_state_information`

Splits the CSI into two components: (i) a struct containing CSI for transmitting to the destination and (ii) a cell of structs containing CSI for all other links (e.g., interference channels).`transmitter_hybrid.s`

Returns the transmit symbol vector.`transmitter_hybrid.set_array`

Sets the transmitter’s array object and updates the number of transmit antennas.`transmitter_hybrid.set_channel_state_information`

Sets the transmit channel state information (CSI).`transmitter_hybrid.set_destination`

Sets the destination (device the transmitter aims to serve).`transmitter_hybrid.set_hybrid_approximation_method`

Sets the method to use during hybrid approximation of a fully-digital beamformer.`transmitter_hybrid.set_name`

Sets the name of the transmitter.`transmitter_hybrid.set_num_rf_chains`

Sets the number of RF chains in the transmitter’s hybrid beamforming structure.`transmitter_hybrid.set_num_streams`

Sets the number of data streams being transmitted.`transmitter_hybrid.set_precoder`

Sets the transmit precoding matrix.`transmitter_hybrid.set_precoder_analog`

Sets the analog precoding matrix.`transmitter_hybrid.set_precoder_analog_amplitude_quantization_law`

Sets the analog precoder’s amlitude quantization law (e.g., linear or log).`transmitter_hybrid.set_precoder_analog_amplitude_resolution_bits`

Sets the resolution (in bits) of the attenuators in the analog precoder.`transmitter_hybrid.set_precoder_analog_phase_resolution_bits`

Sets the resolution (in bits) of the phase shifters in the analog precoder.`transmitter_hybrid.set_precoder_digital`

Sets the digital precoder.`transmitter_hybrid.set_precoder_digital_power_budget`

Sets the power budget of the digital precoding matrix.`transmitter_hybrid.set_precoder_hybrid_connections`

Defines which RF chains are connected to which antennas, allowing for arbitrary hybrid beamforming configurations, including subarray architectures.`transmitter_hybrid.set_precoder_power_budget`

Sets the precoding matrix power budget.`transmitter_hybrid.set_symbol_bandwidth`

Sets the transmit symbol bandwidth.`transmitter_hybrid.set_transmit_power`

Sets the transmit power.`transmitter_hybrid.set_transmit_strategy`

Sets the transmit strategy.`transmitter_hybrid.set_transmit_symbol`

Sets the symbol vector to be transmitted.`transmitter_hybrid.set_transmit_symbol_covariance`

Sets the transmit symbol covariance matrix.`transmitter_hybrid.set_transmitted_signal`

Sets the signal vector that is transmitted (i.e., the signal that exits the transmit array).`transmitter_hybrid.set_type`

Sets the type of the transmitter.`transmitter_hybrid.show_analog_beamformer`

Plots one of the analog beamformers.`transmitter_hybrid.show_effective_beamformer`

Plots one of the effective beamformers (combination of analog and digital).`transmitter_hybrid.transmitter_hybrid`

`transmitter_hybrid.turn_off`

Turns off the transmitter by setting its precoder to a zeros matrix.`transmitter_hybrid.update_precoder`

Updates the effective precoding matrix based on the current analog and digital precoders. Only updates if the dimensionality supports the matrix multiply.`transmitter_hybrid.update_transmit_energy_per_symbol`

Updates the energy per symbol property.`transmitter_hybrid.update_transmitted_signal`

Recomputes the transmitted signal vector.`transmitter_hybrid.x`

Returns the transmitted signal vector.

### Methods Documentation

`F()`

`F()`

Returns the precoding matrix.

- Usage:
`val = F()`

*Return Values*:`val`

— the precoding matrix

`F_BB()`

`F_BB()`

Returns the digital precoding matrix.

- Usage:
`val = F_BB()`

*Return Values*:`val`

— the digital precoding matrix

`F_RF()`

`F_RF()`

Returns the analog precoding matrix.

- Usage:
`val = F_RF()`

*Return Values*:`val`

— the analog precoding matrix

`Lt()`

`Lt()`

Returns the number of transmit RF chains.

- Usage:
`val = Lt()`

*Return Values*:`val`

— the number of transmit RF chains

`Ns()`

`Ns()`

Returns the number of streams.

- Usage:
`val = Ns()`

*Return Values*:`val`

— the number of streams

`Nt()`

`Nt()`

Returns the number of transmit antennas.

- Usage:
`val = Nt()`

*Return Values*:`val`

— the number of transmit antennas

`P()`

`P()`

Returns the transmit energy per symbol (joules per symbol).

- Usage:
`val = P()`

*Return Values*:`val`

— the transmit energy per symbol

`Ptx()`

`Ptx()`

Returns the transmit energy per symbol (joules per symbol).

- Usage:
`val = Ptx()`

*Return Values*:`val`

— the transmit energy per symbol

`Rs()`

`Rs()`

Returns the transmit symbol covariance matrix.

- Usage:
`val = Rs()`

*Return Values*:`val`

— the transmit symbol covariance matrix

`check_precoder_analog_amplitude_constraint(F)`

`check_precoder_analog_amplitude_constraint(F)`

Checks if the analog precoder has entries whose amplitudes have been quantized to the appropriate resolution.

- Usage:
`out = check_precoder_analog_amplitude_constraint()`

`out = check_precoder_analog_amplitude_constraint(F)`

*Input Arguments*:`F`

— (optional) an analog precoding matrix; if not passed, the transmitter’s current analog precoder will be assessed*Return Values*:`out`

— a boolean indicating whether or not the analog amplitude constraint has been met

`check_precoder_analog_dimensions(F)`

`check_precoder_analog_dimensions(F)`

Checks to see if the analog precoding matrix has dimensions appropriate for the current number of RF chains and antennas.

- Usage:
`out = check_precoder_analog_dimensions()`

`out = check_precoder_analog_dimensions(F)`

*Input Arguments*:`F`

— (optional) an analog precoding matrix; if not passed, the transmitter’s current analog precoder will be assessed*Return Values*:`out`

— a boolean indicating if the analog precoder is of appropriate dimension

`check_precoder_analog_phase_constraint(F)`

`check_precoder_analog_phase_constraint(F)`

Checks if the analog precoder has entries whose phases have been quantized to the appropriate resolution.

- Usage:
`out = check_precoder_analog_phase_constraint()`

`out = check_precoder_analog_phase_constraint(F)`

*Input Arguments*:`F`

— (optional) an analog precoding matrix; if not passed, the transmitter’s current analog precoder will be assessed*Return Values*:`out`

— a boolean indicating whether or not the analog phase constraint has been met

`check_precoder_digital_dimensions(F)`

`check_precoder_digital_dimensions(F)`

Checks to see if the digital precoding matrix has dimensions appropriate for the current number of RF chains and streams.

- Usage:
`out = check_precoder_digital_dimensions()`

`out = check_precoder_digital_dimensions(F)`

*Input Arguments*:`F`

— (optional) a digital precoding matrix; if not passed, the transmitter’s current digital precoder will be assessed*Return Values*:`out`

— a boolean indicating if the digital precoder is of appropriate dimension

`check_precoder_digital_power_budget(F_BB)`

`check_precoder_digital_power_budget(F_BB)`

Checks to see if the digital precoding matrix meets the allotted digital precoding power budget.

- Usage:
`out = check_precoder_digital_power_budget()`

`out = check_precoder_digital_power_budget(F_BB)`

*Input Arguments*:`F_BB`

— (optional) a digital precoding matrix; if not passed, the transmitter’s current digital precoding matrix will be assessed*Return Values*:`out`

— a boolean indicating if the digital precoding power budget is met by the current precoding matrix (returns true if met)

`check_precoder_dimensions(F)`

`check_precoder_dimensions(F)`

Checks to see if the precoding matrix has dimensions appropriate for the current number of antennas and streams.

- Usage:
`out = check_precoder_dimensions()`

`out = check_precoder_dimensions(F)`

*Input Arguments*:`F`

— (optional) a precoding matrix; if not passed, the transmitter’s current precoder will be assessed*Return Values*:`out`

— a boolean indicating if the precoder is of appropriate dimension

`check_precoder_hybrid_connections(M,F)`

`check_precoder_hybrid_connections(M,F)`

Checks to see if the analog precoder satisfies the constraints imposed by the connectivity between antennas and RF chains.

- Usage:
`out = check_precoder_hybrid_connections()`

`out = check_precoder_hybrid_connections(M)`

`out = check_precoder_hybrid_connections(M,F)`

`out = check_precoder_hybrid_connections([],F)`

*Input Arguments*:`M`

— (optional) a hybrid connections matrix; if not passed, the transmitter’s current hybrid connections matrix will be used`F`

— (optional) an analog precoding matrix; if not passed, the transmitter’s current analog precoder will be assessed*Return Values*:`out`

— a boolean indicating whether or not the hybrid connections are satisfied by the analog precoder*Notes*:- If the hybrid connections matrix has not been set (is empty), then it is assumed fully-connected hybrid beamforming is employed, meaning the structure of the analog precoder is unconstrained. Thus, out = true.

`check_precoder_hybrid_connections_dimensions(M)`

`check_precoder_hybrid_connections_dimensions(M)`

Checks to see if the hybrid connections matrix has dimensions appropriate for the current number of RF chains and antennas.

- Usage:
`out = check_precoder_hybrid_connections_dimensions()`

`out = check_precoder_hybrid_connections_dimensions(M)`

*Input Arguments*:`M`

— (optional) a hybrid connections matrix; if not passed, the transmitter’s current hybrid connections matrix will be used*Return Values*:`out`

— a boolean indicating if the hybrid connections matrix is of appropriate dimension

`check_precoder_hybrid_dimensions(F_BB,F_RF)`

`check_precoder_hybrid_dimensions(F_BB,F_RF)`

Checks to see if the analog and digital precoders have appropriate dimensions.

- Usage:
`out = check_precoder_hybrid_dimensions()`

`out = check_precoder_hybrid_dimensions(F_BB)`

`out = check_precoder_hybrid_dimensions(F_BB,F_RF)`

`out = check_precoder_hybrid_dimensions([],F_RF)`

`out = check_precoder_hybrid_dimensions(F_BB,[])`

*Input Arguments*:`F_BB`

— (optional) a digital precoding matrix; if not passed, the transmitter’s current digital precoder will be assessed`F_RF`

— (optional) an analog precoding matrix; if not passed, the transmitter’s current analog precoder will be assessed*Return Values*:`out`

— a boolean indicating if the analog and digital precoders have compatible dimensions.

`check_precoder_power_budget(F)`

`check_precoder_power_budget(F)`

Checks to see if the precoding matrix meets the allotted precoding power budget.

- Usage:
`out = check_precoder_power_budget()`

`out = check_precoder_power_budget(F)`

*Input Arguments*:`F`

— (optional) a precoding matrix; if not passed, the transmitter’s current precoding matrix will be assessed*Return Values*:`out`

— a boolean indicating if the precoding power budget is met by the current precoding matrix (returns true if met)

`check_transmit_strategy(strategy)`

`check_transmit_strategy(strategy)`

Returns a boolean indicating if a transmit strategy is valid.

- Usage:
`out = check_transmit_strategy(strategy)`

*Input Arguments*:`strategy`

— a string indentifying a specific transmit strategy*Return Values*:`out`

— a boolean

`configure_transmitter(strategy)`

`configure_transmitter(strategy)`

Configures the transmitter’s precoder according to the current/specified transmit strategy, incorporating channel state information as applicable.

- Usage:
`configure_transmitter()`

`configure_transmitter(strategy)`

*Input Arguments*:`strategy`

— (optional) transmit strategy to use; if not passed, the current transmit strategy will be used

`configure_transmitter_eigen()`

`configure_transmitter_eigen()`

Configures the transmitter to transmit along the strongest components of the desired channel, neglecting interference, etc.

- Usage:
`configure_transmitter_eigen()`

`configure_transmitter_identity()`

`configure_transmitter_identity()`

Configures the transmit precoder to an identity matrix.

- Usage:
`configure_transmitter_identity()`

`create(type)`

`create(type)`

Creates a transmitter.

- Usage:
`obj = transmitter.create()`

`obj = transmitter.create(type)`

*Input Arguments*:`type`

— (optional) a string specifying the type of transmitter to create; either ‘digital’ or ‘hybrid’*Return Values*:`obj`

— a transmitter object

`enforce_precoder_digital_power_budget()`

`enforce_precoder_digital_power_budget()`

Ensures that the digital precoder is normalized such that the digital precoding power budget is satisfied.

- Usage:
`enforce_precoder_digital_power_budget()`

`enforce_precoder_hybrid_connections()`

`enforce_precoder_hybrid_connections()`

Ensures that the analog precoder is constructed in accordance with the connectivity offered between antennas and RF chains.

- Usage:
`enforce_precoder_hybrid_connections()`

*Notes*:- Updates the analog precoder and effective precoder.

`enforce_precoder_power_budget()`

`enforce_precoder_power_budget()`

Ensures that the digital precoder is normalized such that the total precoding power budget is satisfied.

- Usage:
`enforce_precoder_power_budget()`

*Notes*:- Supersedes the function with the same name in the parent in order to only scale the digital precoding portion.

`get_destination_channel_state_information_index()`

`get_destination_channel_state_information_index()`

Returns the index of the transmit CSI entry whose receive device corresponds to the transmitter’s destination device.

- Usage:
`idx = get_destination_channel_state_information_index()`

*Return Values*:`idx`

— an index; if zero, the CSI entry was not found

`get_valid_transmit_strategies()`

`get_valid_transmit_strategies()`

Returns a cell containing all valid transmit strategy strings.

- Usage:
`out = get_valid_transmit_strategies()`

*Return Values*:`out`

— a cell of strings*Notes*:- This function will differ between a fully-digital transmitter and hybrid digital/analog transmitter to account for transmit strategies that are specific to each.
- This function will need to be updated anytime a custom/new transmit strategy is added.

`hybrid_approximation(F,opt)`

`hybrid_approximation(F,opt)`

Performs hybrid approximation of a fully-digital beamforming matrix based on the hybrid approximation method and any associated options.

- Usage:
`[X,RF,BB,err] = hybrid_approximation(F,opt)`

*Input Arguments*:`F`

— fully-digital precoding matrix`opt`

— struct of options specific to the hybrid approximation method*Return Values*:`X`

— the effective fully-digital beamforming matrix`RF`

— the resulting analog beamforming matrix`BB`

— the resulting digital beamforming matrix`err`

— the squared Frobenius norm of the error in hyrbrid approximation*Notes*:- The analog and digital precoders are set after approximation.

`impose_beamformer_power_constraint()`

`impose_beamformer_power_constraint()`

Imposes the power constraint to the digital beamformer such that each stream’s beamformer has Frobenius norm of square root of the number of transmit antennas.

- Usage:
`IMPOSE_DIGITAL_BEAMFORMER_POWER_CONSTRAINT()`

`initialize()`

`initialize()`

Executes initializations for a transmitter.

- Usage:
`initialize()`

`initialize_hybrid()`

`initialize_hybrid()`

Executes initializations for a hybrid digital/analog transmitter.

- Usage:
`initialize_hybrid()`

*Notes*:- Should be executed after the default transmitter initialization (transmitter.initialize()).

`omp_based_hybrid_approximation(A,B,C,Nrf,P)`

`omp_based_hybrid_approximation(A,B,C,Nrf,P)`

*Input Arguments*:`A`

— predefined RF beamforming vectors as columns (codebook)`B`

— desired fully-digital beamformer`C`

— identity of size Nt by Nt (eye(Nt)) (covariance matrix E[yy*]?)`Nrf`

— number of RF chains`P`

— power constraint (optional)

`parse_channel_state_information()`

`parse_channel_state_information()`

Splits the CSI into two components: (i) a struct containing CSI for transmitting to the destination and (ii) a cell of structs containing CSI for all other links (e.g., interference channels).

- Usage:
`[csi_des,csi_int] = parse_channel_state_information()`

*Return Values*:`csi_des`

— a CSI struct`csi_int`

— a cell of one or more CSI structs

`s()`

`s()`

Returns the transmit symbol vector.

- Usage:
`val = s()`

*Return Values*:`val`

— the transmit symbol vector

`set_array(array)`

`set_array(array)`

Sets the transmitter’s array object and updates the number of transmit antennas.

- Usage:
`set_array(array)`

*Input Arguments*:`array`

— an array object*Notes*:- Also updates number of antennas based on array.

`set_channel_state_information(csi)`

`set_channel_state_information(csi)`

Sets the transmit channel state information (CSI).

- Usage:
`set_channel_state_information(csi)`

*Input Arguments*:`csi`

— a cell of channel state information structs or a single struct of csi

`set_destination(device_destination)`

`set_destination(device_destination)`

Sets the destination (device the transmitter aims to serve).

- Usage:
`set_destination(device_destination)`

*Input Arguments*:`device_destination`

— a device object

`set_hybrid_approximation_method(method)`

`set_hybrid_approximation_method(method)`

Sets the method to use during hybrid approximation of a fully-digital beamformer.

- Usage:
`set_hybrid_approximation_method(method)`

*Input Arguments*:`method`

— a string declaring which method to use

`set_name(name)`

`set_name(name)`

Sets the name of the transmitter.

- Usage:
`set_name()`

`set_name(name)`

*Input Arguments*:`name`

— (optional) a string; if not passed, ‘transmitter’ is the default name used

`set_num_rf_chains(L)`

`set_num_rf_chains(L)`

Sets the number of RF chains in the transmitter’s hybrid beamforming structure.

- Usage:
`set_num_rf_chains(L)`

*Input Arguments*:`L`

— number of RF chains

`set_num_streams(Ns)`

`set_num_streams(Ns)`

Sets the number of data streams being transmitted.

- Usage:
`set_num_streams(Ns)`

*Input Arguments*:`Ns`

— number of data streams*Notes*:- Also updates the transmit symbol covariance to Rs = eye(Ns) ./ sqrt(Ns). This can be overwritten if needed using set_transmit_symbol_covariance().
- Also updates the precoder power budget to the number of streams. This can be overwritten if needed.

`set_precoder(F)`

`set_precoder(F)`

Sets the transmit precoding matrix.

- Usage:
`set_precoder()`

`set_precoder(F)`

*Input Arguments*:`F`

— transmit precoding matrix; if not provided an identity matrix of size Nt-by-Ns will be used

`set_precoder_analog(F)`

`set_precoder_analog(F)`

Sets the analog precoding matrix.

- Usage:
`set_precoder_analog(F)`

*Input Arguments*:`F`

— analog precoding matrix*Notes*:- Also updates the effective precoding matrix.

`set_precoder_analog_amplitude_quantization_law(law)`

`set_precoder_analog_amplitude_quantization_law(law)`

Sets the analog precoder’s amlitude quantization law (e.g., linear or log).

- Usage:
`set_precoder_analog_amplitude_quantization_law(law)`

*Input Arguments*:`law`

— either ‘linear’ for uniform linear amplitude quantization between (0,1]; or a negative number corresponding to the (amplitude) attenuation step size in dB*Notes*:- A law = -0.25 represents an analog precoder with attenuators having a step size of -0.25 dB, meaning with 3 bits of amplitude resolution, for example, the attenuators can attenuate at most -0.25 dB * 2^3 = -2 dB. Practical attenuators often are stepped in such a log-scale, motivating us to support both linear- and log-based amplitude quantization laws.

`set_precoder_analog_amplitude_resolution_bits(bits)`

`set_precoder_analog_amplitude_resolution_bits(bits)`

Sets the resolution (in bits) of the attenuators in the analog precoder.

- Usage:
`set_precoder_analog_amplitude_resolution_bits(bits)`

*Input Arguments*:`bits`

— number of bits of amplitude control*Notes*:- When bits = Inf, amplitude control is not quantized.

`set_precoder_analog_phase_resolution_bits(bits)`

`set_precoder_analog_phase_resolution_bits(bits)`

Sets the resolution (in bits) of the phase shifters in the analog precoder.

- Usage:
`set_precoder_analog_phase_resolution_bits(bits)`

*Input Arguments*:`bits`

— number of bits of phase control*Notes*:- When bits = Inf, phase control is not quantized.

`set_precoder_digital(F)`

`set_precoder_digital(F)`

Sets the digital precoder.

- Usage:
`set_precoder_digital(F)`

*Input Arguments*:`F`

— digital precoding matrix

`set_precoder_digital_power_budget(P)`

`set_precoder_digital_power_budget(P)`

Sets the power budget of the digital precoding matrix.

- Usage:
`set_precoder_digital_power_budget(P)`

*Input Arguments*:`P`

— the digital precoding power budget

`set_precoder_hybrid_connections(M)`

`set_precoder_hybrid_connections(M)`

Defines which RF chains are connected to which antennas, allowing for arbitrary hybrid beamforming configurations, including subarray architectures.

- Usage:
`set_precoder_hybrid_connections(M)`

*Input Arguments*:`M`

— a matrix of booleans whose (i,j)-th entry indicates whether or not the i-th antenna is connected to the j-th RF chain. The number of rows in M should equal the number of antennas. The number of columns in M should equal the number of RF chains. A logical 1 indicates a connection. A logical 0 indicates no connection. A subarray architecture, for example, would take on a block diagonal form.

`set_precoder_power_budget(P)`

`set_precoder_power_budget(P)`

Sets the precoding matrix power budget.

- Usage:
`set_precoder_power_budget(P)`

*Input Arguments*:`P`

— total power budget (squared Frobenius norm) of effective precoding matrix

`set_symbol_bandwidth(B)`

`set_symbol_bandwidth(B)`

Sets the transmit symbol bandwidth.

- Usage:
`set_symbol_bandwidth(B)`

*Input Arguments*:`B`

— symbol bandwidth in Hertz*Notes*:- Also updates the symbol period and transmit energy per symbol accordingly.

`set_transmit_power(P,unit)`

`set_transmit_power(P,unit)`

Sets the transmit power.

- Usage:
`set_transmit_power(P)`

`set_transmit_power(P,unit)`

*Input Arguments*:`P`

— the transmit power`unit`

— an optional unit specifying the units of P (default of Watts)

`set_transmit_strategy(strategy)`

`set_transmit_strategy(strategy)`

Sets the transmit strategy.

- Usage:
`set_transmit_strategy()`

`set_transmit_strategy(strategy)`

*Input Arguments*:`strategy`

— (optional) a string specifying the transmit strategy; options vary depending on transmitter type (digital vs. hybrid); if not passed, identity transmission will be used

`set_transmit_symbol(s)`

`set_transmit_symbol(s)`

Sets the symbol vector to be transmitted.

- Usage:
`set_transmit_symbol(s)`

*Input Arguments*:`s`

— the symbol vector transmitted

`set_transmit_symbol_covariance(Rs)`

`set_transmit_symbol_covariance(Rs)`

Sets the transmit symbol covariance matrix.

- Usage:
`set_transmit_symbol_covariance()`

`set_transmit_symbol_covariance(Rs)`

*Input Arguments*:`Rs`

— (optional) the covariance matrix of the transmit symbols; if not passed, the default is an identity matrix normalized to unit power

`set_transmitted_signal(x)`

`set_transmitted_signal(x)`

Sets the signal vector that is transmitted (i.e., the signal that exits the transmit array).

- Usage:
`set_transmitted_signal(x)`

*Input Arguments*:`x`

— the vector leaving the transmit array (i.e., x = sqrt(Ptx) * F * s)

`set_type(type)`

`set_type(type)`

Sets the type of the transmitter.

- Usage:
`set_type()`

`set_type(type)`

*Input Arguments*:`type`

— (optional) a string; if not passed, ‘digital’ is the default type used

`show_analog_beamformer(idx)`

`show_analog_beamformer(idx)`

Plots one of the analog beamformers.

- Usage:
`show_analog_beamformer()`

`show_analog_beamformer(idx)`

*Input Arguments*:`idx`

— an index specifying which beamformer in the analog precoding matrix to plot (default of 1)

`show_effective_beamformer(idx)`

`show_effective_beamformer(idx)`

Plots one of the effective beamformers (combination of analog and digital).

- Usage:
`show_effective_beamformer()`

`show_effective_beamformer(idx)`

*Input Arguments*:`idx`

— an index specifying which beamformer in the effective precoding matrix to plot (default of 1)

`transmitter_hybrid()`

`transmitter_hybrid()`

`turn_off()`

`turn_off()`

Turns off the transmitter by setting its precoder to a zeros matrix.

- Usage:
`turn_off()`

`update_precoder()`

`update_precoder()`

Updates the effective precoding matrix based on the current analog and digital precoders. Only updates if the dimensionality supports the matrix multiply.

- Usage:
`update_precoder()`

`update_transmit_energy_per_symbol()`

`update_transmit_energy_per_symbol()`

Updates the energy per symbol property.

- Usage:
`update_transmit_energy_per_symbol()`

*Notes*:- Is automatically called when transmit power or symbol bandwidth is set.

`update_transmitted_signal()`

`update_transmitted_signal()`

Recomputes the transmitted signal vector.

- Usage:
`update_transmitted_signal()`

*Notes*:- Should be called anytime the transmit power, precoder, or transmit symbol are changed.

`x()`

`x()`

Returns the transmitted signal vector.

- Usage:
`val = x()`

*Return Values*:`val`

— the transmitted signal vector