blkdiagbfweights

MIMO channel block diagonalized weights

Syntax

``````[wp,wc] = blkdiagbfweights(chanmat,ns)``````
``[wp,wc] = blkdiagbfweights(chanmat,ns,pt)``

Description

example

``````[wp,wc] = blkdiagbfweights(chanmat,ns)``` returns precoding weights, `wp`, and combining weights, `wc`, derived from the channel response matrices contained in a MATLAB® cell array `chanmat`. You can specify multiple user channels by putting each channel in a `chanmat` cell. `chanmat``{k}` represents the kthchannel from the transmitter to the user.For a single frequency, specify the channel cell as a matrix.For multiply frequencies, specify the channel cell as a three-dimensional array where the rows represent different subcarriers.Specify multiple subchannels per channel using the `ns` argument. Subchannels represent different data streams. `ns` specifies the number of subchannels for each user channel. Multiply the data streams by the precoding weights, `wp`. The precoding and combining weights diagonalize the channel into independent subchannels so that for the kthuser, the matrix `wp*chanmat{k}*wc{k}` is diagonal for each subcarrier.```

example

````[wp,wc] = blkdiagbfweights(chanmat,ns,pt)` also specifies the total transmitted power, `pt`, per subcarrier.```

Examples

collapse all

Start with a base station consisting of a uniform linear array (ULA) with 16 antennas, and two users having receiver ULA arrays with 8 and 4 antennas, respectively. Show that using block diagonalization-based precoding and combining weights achieves spatial multiplexing, where the received signal at each user can be decoded without interference from the other user. Specify two data streams for each user.

Specify the transmitter location in `txpos` and two user receiver locations in `rxpos1` and `rxpos2`. Array elements are spaced one-half wavelength apart.

```txpos = (0:15)*0.5; rxpos1 = (0:7)*0.5; rxpos2 = (0:3)*0.5;```

Create the channel matrix cell array using `scatteringchanmtx` and then compute the beamforming weights `wp` and `wc`. Each channel corresponds to a user. Assume that the channels have 10 scatterers. Each channel has two subchannels specified by the vector `ns`.

```chanmat = {scatteringchanmtx(txpos,rxpos1,10), ... scatteringchanmtx(txpos,rxpos2,10)}; ns = [2 2]; [wp,wc] = blkdiagbfweights(chanmat,ns);```

The weights diagonalize the channel matrices for each user.

For channel 1:

`disp(wp*chanmat{1}*wc{1})`
``` 8.2269 + 0.0000i -0.0000 - 0.0000i 0.0000 + 0.0000i 6.1371 - 0.0000i -0.0000 - 0.0000i 0.0000 - 0.0000i 0.0000 + 0.0000i 0.0000 + 0.0000i ```

For channel 2:

`disp(wp*chanmat{2}*wc{2})`
``` 0.0000 - 0.0000i 0.0000 - 0.0000i -0.0000 + 0.0000i -0.0000 + 0.0000i 8.7543 + 0.0000i 0.0000 - 0.0000i 0.0000 + 0.0000i 4.4372 + 0.0000i ```

First create four subchannels to carry the data streams: two subchannels per channel. Each data stream contains 20 samples of $±1$. Precode the input streams and combine the streams to produce the recovered signals.

```x = 2*round(rand([20,4])) - 1; xp = x*wp; y1 = xp*chanmat{1} + 0.1*randn(20,8); y2 = xp*chanmat{2} + 0.1*randn(20,4); y = [y1*wc{1},y2*wc{2}];```

Overlay stem plots of the input and recovered signals to show that the received user signals are the same as the transmitted signals.

```for m = 1:4 subplot(4,1,m) s = stem([x(:,m) 2*((real(y(:,m)) > 0) - 0.5)]); s(1).LineWidth = 2; s(2).MarkerEdgeColor = 'none'; s(2).MarkerFaceColor = 'r'; ylabel('Signal') title(sprintf('User %d Stream %d',ceil(m/2),rem(m-1,2) + 1)) if m==1 legend('Input','Recovered','Location','best') end end xlabel('Samples')```

Start with a base station consisting of a uniform linear array (ULA) with 16 antennas, and two users having receiver ULA arrays with 8 and 5 antennas, respectively. Show how to use three-dimensional arrays of channel matrices to handle two subcarriers. Then, the channel matrix for the first user takes the form 2-by-16-by-8 and the channel matrix for the second users takes the form 2-by-16-by-5. Also assume that there are two data streams for each user.

Specify the transmitter location in `txpos` and two user receiver locations in `rxpos1` and `rxpos2`. Array elements are spaced one-half wavelength apart.

```nr1 = 8; nr2 = 5; txpos = (0:15)*0.5; rxpos1 = (0:(nr1-1))*0.5; rxpos2 = (0:(nr2-1))*0.5;```

Create the channel matrices using `scatteringchanmtx `and put them in a cell array. To create a second subchannel for each receiver, duplicate each channel matrix. Assume 10 point scatterers in computing the channel matrix.

```smtmp1 = scatteringchanmtx(txpos,rxpos1,10); smtmp2 = scatteringchanmtx(txpos,rxpos2,10); sm1 = zeros(2,16,8); sm2 = zeros(2,16,5); sm1(1,:,:) = smtmp1; sm1(2,:,:) = smtmp1; sm2(1,:,:) = smtmp2; sm2(2,:,:) = smtmp2; chanmat = {sm1,sm2};```

Specify that there are two data streams for each user.

`ns = [2 2];`

Specify the transmitted powers for each subcarrier.

