The Sphere Decoder
System object™ decodes
the symbols sent over Nt
antennas using the sphere
decoding algorithm.
To decode input symbols using a sphere decoder:
Define and set up your sphere decoder object. See Construction.
Call step
to decode input symbols
according to the properties of comm.SphereDecoder
.
The behavior of step
is specific to each object in
the toolbox.
H = comm.SphereDecoder
creates a System object, H
.
This object uses the sphere decoding algorithm to find the maximumlikelihood
solution for a set of received symbols over a MIMO channel with N_{t} transmit
antennas and N_{r} receive
antennas.
H = comm.SphereDecoder(
creates a sphere decoder object, Name
,Value
)H
, with the
specified property name set to the specified value. Name must appear
inside single quotes (''). You can specify several namevalue pair
arguments in any order as Name1,Value1,…,NameN,ValueN.
H = comm.SphereDecoder(
creates
a sphere decoder object, CONSTELLATION
,BITTABLE
)H
, with the Constellation
property set to CONSTELLATION
, and the BitTable
property
set to BITTABLE
.

Signal constellation per transmit antenna Specify the constellation as a complex column vector containing
the constellation points to which the transmitted bits are mapped.
The default setting is a QPSK constellation with an average power
of 

Bit mapping used for each constellation point. Specify the bit mapping for the symbols that the The matrix size must be 

Initial search radius of the decoding algorithm. Specify the initial search radius for the decoding algorithm
as either When you set this property to When you set this property to 

