Superclass:  Transmitter

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 $N_{\mathrm{t}} \times 1$ signal vector $\mathrm{x}$ leaving the hybrid transmitter and entering the channel can be written as

where $\mathbf{s}$ is the $N_{\mathrm{s}} \times 1$ complex transmit symbol vector, $\mathbf{F}_{\mathrm{RF}}$ is the $N_{\mathrm{t}} \times L_{\mathrm{t}}$ analog precoding matrix, $\mathbf{F}_{\mathrm{BB}}$ is the $L_{\mathrm{t}} \times N_{\mathrm{s}}$ digital precoding matrix, and $P_{\mathrm{tx}}$ is the transmit energy per symbol.

Digital precoding—represented by the matrix $\mathbf{F}_{\mathrm{BB}}$—takes place in the digital domain at baseband (hence “BB”).

Analog precoding—represented by the matrix $\mathbf{F}_{\mathrm{RF}}$—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 $L_{\mathrm{t}}$ RF chains. In order to support spatial multiplexing of $N_{\mathrm{s}}$ 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 $\mathbf{F}_{\mathrm{BB}}$ and the analog precoding matrix $\mathbf{F}_{\mathrm{RF}}$, the transmitter_hybrid object has the following properties

tx.precoder_digital
tx.precoder_analog


Their product $\mathbf{F}_{\mathrm{RF}} \mathbf{F}_{\mathrm{BB}}$ 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 $[0,2\pi)$ with step size $2\pi/2^{b_{\mathrm{phs}}}$, where each phase shifter has $b_{\mathrm{phs}}$ 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 $[0,1]$.

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 $\mathbf{F}_{\mathrm{RF}}$. The $(i,j)$-th entry is only nonzero if there exists a weighted connection between the $i$-th antenna and the $j$-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 $N_{\mathrm{t}} \times L_{\mathrm{t}}$ matrix (like the analog precoding matrix) whose $(i,j)$-th entry is 1 if there exists a weighted connection between the $i$-th antenna and the $j$-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 $P$ 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 $L_{\mathrm{t}} \times N_{\mathrm{s}}$ 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 $N_{\mathrm{t}} \times L_{\mathrm{t}}$ 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:

### Methods Documentation

#### F()

Returns the precoding matrix.

Usage:
val = F()
Return Values:
val — the precoding matrix

Back to methods

#### F_BB()

Returns the digital precoding matrix.

Usage:
val = F_BB()
Return Values:
val — the digital precoding matrix

Back to methods

#### F_RF()

Returns the analog precoding matrix.

Usage:
val = F_RF()
Return Values:
val — the analog precoding matrix

Back to methods

#### Lt()

Returns the number of transmit RF chains.

Usage:
val = Lt()
Return Values:
val — the number of transmit RF chains

Back to methods

#### Ns()

Returns the number of streams.

Usage:
val = Ns()
Return Values:
val — the number of streams

Back to methods

#### Nt()

Returns the number of transmit antennas.

Usage:
val = Nt()
Return Values:
val — the number of transmit antennas

Back to methods

#### P()

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

Usage:
val = P()
Return Values:
val — the transmit energy per symbol

Back to methods

#### Ptx()

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

Usage:
val = Ptx()
Return Values:
val — the transmit energy per symbol

Back to methods

#### Rs()

Returns the transmit symbol covariance matrix.

Usage:
val = Rs()
Return Values:
val — the transmit symbol covariance matrix

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### 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)

Back to methods

#### 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

Back to methods

#### 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.

Back to methods

#### 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

Back to methods

#### 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.

Back to methods

#### 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)

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### configure_transmitter_eigen()

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

Usage:
configure_transmitter_eigen()

Back to methods

#### configure_transmitter_identity()

Configures the transmit precoder to an identity matrix.

Usage:
configure_transmitter_identity()

Back to methods

#### 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

Back to methods

#### 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()

Back to methods

#### 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.

Back to methods

#### 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.

Back to methods

#### 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

Back to methods

#### 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.

Back to methods

#### 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.

Back to methods

#### 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()

Back to methods

#### initialize()

Executes initializations for a transmitter.

Usage:
initialize()

Back to methods

#### initialize_hybrid()

Executes initializations for a hybrid digital/analog transmitter.

Usage:
initialize_hybrid()
Notes:
Should be executed after the default transmitter initialization (transmitter.initialize()).

Back to methods

#### 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)

Back to methods

#### 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

Back to methods

#### s()

Returns the transmit symbol vector.

Usage:
val = s()
Return Values:
val — the transmit symbol vector

Back to methods

#### 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.

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### 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

Back to methods

#### 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.

Back to methods

#### 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

Back to methods

#### 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.

Back to methods

#### 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.

Back to methods

#### 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.

Back to methods

#### 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.

Back to methods

#### set_precoder_digital(F)

Sets the digital precoder.

Usage:
set_precoder_digital(F)
Input Arguments:
F — digital precoding matrix

Back to methods

#### 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

Back to methods

#### 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.

Back to methods

#### 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

Back to methods

#### 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.

Back to methods

#### 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)

Back to methods

#### 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

Back to methods

#### set_transmit_symbol(s)

Sets the symbol vector to be transmitted.

Usage:
set_transmit_symbol(s)
Input Arguments:
s — the symbol vector transmitted

Back to methods

#### 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

Back to methods

#### 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)

Back to methods

#### 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

Back to methods

#### 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)

Back to methods

#### 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)

Back to methods

Back to methods

#### turn_off()

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

Usage:
turn_off()

Back to methods

#### 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()

Back to methods

#### 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.

Back to methods

#### 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.

Back to methods

#### x()

Returns the transmitted signal vector.

Usage:
val = x()
Return Values:
val — the transmitted signal vector

Back to methods