`pt = [1.0 1.5];`

Compute the beamforming weights.

`[wp,wc] = blkdiagbfweights(chanmat,ns,pt);`

Show that the channels are diagonalized for the first subcarrier.

```ksubcr = 1; wpx = squeeze(wp(ksubcr,:,:)); chanmat1 = squeeze(chanmat{1}(ksubcr,:,:)); chanmat2 = squeeze(chanmat{2}(ksubcr,:,:)); wc1 = squeeze(wc{1}(ksubcr,:,:)); wc2 = squeeze(wc{2}(ksubcr,:,:)); wpx*chanmat1*wc1```
```ans = 4×2 complex 8.2104 - 0.0000i -0.0000 - 0.0000i 0.0000 + 0.0000i 5.9732 - 0.0000i 0.0000 - 0.0000i 0.0000 + 0.0000i -0.0000 - 0.0000i -0.0000 - 0.0000i ```
`wpx*chanmat2*wc2`
```ans = 4×2 complex 0.0000 - 0.0000i -0.0000 + 0.0000i -0.0000 - 0.0000i -0.0000 - 0.0000i 8.8122 + 0.0000i -0.0000 + 0.0000i -0.0000 - 0.0000i 4.8186 - 0.0000i ```

Propagate the signals to each user and then decode. Generate four streams of random data containing -1's and +1's and having two columns for each user. Each stream is a subchannel.

`x = 2*(round(rand([20 4]))) - 1;`

Precode the data streams.

```xp = x*wpx; y1 = xp*chanmat1 + 0.1*randn(20,8); y2 = xp*chanmat2 + 0.1*randn(20,5);```

Decode the data streams.

`y = [y1*wc1,y2*wc2];`

Overlay stem plots of the input and recovered signals to show that the received user signals are the same as the transmitted signals.

```for m = 1:4 subplot(4,1,m) s = stem([x(:,m) 2*((real(y(:,m)) > 0) - 0.5)]); s(1).LineWidth = 2; s(2).MarkerEdgeColor = 'none'; s(2).MarkerFaceColor = 'r'; ylabel('Signal') title(sprintf('User %d Stream %d',ceil(m/2),rem(m-1,2) + 1)) if m==1 legend('Input','Recovered','Location','best') end end xlabel('Samples')```

Input Arguments

collapse all

Channel response matrices, specified as an Nu-element cell array. Nu is the number of receive arrays. Each cell corresponds to a different channel and contains a channel response matrix or a three dimensional MATLAB array. The cell array must contain either all matrices or all arrays. For matrices, the number of rows for all matrices must be the same. For three-dimensional arrays, the number of rows and columns must be the same.

• If the kth cell is a matrix, the matrix has the size Nt-by-Nr(k). Nt is the number of elements in the transmitting array and Nr(k) is the number of elements in the kth receiving array.

• If the kth cell is an array, the array has the size L-by-Nt-by-Nr(k). L is the number of subcarriers. Nt is the number of elements in the transmit array and Nr(k) is the number of elements in the kth receive array.

Data Types: `double`
Complex Number Support: Yes

Number of data streams per receive array, specified as an Nu-element row vector of positive integers. Nu is the number of receive arrays.

Data Types: `double`

Total transmitted power per subcarrier, specified as a positive scalar or an L-element vector of positive values. L is the number of subcarriers. If `pt` is a scalar, all subcarriers have the same transmitted power. If `pt` is a vector, each vector element specifies the transmitted power for the corresponding subcarrier. Power is in linear units.

Data Types: `double`

Output Arguments

collapse all

Precoding weights, returned as a complex-valued Nst-by-Nt matrix or a complex-valued L-by-Nst-by-Nt MATLAB array.

• If `chanmat` contains matrices, `wp` is a complex-valued Nst-by-Nt matrix where Nst is the total number of data channels (`sum(ns)`).

• If `chanmat` contains three-dimensional MATLAB arrays, `wp` is a complex-valued L-by-Nst-by-Nt MATLAB array where Nst is the total number of data channels (`sum(ns)`).

Units are dimensionless.

Data Types: `double`
Complex Number Support: Yes

Combining weights, returned as an Nu-element cell array. Units are dimensionless.

• If `chanmat` contains matrices, the kth cell in `wc` contains a complex valued Nr(k)-by-Ns(k) matrix. Ns(k) is the value of the argument `ns` for the kth receive array.

• If `chanmat` contains three-dimensional MATLAB arrays, the kth cell of `wc` contains a complex-valued L-by-Nr(k)-by-Ns(k) MATLAB array. Ns(k) is the value of the kth entry of the `ns` vector.

Data Types: `double`
Complex Number Support: Yes

References

[1] Heath, Robert W., et al. “An Overview of Signal Processing Techniques for Millimeter Wave MIMO Systems.” IEEE Journal of Selected Topics in Signal Processing, vol. 10, no. 3, Apr. 2016, pp. 436–53. DOI.org (Crossref), doi:10.1109/JSTSP.2016.2523924. Bibliography

[2] Tse, D. and P. Viswanath, Fundamentals of Wireless Communications, Cambridge: Cambridge University Press, 2005.

[3] Paulraj, A. Introduction to Space-Time Wireless Communications, Cambridge: Cambridge University Press, 2003.

[4] Spencer, Q.H., et al. "Zero-Forcing Methods for Downlink Spatial Multiplexing in Multiuser MIMO Channels." IEEE Transactions on Signal Processing, Vol. 52, No. 2, February 2004, pp. 461-471. DOI.org (Crossref), doi:10.1109/TSP.2003.821107.