MATLAB Examples

PDSCH Transmit Diversity Throughput Simulation

This example demonstrates how to measure the Physical Downlink Shared Channel (PDSCH) throughput of a transmit/receive chain using the LTE System Toolbox™.

Contents

Introduction

The example uses the LTE System Toolbox functions to generate a multi antenna downlink Reference Measurement Channel (RMC) R.12. Transmission is simulated using the Extended Pedestrian A (EPA) propagation channel model. Channel noise is added to the received waveform which is then OFDM demodulated, resulting in a received resource grid for each receive antenna. Channel estimation is performed to determine the channel between each transmit/receive antenna pair. The PDSCH data is then extracted and decoded from the received resource grid. Using the result of the block CRC the throughput performance of the transmit/receive chain is determined.

eNodeB Setup

% eNodeB Configuration
enb = struct;                       % eNodeB config structure
enb.RC = 'R.12';                    % RMC number
enb.NCellID = 10;                   % Cell ID
% Total number of subframes lteRMCDLTool  will generate per call. This
% example generates 1 frame (10 subframes) worth of data each call within
% the processing loop. lteRMCDLTool will be called 10 (NFrames) times.
enb.TotSubframes = 10;
enb.PDSCH.TxScheme = 'TxDiversity'; % Transmission scheme
enb.PDSCH.RNTI = 1;                 % 16-bit UE specific mask
enb.PDSCH.Rho = -3;                 % Downlink power allocation
enb.PDSCH.CSI = 'On';               % CSI scaling of soft bits
enb.PDSCH.RVSeq = 0;                % Disable HARQ

NFrames = 10;                       % Number of frames to simulate
SNRIn = [-2 2];                     % SNR points to simulate

RMC Configuration

Generate the configuration for the specified RMC and obtain associated information: number of bits in a transport block for each subframe; number of OFDM symbols per subframe and number of transmit antennas.

% Generate RMC configuration for test model specified in enb structure
rmc = lteRMCDL(enb);

% Transport block sizes of each subframe within a frame
trblksize = rmc.PDSCH.TrBlkSizes;
ncw = size(trblksize,1);             % no of codewords associated to RMC

% dims is a three element vector [K; L; P]: where K = no of subcarriers,
% L = no of OFDM symbols and P = no of transmit antennas
dims = lteDLResourceGridSize(rmc);  % Determine resource grid dimensions
L = dims(2);                        % Number of OFDM symbols per subframe
P = dims(3);                        % Number of transmit antennas

Propagation Channel Model Configuration

cfg = struct;                    % Channel config structure
cfg.Seed = 2;                    % Random channel seed
cfg.NRxAnts = 2;                 % 2 receive antennas
cfg.DelayProfile ='EPA';         % Delay profile
cfg.DopplerFreq = 5;             % Doppler frequency in Hz
cfg.MIMOCorrelation = 'Medium';  % Multi-antenna correlation
cfg.NTerms = 16;                 % Oscillators used in fading model
cfg.ModelType = 'GMEDS';         % Rayleigh fading model type
cfg.InitPhase = 'Random';        % Random initial phases
cfg.NormalizePathGains = 'On';   % Normalize delay profile power
cfg.NormalizeTxAnts = 'On';      % Normalize for transmit antennas

Channel Estimation Configuration

To reduce the impact of noise on pilot estimates, an averaging window of 15-by-141 Resource Elements (REs) is used. An EPA delay profile causes the channel response to change slowly over frequency. Therefore a large frequency averaging window of 15 REs is used. The Doppler frequency is 5 Hz, causing the channel to fade very slowly over time. Therefore a large time averaging window is also used. The channel is estimated frame-by-frame, therefore pilots in the preceding and following five subframes are included in the average when possible by setting the time window to 141 REs.

cec = struct;                       % Channel estimation config structure
cec.PilotAverage = 'UserDefined';   % Type of pilot symbol averaging
cec.FreqWindow = 15;                % Frequency window size in REs
cec.TimeWindow = 141;               % Time window size in REs

Interpolation is performed by the channel estimator between pilot estimates to create a channel estimate for all REs. To improve the estimate multiple subframes can be used when interpolating. An interpolation window of 3 subframes with a centered interpolation window uses pilot estimates from 3 consecutive subframes to estimate the center subframe.

cec.InterpType = 'Cubic';         % Cubic interpolation
cec.InterpWinSize = 3;            % Interpolate up to 3 subframes
                                  % simultaneously
cec.InterpWindow = 'Centred';     % Interpolation windowing method

Processing Loop

