Capon Beamformer

Capon beamformer, also referred to as Minimum Variance Distortionless Response (MVDR).

The Capon[1] beamformer estimates the power \(\hat{P}\) received from a direction \((\theta, \phi)\), where \(\theta\) is the zenith and \(\phi\) is the azimuth angle of interest in spherical coordinates, respectively. Let \(\mathbf{X} \in \mathbb{C}^{N \times T}\) be the the matrix of \(T\) time-discrete samples acquired by an antenna arrary featuring \(N\) antennas and

\[\mathbf{R}^{-1} = \left( \mathbf{X}\mathbf{X}^{\mathsf{H}} + \lambda \mathbb{I} \right)^{-1}\]

be the respective inverse sample correlation matrix loaded by a factor \(\lambda \in \mathbb{R}_{+}\). The antenna array’s response towards a source within its far field emitting a signal of small relative bandwidth is \(\mathbf{a}(\theta, \phi) \in \mathbb{C}^{N}\). Then, the Capon beamformer’s spatial power response is defined as

\[\hat{P}_{\mathrm{Capon}}(\theta, \phi) = \frac{1}{\mathbf{a}^{\mathsf{H}}(\theta, \phi) \mathbf{R}^{-1} \mathbf{a}(\theta, \phi)}\]

with

\[\mathbf{w}(\theta, \phi) = \frac{\mathbf{R}^{-1} \mathbf{a}(\theta, \phi)}{\mathbf{a}^{\mathsf{H}}(\theta, \phi) \mathbf{R}^{-1} \mathbf{a}(\theta, \phi)} \in \mathbb{C}^{N}\]

being the beamforming weights to steer the sensor array’s receive characteristics towards direction \((\theta, \phi)\), so that

\[\mathcal{B}\lbrace \mathbf{X} \rbrace = \mathbf{w}^\mathsf{H}(\theta, \phi) \mathbf{X}\]

is the implemented beamforming equation.

The following section provides an example for the usage of the Conventional Beamformer in a communication scenario.

For this a new simulation environment is initialised. A digital antenna array consisting of ideal isotropic antenna elements spaced at half wavelength intervals is created and is assigned to a device representing a base station.

# Initialize a new simulation
from hermespy.simulation import Simulation

simulation = Simulation(seed=42)

# Create a new device and assign it the antenna array
from hermespy.simulation import SimulatedIdealAntenna, SimulatedUniformArray
from hermespy.core import Transformation
import numpy as np

base_station_device = simulation.new_device(
    antennas=SimulatedUniformArray(SimulatedIdealAntenna, .5 * wavelength, (8, 8, 1)),
    carrier_frequency=carrier_frequency,
    pose=Transformation.From_Translation(np.array([0, 0, 0])),
)

To probe the characterestics a cosine waveform is generated as the transmit waveform.

# Configure a probing signal to be transmitted.
from hermespy.modem import RootRaisedCosineWaveform, SingleCarrierLeastSquaresChannelEstimation, SingleCarrierZeroForcingChannelEqualization, SingleCarrierCorrelationSynchronization

waveform = RootRaisedCosineWaveform(
    symbol_rate=sampling_rate//2,
    oversampling_factor=2,
    num_preamble_symbols=32,
    num_data_symbols=128,
    roll_off=.9,
)
waveform.synchronization = SingleCarrierCorrelationSynchronization()
waveform.channel_estimation = SingleCarrierLeastSquaresChannelEstimation()
waveform.channel_equalization = SingleCarrierZeroForcingChannelEqualization()

The base station device is configured to receive the signal from desired UE by assigning the Capon Beamformer to the base station device.

# Assign the capon beanfornmer to the base station device.
from hermespy.beamforming import CaponBeamformer
from hermespy.modem import ReceivingModem
from copy import deepcopy

beamformer = CaponBeamformer(1.0)
base_station_device.receive_coding[0] = beamformer

base_station_receiver = ReceivingModem(waveform=deepcopy(waveform))
base_station_device.add_dsp(base_station_receiver)

Now the simulation can be extended to evaluate the performance in a real world communication scenario. For this two devices representing the UEs are added, to be illuminated by the BS.

# Create two simulated devices representing the user equipments
user_equipment_device_1 = simulation.new_device(
    carrier_frequency=carrier_frequency,
    pose=Transformation.From_Translation(np.array([200., 200., 100.])),
)
user_equipment_device_2 = simulation.new_device(
    carrier_frequency=carrier_frequency,
    pose=Transformation.From_Translation(np.array([200., -200., 100.])),
)

The user equipments are configured to transmit the probing signal.

# Configure the user equipments to transmit the signal.
from hermespy.modem import TransmittingModem

