Conventional Beamformer

Also refferred to as delay and sum beamformer.

The Bartlett[1] beamformer, also known as conventional or delay and sum beamformer, maximizes the power transmitted or received towards a single direction of interest \((\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. 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

\[\hat{P}_{\mathrm{Conventional}}(\theta, \phi) = \mathbf{a}^\mathsf{H}(\theta, \phi) \mathbf{X} \mathbf{X}^\mathsf{H} \mathbf{a}(\theta, \phi)\]

is the Conventional beamformer’s power estimate with

\[\mathbf{w}(\theta, \phi) = \mathbf{a}(\theta, \phi)\]

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.

base_station_device = simulation.new_device(
    antennas=SimulatedUniformArray(SimulatedIdealAntenna, .5 * wavelength, (4, 4, 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.

waveform = RootRaisedCosineWaveform(
    num_preamble_symbols=32,
    num_data_symbols=128,
    roll_off=.9,
)

The base station device is configured to transmit the beamformed signal by assigning the Conventional Beamformer to the base station device.

beamformer = ConventionalBeamformer()
base_station_device.transmit_coding[0] = beamformer

base_station_transmitter = TransmittingModem(waveform=deepcopy(waveform))
base_station_device.add_dsp(base_station_transmitter)

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

    carrier_frequency=carrier_frequency,
    pose=Transformation.From_Translation(np.array([100., 100., 100.])),
)
user_equipment_device_2 = simulation.new_device(
    carrier_frequency=carrier_frequency,
    pose=Transformation.From_Translation(np.array([100., -100., 100.])),
)

The user equipments can be configured to receive the signal by setting them up as receiving modems.

user_equipment_receiver_2 = ReceivingModem(waveform=deepcopy(waveform))
user_equipment_device_1.add_dsp(user_equipment_receiver_1)
user_equipment_device_2.add_dsp(user_equipment_receiver_2)

Now as defined the Conventional Beamformer illuminates the maximum radiation on one UE. This can be realised by configuring the transmit foucs of the Beamformer.

]

# Configure a channel between base station and the UEs

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

    user_equipment_device_1,
    SpatialDelayChannel(model_propagation_loss=False),
)

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

# Run the simulation and the evaluate the received power from the respective UEs.

Now hermespy can be instructed to conduct a simulation campaign to evaluate the received signal power at the UEs by adding the evaluator.

# Creating a new dimension to dynamically switch the focus of the beamformer during the simulation campaign.

In the previous example the Conventional Beamformer was assigned to transmitting base station. The same example can be adpated to study the performance of the beamformer assigned to a receiving base station.

The base station is configured for reception.

beamformer = ConventionalBeamformer()
base_station_device.receive_coding[0] = beamformer

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

The UEs will be configured as transmitting.

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 receieve focus of the beamformer will be configured.

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

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.

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 ConventionalBeamformer

Bases: TransmitBeamformer, ReceiveBeamformer

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:

ConventionalBeamformer

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.

_encode(samples, carrier_frequency, focus_angles, array)

Encode signal streams for transmit beamforming.

Parameters:

• samples (ndarray) – Signal samples, first dimension being the number of transmit antennas, second the number of samples.

• carrier_frequency (float) – The assumed central carrier frequency of the samples generated RF signal after mixing in Hz.

• focus_angles (ndarray) – Focused angles of departure in radians. Two-dimensional numpy array with the first dimension representing the number of focus points and the second dimension of magnitude two being the azimuth and elevation angles, respectively.

• array (AntennaArrayState) – The assumed antenna array.

Return type:

ndarray

Returns:

The encoded signal samples. Two-dimensional complex-valued numpy array with the first dimension representing the number of transmit antennas streams and the second dimension the number 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.

num_transmit_input_streams(num_output_streams)

Get required number of input streams during encoding.

Parameters:

num_output_streams (int) – Number of desired output streams.

Return type:

int

Returns: The number of input 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 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.

property num_transmit_focus_points: int

Number of required transmit focus points.

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

[1]

M. S. Bartlett. Periodogram analysis and continuous spectra. Biometrika, 37(1/2):1–16, 1950. URL: http://www.jstor.org/stable/2332141 (visited on 2022-06-28).