Specify the decoding decision method as either When you set this property to When you set this property to 
clone  Create SphereDecoder object with same
property values 
isLocked  Locked status for input attributes and nontunable properties 
release  Allow property value and input characteristics changes 
step  Decode received symbols using sphere decoding algorithm 
Modulate a set of bits using 16QAM constellation. Transmit the signal as two parallel streams over a MIMO channel. Decode using a sphere decoder with perfect channel knowledge.
Specify the modulation order, the number of transmitted bits, the Eb/No ratio, and the symbol mapping.
M = 16; nBits = 1e3*log2(M); ebno = 10; symMap = [11 10 14 15 9 8 12 13 1 0 4 5 3 2 6 7];
Create a Rectangular QAM modulator System object™ whose properties are set using namevalue pairs.
hMod = comm.RectangularQAMModulator(... 'ModulationOrder',M, ... 'BitInput',true, ... 'NormalizationMethod','Average power', ... 'SymbolMapping','Custom', ... 'CustomSymbolMapping',symMap);
Display the symbol mapping of the 16QAM modulator by using the constellation
function.
constellation(hMod)
Convert the decimal value of the symbol map to binary bits using the left bit as the most significant bit (msb). The Mbylog2(M) matrix bitTable
is used by the sphere decoder.
bitTable = de2bi(symMap,log2(M),'leftmsb');
Create a 2x2 MIMO Channel System object with PathGainsOutputPort
set to true
to use the path gains as a channel estimate. To ensure the repeatability of results, set the object to use the global random number stream.
hMIMO = comm.MIMOChannel(... 'PathGainsOutputPort',true, ... 'RandomStream','Global stream');
Create an AWGN Channel System object.
hAWGN = comm.AWGNChannel('EbNo',ebno,'BitsPerSymbol',log2(M));
Create a Sphere Decoder System object that processes bits using harddecision decoding.
hSpDec = comm.SphereDecoder('Constellation',constellation(hMod),... 'BitTable',bitTable,'DecisionType','Hard');
Create an error rate System object.
hBER = comm.ErrorRate;
Set the global random number generator seed.
rng(37)
Generate a random data stream.
data = randi([0 1],nBits,1);
Modulate the data and reshape it into two streams to be used with the 2x2 MIMO channel.
modData = step(hMod,data); modData = reshape(modData,[],2);
Pass the modulated data through the MIMO fading channel and add AWGN.
[fadedSig,pathGains] = step(hMIMO,modData); rxSig = step(hAWGN,fadedSig);
Decode the received signal using pathGains
as a perfect channel estimate.
decodedData = step(hSpDec,rxSig,squeeze(pathGains));
Convert the decoded harddecision data, which is a logical matrix, into a double column vector to enable the calculation of error statistics. Calculate and display the bit error rate and the number of errors.
dataOut = double(decodedData(:)); errorStats = step(hBER,data,dataOut); errorStats(1:2)
ans = 0.0380 152.0000
For an additional example that uses this System object, see the LTE PHY Downlink with Spatial Multiplexing example. This example shows the Downlink Shared Channel (eNodeB to UE) processing of the Long Term Evolution (LTE) physical layer (PHY) specifications developed by the Third Generation Partnership Project (3GPP).
This object implements a softoutput maxlog APP MIMO detector by means of a softoutput SchnorrEuchner sphere decoder (SESD), implemented as single tree search (STS) tree traversal. The algorithm assumes the same constellation and bit table on all of the transmit antennas. Given as inputs, the received symbol vector and the estimated channel matrix, the algorithm outputs the loglikelihood ratios (LLRs) of the transmitted bits.
The algorithm assumes a MIMO system model with N_{t} transmit antennas and N_{r} receive antennas where N_{t} symbols are simultaneously sent, which is express as:
$$y=Hs+n$$
where the received symbols y are a function of the transmitted symbol vector s, the MIMO channel matrix, H, and the thermal noise, n.
The goal of the MIMO detector is to find the maximumlikelihood (ML) solution, for which it holds that
$${\widehat{s}}_{{}_{ML}}=\underset{s\in o}{{\displaystyle {}_{\mathrm{arg}\mathrm{min}}}}{\Vert yHs\Vert}^{2}$$
where O is the complexvalued constellation from which the N_{t} elements of s are chosen.
Soft detection additionally delivers, for each bit, estimates on how reliable the estimate is. For each of the sent bits, denoted as $${x}_{j,b}$$ (the bth bit of the jth symbol), the reliability of the estimate is calculated by means of the loglikelihood ratio (LLR), which is denoted as L and is calculated as using the maxlog approximation:
$$L\left({x}_{i,j}\right)=\underset{{\lambda}^{ML}}{\underbrace{\underset{s\in {x}_{j,b}^{(0)}}{\mathrm{min}}{\Vert yHs\Vert}^{2}}}\underset{{\lambda}_{j,b}^{\overline{ML}}}{\underbrace{\underset{s\in {x}_{j,b}^{(1)}}{\mathrm{min}}{\Vert yHs\Vert}^{2}}}$$
where $${x}_{j,b}^{(0)}$$ and $${x}_{j,b}^{(1)}$$ are the disjoint sets of vector symbols that have the bth bit in the label of the jth scalar symbol equal to 0 and 1, respectively. The symbol λ denotes the distance calculated as norm squared. The two terms can be expressed as the difference of:
The distance to the ML solution $${\widehat{s}}_{ML}$$, denoted as $${\lambda}^{ML}$$.
The distance $${\lambda}_{j,b}^{{}^{\overline{ML}}}$$ to the counterhypothesis, which denotes the binary complement of the bth bit in the binary label of the jth entry of $${\widehat{s}}_{ML}$$, i.e., the minimum of the symbol set $${x}_{j,b}^{\left({x}_{j,b}^{\overline{ML}}\right)}$$, which contains all of the possible vectors for which the bth bit of the jth entry is flipped compared to the same entry of $${\widehat{s}}_{ML}$$.
Thus, depending on whether $${x}_{j,b}^{\left({x}_{j,b}^{ML}\right)}$$ is zero or one, the LLR for the bit $${x}_{j,b}$$ is expressed as
$$L({x}_{j,b})=\{{}_{{\lambda}_{j,b}^{\overline{ML}}{\lambda}^{ML}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}},{x}_{j,b}^{ML}=\text{\hspace{0.17em}}1}^{{\lambda}^{ML}{\lambda}_{j,b}^{\overline{ML}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}},\text{\hspace{0.17em}}{x}_{j,b}^{ML}=\text{\hspace{0.17em}}0}$$
The design of a decoder thus aims at efficiently finding $${\widehat{s}}_{ML}$$, $${\lambda}^{ML}$$, and $${\lambda}_{j,b}^{\overline{ML}}$$.
This search can be converted into a tree search by means of the sphere decoding algorithms. To this end, the channel matrix is decomposed into $$H=QR$$ by means of a QR decomposition. Leftmultiplying y by Q^{H}, the problem can be reformulated as
$$\begin{array}{l}{\lambda}^{ML}=\underset{s\in o}{{\displaystyle \text{\hspace{0.17em}}\mathrm{arg}\text{\hspace{0.17em}}\mathrm{min}}}{\Vert \overline{y}Rs\Vert}^{2}\\ {\lambda}_{j,b}^{\overline{ML}}{=}_{s\in {x}_{j,b}^{\left({x}_{j,b}^{\overline{ML}}\right)}}^{\mathrm{arg}\mathrm{min}\text{\hspace{0.17em}}\text{\hspace{0.17em}}{\Vert \overline{y}Rs\Vert}^{2}}\end{array}$$
from which the triangular structure of R can be exploited to arrange a tree structure where each of the leaf nodes corresponds to a possible s vector and the partial distances to the nodes in the tree can be calculated cumulatively adding to the partial distance of the parent node.
In the STS algorithm, the $${\lambda}^{ML}$$ and $${\lambda}_{j,b}^{\overline{ML}}$$ metrics are searched concurrently. The main idea is to have a list containing the metric $${\lambda}^{ML}$$, along with the corresponding bit sequence $${x}^{ML}$$ and the metrics $${x}_{j,b}^{\left({x}_{j,b}^{ML}\right)}$$ of all counterhypotheses. Then, we search the subtree originating from a given node only if the result can lead to an update of either $${\lambda}^{ML}$$ or $${\lambda}_{j,b}^{\overline{ML}}$$.
The STS algorithm flow can be summarized as:
If when reaching a leaf node, a new ML hypothesis is found $$\left(d\left(x\right)<{\lambda}^{ML}\right)$$, all $${\lambda}_{j,b}^{\overline{ML}}$$ for which $${x}_{j,b}={x}_{j,b}^{\overline{ML}}$$ are set to $${\lambda}^{ML}$$ which now turns into a valued counterhypothesis. Then, $${\lambda}^{ML}$$ is set to the current distance d(x).
If the current partial distance d(x) satisfies $$d(x)\ge {\lambda}^{ML}$$, only the counterhypotheses have to be checked. For all j and b for which $$\left(d\left(x\right)<{\lambda}^{ML}\right)$$ and $${x}_{j,b}={x}_{j,b}^{\overline{ML}}$$ the decoder updates $${\lambda}_{j,b}^{\overline{ML}}$$ to be d(x).
A subtree is pruned if the partial distance of the node is bigger than the current $${\lambda}_{j,b}^{\overline{ML}}$$ which may be affected when traversing the subtree.
The algorithm finalizes once all of the tree nodes have been visited once or pruned.
[1] Studer, C., M. Wenk, A. Burg, and H. Bölcskei. "Softoutput MIMO detection algorithms: Performance and implementation aspects" Proceedings of the 40th Asilomar Conference on signals, Systems, and Computers, October 2006.
[2] Cho, Y. S., et.al. "MIMOOFDM Wireless communications with MATLAB," IEEE Press, 2011.
[3] Hochwald, B.M., S. ten Brink. "Achieving nearcapacity on a multipleantenna channel", IEEE Transactions on Communications, Vol. 51, No. 3, Mar 2003, pp. 389399.
[4] Agrell, E., T. Eriksson, A. Vardy, K. Zeger. "Closest point search in lattices", IEEE Transactions on Information Theory, Vol. 48, No. 8, Aug 2002, pp. 22012214.
comm.LTEMIMOChannel
 comm.MIMOChannel
 comm.OSTBCCombiner
 Sphere Decoder