Receive Combining

For receivers with multiple antennas, the output of each received path have to be combined to extract the transmitted information correctly. In 5G, mostly 2 type of combiners are used.

  • Spatial Diversity Based: The ones which aim to maximizes the received power.

    • DFT based combiners.

    • Direction of arrival based combiners.

  • Spatial Multiplexing based: The ones which aim to reduces the interlayer/path interference.

    • SVD based combiners.

The ReceiveCombining module in 5G Toolkit provide APIs to facilitate all these cases. It provide the ways to support all type of combiners. A few such examples are listed below.

For Custom Combiner:

# Wr (Custom Combiner) of shape: numberOfCombiners x Nr
# y (Received Grid) of shape: ... x Nr (N1 x N2 x N3 x Nr)

method      = "custom"
rxCombining = ReceiveCombining(combinerType = method)
yCombined   = rxCombining(y, Wr)

# yCombined (Combined received Grid) of shape: ... x numberOfCombiners (N1 x N2 x N3 x numberOfCombiners)

For DFT beams based Combiner: Returns Output with highest Power

# numBeams (number of Beams) should be > Nr.
# y (Received Grid) of shape: (: x Nr) (For ex: N1 x Nr)

method      = "dft"
outType     = "best"
numBeams    = 64
rxCombining = ReceiveCombining(combinerType = method, numDFTBeams = nBeam, output = out)
yCombined   = rxCombining(y)

# yCombined (Combined received Grid) of shape: (:,) (For ex: N1,))

For DFT beams based Combiner: Returns all the Combined Outputs

# numBeams (number of Beams) should be > Nr.
# y (Received Grid) of shape: ... x Nr (For ex: N1 x N2 x N3 x Nr)

method      = "dft"
outType     = "all"
numBeams    = 18
rxCombining = ReceiveCombining(combinerType = method)
yCombined   = rxCombining(y)

# yCombined (Combined received Grid) of shape: ... x numBeams (For ex: N1 x N2 x N3 x numBeams)

For Direction of Arrival based Combiner: Returns all the Combined Outputs

# angles (2D Direction of Arrivals) of shape: numberAngles x 2
# Nr_x: Number of Antenna elements in each row of the 2D planner array
# Nr_y: Number of Antenna elements in each column of the 2D planner array
# P: Polarization Order
# y (Received Grid) of shape: ... x Nr (For ex: N1 x N2 x N3 x Nr)

method      = "doa"
carrierFreq = 3.6*10**9 # carrier frequency is 3.6 GHz
speedOfLight= 3*10**8   # speed of light (m/s)
spacing     = np.array([0.5, 0.5])*(speedOfLight/carrierFreq)
rxCombining = ReceiveCombining(combinerType = method, carrierFrequency = fc)
yCombined   = rxCombining(y, angles, spacing, np.array([Nr_x, Nr_y, P]))

# yCombined (Combined received Grid) of shape: ... x numberAngles (For ex: N1 x N2 x N3 x numberAngles)

API Documentation

The details about the input-output interface of the ReceiveCombining modules is provided below.

class toolkit5G.MIMOProcessing.ReceiveCombining(combinerType='dft', carrierFrequency=1000000000, numDFTBeams=1, output='all')[source]

This class implements the receiver combining for receiver multiple antenna systems. Currently, it supports 3 combiner types which are discussed below.

Note

  • When combinerType is “dft”, the code generates (numDFTBeams \(\times\) numDFTBeams) DFT basis and select first \(\text{N}_\text{r}\) DFT basis as combiner (dimension numDFTBeams \(\times \text{N}_\text{r}\) ) are selected as the combiner matrix at the receiver. The combiner vector resulting in highest received power is selected and corresponding combined output is returned.

  • When combinerType is “custom”, the user can pass their own set of combiners. The combiner resulting in highest received power is selected and corresponding combined output is returned.

  • When combinerType is “doa”, the user can pass 2D direction of arrivals. The implementation computes the combiners for each of these angles and apply them to the input received sequence. The combiner resulting in highest received power is selected and corresponding combined output is returned.