user_equipment_transmitter_1 = TransmittingModem(waveform=deepcopy(waveform))
user_equipment_transmitter_2 = TransmittingModem(waveform=deepcopy(waveform))
user_equipment_device_1.add_dsp(user_equipment_transmitter_1)
user_equipment_device_2.add_dsp(user_equipment_transmitter_2)

Now as defined the Capon Beamformer focuses on one UE. This can be realised by configuring the receive foucs of the Beamformer.

# Focus the base station's main lobe on the desired user equipment.
from hermespy.simulation import DeviceFocus

beamformer.receive_focus = [
    DeviceFocus(user_equipment_device_1), # Focus on User Equipmment 1
]

The propgation characterestics between the BS and the UEs can be modelled using the SpatialDelayChannel Model.

# Configure a channel between base station and the UEs
from hermespy.channel import SpatialDelayChannel

simulation.set_channel(
    base_station_device,
    user_equipment_device_1,
    SpatialDelayChannel(model_propagation_loss=False),
)

simulation.set_channel(
    base_station_device,
    user_equipment_device_2,
    SpatialDelayChannel(model_propagation_loss=False),
)

The performance of the beamformer is studied by analysing the received signal quality from the respective UEs. For this purpose, the Error Vector Magnitude of the consetallation diagram of the Received signal is evaluated.

# Run the simulation and the inspect the received signal quality from the respective UEs.
from hermespy.modem import ConstellationEVM

simulation.add_evaluator(ConstellationEVM(user_equipment_transmitter_1, base_station_receiver))
simulation.add_evaluator(ConstellationEVM(user_equipment_transmitter_2, base_station_receiver))

# Creating a new dimension to dynamically switch the focus of the beamformer during the simulation campaign.
simulation.new_dimension(
    'focused_device',
    [user_equipment_device_1, user_equipment_device_2],
    beamformer.receive_focus[0]
)

result = simulation.run()

class CaponBeamformer(loading=0.0)

Bases: ReceiveBeamformer

Parameters:

loading (float) – Diagonal covariance loading coefficient \(\lambda\). Defaults to zero.

classmethod Deserialize(process)

Deserialize an object’s state.

Objects cannot be deserialized directly, instead a Factory must be instructed to carry out the deserialization process.

Parameters:

process (DeserializationProcess) – The current stage of the deserialization process. This object is generated by the Factory and provides an interface to deserialization methods supporting multiple backends.

Return type:

CaponBeamformer

Returns:

The deserialized object.

_decode(samples, carrier_frequency, angles, array)

Decode signal streams for receive beamforming.

This method is called as a subroutine during decode_streams and probe.

Parameters:

• samples (ndarray) – Signal samples, first dimension being the number of signal streams \(N\), second the number of samples \(T\).

• carrier_frequency (float) – The assumed carrier central frequency of the samples \(f_\mathrm{c}\).

• angles (ndarray) – Spherical coordinate system angles of arrival in radians. A three-dimensional numpy array with the first dimension representing the number of angles, the second dimension of magnitude number of focus points \(F\), and the third dimension containing the azimuth and zenith angle in radians, respectively.

• array (AntennaArrayState) – The assumed antenna array.

Return type:

ndarray

Returns:

Stream samples of the focused signal towards all focus points. A three-dimensional numpy array with the first dimension representing the number of focus points, the second dimension the number of returned streams and the third dimension the amount of samples.

num_receive_output_streams(num_input_streams)

Get required number of output streams during decoding.

Parameters:

num_input_streams (int) – Number of input streams.

Return type:

int

Returns: The number of output streams. Negative numbers indicate infeasible configurations.

serialize(process)

Serialize this object’s state.

Objects cannot be serialized directly, instead a Factory must be instructed to carry out the serialization process.

Parameters:

process (SerializationProcess) – The current stage of the serialization process. This object is generated by the Factory and provides an interface to serialization methods supporting multiple backends.

Return type:

None

property loading: float

Magnitude of the diagonal sample covariance matrix loading.

Required for robust matrix inversion in the case of rank-deficient sample covariances.

Returns:

Diagonal loading coefficient \(\lambda\).

Raises:

ValueError – For loading coefficients smaller than zero.

property num_receive_focus_points: int

Number of required receive focus points.

If this is \(1\), the beamformer is considered to be a single focus point beamformer and receive_focus will return a single focus point. Otherwise, the beamformer is considered a multi focus point beamformer and receive_focus will return a Sequence of focus points.

Returns: Number of focus points.

[1]

J. Capon. High-resolution frequency-wavenumber spectrum analysis. Proceedings of the IEEE, 57(8):1408–1418, 1969. doi:10.1109/PROC.1969.7278.