For each SNR point the following operations are performed for each frame:

  • RMC Generation and OFDM Modulation: Generate the OFDM modulated waveform for RMC using random data.
  • Propagation Channel Model: The OFDM modulated waveform is transmitted through the propagation channel. The channel model is initialized appropriately to guarantee continuity of the fading waveforms between frames. The output of the channel rxWaveform has two columns, one per receive antenna.
  • Add Channel Noise: The channel noise is modeled by AWGN.
  • Receiver Synchronization and OFDM Demodulation: Determine the delay suffered during propagation. This is calculated by calling lteDLFrameOffset, which uses the primary and secondary synchronization signals. If it has not been possible to detect the primary and secondary synchronization signals due to extreme channel conditions or noise, then the previously calculated frame offset value is used. OFDM demodulation is performed after synchronization.
  • Channel Estimation: Provides an estimate of the channel response at each element of the resource grid for a transmit/receive antenna pair. This estimate is then used to remove the effect of the channel on the transmitted signal. The channel estimation also aims to reduce the channel noise experienced during transmission by averaging the reference signals (pilot symbols).
  • Throughput Measurement: PDSCH data is analyzed on a subframe by subframe basis. As specified by RMC R.12 no PDSCH data is transmitted on subframe 5. Therefore it is not decoded and does not count towards the throughput calculation. A specific subframe worth of data for all receive antennas is extracted from the array of received grids, the same defined subframe worth of information is extracted from the estimate of channel response for all transmit and receive antenna pairs. These, along with the noise estimate, are input into the function ltePDSCHDecode, which deprecodes the PDSCH data using an orthogonal space frequency block code (OSFBC) decoder. This returns a cell array of soft bit vectors (codewords) which are input to the lteDLSCHDecode function; this decodes the codeword and returns the block CRC error which is used to determine the throughput of the system.
% Initialize the variables used in the simulation and analysis
resultIndex = 1;                    % Initialize SNR counter index
offsets = 0;                        % Initialize offset vector
crc = [];                           % Define CRC error per frame
trSizes = [];                       % Define transport sizes per frame

% Set the random number generator to default value
rng('default');

% Number of subframes carrying transport blocks with data within a frame.
% For RMC R.12 this should be 9, of the 10 subframes in a frame subframe 5
% does not carry any data
nDataTBSPerFrame = sum(trblksize(:) ~= 0);

% Total block CRC vector
TotalBLKCRC = zeros(numel(SNRIn),nDataTBSPerFrame*NFrames);

% Bit throughput vector
BitThroughput = zeros(numel(SNRIn),nDataTBSPerFrame*NFrames);