Parameters:

  • combinerType (str) – Defines the type of combiner to be used. It can take 3 values \(\{\) “dft”, “custom”, “doa” \(\}\).

  • carrierFrequency (float) – Defines the carrier frequency used for pass-band transmission in Hz.

  • numDFTBeams (int) – Defines the number of beams to tried for receiver combining when combinerType is “dft”.

  • output (str) – Defines the type of output to be returned by the module. It can take a value from the set \(\{\) “all”, “best” \(\}\). This parameter is relevant only for combinerType` = “dft”.

    • When output is “all”, the output resulting from each combiner is returned. The user can choose the one they want.

    • When output is “best”, the output resulting in highest received power is returned. The user can access the best combiner using the variable bestBeam.

Input:

  • y ((:, \(\text{N}_\text{r}\)), np.complex) – Defines the received grid/samples to be combined. Must be a 2D arrays.

  • arg (list) – Defines the variable arguments related to combiner. The lenfth and variable passed via arguments depend on the combinerType.

    • When combinerType is “custom”:

      • arg: (:, \(\text{N}_\text{r}\)), np.complex - The arg carries only one variable. This variable is custom combiners which user wants to apply to the received signal.

    • When combinerType is “doa”:

      • (3,), list of 3 Numpy arrays.

        • arg[0]: (:,2), NumPy array of numbers - Defines 2D-direction of arrivals where

          • arg[0][:,0] carries elevation angles (in degrees) and,

          • arg[0][:,1] carries azimuth angles (in degrees).

        • arg[1]: (2,), NumPy array of 2 numbers - Defines the inter antenna element spacing in vertical and horizontal Direction.

          • arg[1][0] is spacing in vertical direction and,

          • arg[1][1] is spacing in horizontal direction.

        • arg[2]: (3,), NumPy array of 2 numbers - Defines the number of antenna element in rows and columns of an antenna array along with polarization.

          • arg[1][0] is number of antenna element in placed in each row of antenna array and

          • arg[1][1] number of antenna element in placed in each column of antenna array.

          • arg[1][2] Defines polarization (P = 1 or P = 2).

    • When combinerType is “dft”:

      • None

Output:

(:, k), np.complex – Defines the receiver combined signal.

  • k is 1 When output is “best”.

  • k is \(\text{N}_\text{r}\) When output is “all”.

Attributes:

bestBeam ((\(\text{N}_\text{r}\),), np.complex) – Defines the combiner resulting highest received power. Relevant only for combinerType` = “dft”.

Raises:

  • ValueError – [Error-ReceiveCombining]: ‘y’ must be a Complex NumPy array!”)

  • ValueError – [Error-ReceiveCombining]: Shape mismatch between ‘y’ and combiner passed as input! Shape of y and ‘combiner’ must be (…, Nr) and (…, K, Nr) respectively with K>0!

  • Warning – [Warning-ReceiveCombining] Invalid value for ‘numDFTBeams’! Value is set to numRx Antennas (y.shape[-1])

  • ValueError – [Error-ReceiveCombining]: 3 Agruments must be passed ‘Sweep Directions’, ‘Antenna Spacing’ and ‘Antenna Geometry’

  • ValueError – [Error-ReceiveCombining]: Sweep Directions must be a 2D array of numbers

  • ValueError – [Error-ReceiveCombining]: Antenna Spacing must be a 1D array of numbers

  • ValueError – [Error-ReceiveCombining]: Antenna Geometry must be a 1D array of integers

  • ValueError – [Error-ReceiveCombining]: ‘carrierFrequency’ must be integer or Float type!

  • ValueError – [Error-ReceiveCombining]: ‘numDFTBeams’ must be an integer!

  • ValueError – [Error-ReceiveCombining]: ‘combinerType’ must be string!

  • ValueError – [Error-ReceiveCombining]: ‘combinerType’ must be one of {‘dft’, ‘custom’, ‘doa’}!

  • ValueError – [Error-ReceiveCombining]: ‘output’ must be string!

  • ValueError – [Error-ReceiveCombining]: ‘output’ must be one of {‘all’, ‘best’}!

property carrierFrequency

Defines the carrier frequency considered for compluting wavelength

property combinerType

Defines the combiner type used at the receiver.

property numDFTBeams

Defines the numBER DFT Beams generated for rx Combining

property output

Defines the output of the receive combiner. If output = ‘all’, then receiveCombiner return all the combined beams and user can select the best beam him/herself.

  • In this case the dimension of the output will be (…,Nr,numDFTBeams)

If output = ‘best’, then receiveCombiner return the beam resulting in highest received power.

  • In this case the dimension of the output will be (…,Nr,1). Best beam combiner vector can be accessed by obj.bestBeam.