for SNRdB = SNRIn
    fprintf('\nSimulating at %gdB SNR for a total %d Frame(s)\n',...
    SNRdB,NFrames);

    % Initialize result store for each SNR point
    TotalBLKCRCcws = zeros(NFrames,nDataTBSPerFrame);% Total block CRC
                                                     % vector
    BitTput = zeros(NFrames,nDataTBSPerFrame);      % Bit throughput vector

    for FrameNo = 1:NFrames
        % Generate random bits for the frame. The number of bits to
        % generate for each subframe is specified by each element of
        % trblksize. For a full frame generate sum(trblksize) bits
        trdata = randi([0 1], sum(trblksize), 1);

        % Generate populated LTE resource grid using RMC generator and OFDM
        % modulate. info is a structure containing the sampling rate used
        % for OFDM modulation
        [txWaveform,txGrid,info] = lteRMCDLTool(rmc,trdata);

        % Initialize result store for frame
        crc = zeros(nDataTBSPerFrame/ncw,ncw);    % Intermediate block CRC
        trSizes = zeros(nDataTBSPerFrame/ncw,ncw);% Intermediate throughput
        dataSubframeIndex = 1;

        % Set sampling rate of channel to that of OFDM modulation
        cfg.SamplingRate = info.SamplingRate;

        % Set channel offset to current frame (1 frame = 10ms)
        cfg.InitTime = (FrameNo-1)*(rmc.TotSubframes)/1000;

        % Pass data through the fading channel model.
        % An additional 25 samples are added to the end of the waveform.
        % These are to cover the range of delays expected from the channel
        % modeling (a combination of implementation delay and channel
        % delay spread).
        rxWaveform = lteFadingChannel(cfg,[txWaveform ; zeros(25,P)]);

        % Noise setup
        SNR = 10^(SNRdB/20);    % Linear SNR

        % Normalize noise power to take account of sampling rate, which is
        % a function of the IFFT size used in OFDM modulation, and the
        % number of antennas
        N0 = 1/(sqrt(2.0*rmc.CellRefP*double(info.Nfft))*SNR);

        % Create additive white Gaussian noise
        noise = N0*complex(randn(size(rxWaveform)), ...
                            randn(size(rxWaveform)));

        % Add AWGN to the received time domain waveform
        rxWaveform = rxWaveform + noise;

        % Perform receiver synchronization
        offset = lteDLFrameOffset(rmc,rxWaveform);

        % Determine if frame synchronization was successful
        if (offset > 25)
            offset = offsets(end);
        else
            offsets = [offsets offset]; %#ok
        end
        if (offset>0)
            rxWaveform = rxWaveform(1+offset:end,:);
        end

        % Perform OFDM demodulation on the received data to recreate the
        % resource grid
        rxGrid = lteOFDMDemodulate(rmc,rxWaveform);

        % Perform channel estimation
        [estChannelGrid, noiseest] = lteDLChannelEstimate(rmc,cec,rxGrid);

        % Process subframes 0 to 9 within received frame
        for sf = 0:rmc.TotSubframes-1

            % Increment NSubframe for correct decoding of data
            rmc.NSubframe = mod(sf,10);

            % Extract one subframe for analyzing at a time from the
            % received grid
            rxSubframe = rxGrid(:,L*sf+1:L*(sf+1),:);

            % Extract the estimated channel response for the subframe
            % being analyzed
            chSubframe = estChannelGrid(:,L*sf+1:L*(sf+1),:,:);

            % Perform deprecoding, layer demapping, demodulation and
            % descrambling on the received data using the estimate of
            % the channel
            rxEncodedBits = ltePDSCHDecode(rmc,rmc.PDSCH,...
                  rxSubframe*(10^(-rmc.PDSCH.Rho/20)),chSubframe,noiseest);

            % Transport block sizes
            outLen = ones(1,ncw)*trblksize(rmc.NSubframe+1);

            % Decode DownLink Shared Channel (DL-SCH)
            [decbits,blkcrc] = lteDLSCHDecode(rmc,rmc.PDSCH,outLen,...
                               rxEncodedBits);

            % Skip empty transport blocks, this will be the case of
            % subframe 5, where no data is transmitted in RMC R.12
            if(outLen ~= 0)
                trSizes(dataSubframeIndex, :) = outLen;
                crc(dataSubframeIndex, :) = blkcrc;
                dataSubframeIndex = dataSubframeIndex + 1;
            end
        end

        % Store resulting block CRC results and bit throughput vector
        % for analysis
        TotalBLKCRCcws(FrameNo,:) = crc(:);
        BitTput(FrameNo,:) = trSizes(:).*(1 - crc(:));
        rmc.NSubframe = 0;
    end

    % Record the block CRC and bit throughput for the total number of
    % frames simulated at a particular SNR
    TotalBLKCRC(resultIndex,:) = TotalBLKCRCcws(:); % CRC
    BitThroughput(resultIndex,:) = BitTput(:); % successfully decoded bits
    resultIndex = resultIndex + 1;
    offsets = 0;
end
Simulating at -2dB SNR for a total 10 Frame(s)

Simulating at 2dB SNR for a total 10 Frame(s)

Plot Results

First graph shows the throughput as total bits per second against the range of SNRs, second plots total throughput as a percentage of block CRC errors against SNR range.

figure
plot(SNRIn,mean(BitThroughput,2),'-*')
title(['Throughput for ', num2str(NFrames) ' frame(s)'] )
xlabel('SNRdB'); ylabel('Throughput (kbps)');
grid on;
hold on;
plot(SNRIn,mean([trblksize(1:5) trblksize(7:end)])*0.7*...
    ones(1,numel(SNRIn)),'--rs');
legend('Simulation Result','70 Percent Throughput','Location',...
    'SouthEast')
figure
plot(SNRIn,100*(1-mean(TotalBLKCRC,2)),'-*')
title(['Throughput for ', num2str(NFrames) ' frame(s)'] )
xlabel('SNRdB'); ylabel('Throughput (%)');
grid on;
hold on;
plot(SNRIn,70*ones(1,numel(SNRIn)),'--rs');
legend('Simulation Result','70 Percent Throughput','Location',...
    'SouthEast')
ylim([0 100])

Further Exploration

You can modify parts of this example to experiment with different number of frames and different values of SNR. SNR can be a vector of values or a single value. The example should be run for a larger number of frames to obtain meaningful throughput measurements.

The demo can easily be configured to analyze system performance for 2-codeword scenario. For example, if we wish to configure the system for an open-loop spatial multiplexing scheme with 2-codeword transmission the following changes in PDSCH configuration structure would be required:

enb.PDSCH.TxScheme = 'CDD';         % Transmission scheme
enb.PDSCH.Rho = -6;                 % Downlink power allocation
enb.RC = 'R.14';                    % RMC number

The channel estimator parameters then can also be tuned as per noise level and modulation scheme used.

Selected Bibliography

  1. 3GPP TS 36.101 "User Equipment (UE) radio transmission and reception"