MATLAB Examples

Enhanced Physical Downlink Control Channel (EPDCCH) Conformance Test

This example shows how to measure EPDCCH/PCFICH demodulation performance using LTE System Toolbox™ under the test conditions defined in TS 36.101 [ 1 ] Section 8.8 "Demodulation of EPDCCH".



This example shows the demodulation performance of EPDCCH/PCFICH in terms of the probability of misdetection of the downlink scheduling grant (Pm-dsg) as defined in TS 36.101 [ 1 ] Section 8.8 "Demodulation of EPDCCH". The EPDCCH and PCFICH are tested jointly and a misdetection of PCFICH implies a misdetection of EPDCCH. This example works on a subframe by subframe basis when simulating at a particular SNR. A resource grid populated with EPDCCH, EPDCCH DM-RS, and PCFICH is generated and OFDM modulated to create a transmit waveform. The generated waveform is passed through a noisy Extended Vehicular A (EVA) channel. Channel estimation, equalization, demodulation and decoding are performed at the receiver. The average misdetection probability of the EPDCCH/PCFICH is determined using a combination of the received CFI and received DCI message.

LTE System Toolbox supports the transmission and reception of EPDCCH via the following product functions:

Simulation Setup

The variable Test allows selection of Test number 1 or 2 from TS 36.101 [ 1 ] Table For Test 1, the target SNR for a probability of missed downlink scheduling grant (Pm-dsg) of $<=$ 1% is 2.6dB. For Test 2, the target SNR for Pm-dsg $<=$ 1% is -3.2dB. The code below sets up the target SNR depending on the Test number, and it also chooses a range of SNR points SNRIn to simulate, where the range covers the target SNR. SNRIn can be an array of values or a scalar.

Test = 1; % Test number (1 or 2)

if (Test==1)
    targetSNR = 2.6;
    SNRIn = [-1.5 1.0 3.5];
    targetSNR = -3.2;
    SNRIn = [-7.3 -4.8 2.3];

The example is executed for a simulation length of 1 frame to keep the simulation time low. A large number of frames, nFrames, should be used to produce meaningful results.

nFrames = 1;

eNodeB Configuration

Create a structure enb representing the cell-wide (eNodeB) settings specified for the test. The number of downlink resource blocks (50) corresponds to the test bandwidth (10MHz) defined in TS 36.101 [ 1 ] Table The duplexing mode is indicated in Table, as part of the description of the Reference Channel: "R.55 FDD" for Test 1 and "R.56 FDD" for Test 2. See TS 36.101 Appendix A.3.10.1 for additional R.55 FDD and R.56 FDD reference channel settings.

% eNodeB configuration according to TS 36.101 Table
enb = struct;
enb.NDLRB = 50;
enb.DuplexMode = 'FDD';

% eNodeB configuration according to TS 36.101 Table
enb.CyclicPrefix = 'Normal';
enb.CellRefP = 2;
enb.CFI = 2 - (enb.NDLRB <= 10); % 2 symbols for PDCCH
enb.NCellID = 0;

EPDCCH Configuration

Create a structure epdcch representing the EPDCCH settings specified for the test.

For these tests, two EPDCCH sets are configured as noted in TS 36.101 [ 1 ] Table EPDCCHTypeList and EPDCCHPRBSetList give the EPDCCH types and EPDCCH PRB pairs for each EPDCCH set. Note that the EPDCCH sets must be configured in the order given by EPDCCHPRBSetList. Although TS 36.101 Table specifies that the first set has 4 PRB pairs and the second set has 8 PRB pairs, the definition of the number of PRB pairs in the EPDCCH candidate sets in TS 36.213 [ 3 ] Table 9.1.4-3a has an entry for 8 pairs in set 1 and 4 pairs in set 2, but not the other way around.

Set ControlChannelType to 'EPDCCH', so that lteDCIInfo reports the correct DCI message sizes for the DCI messages transmitted on the EPDCCH. The DCI Format DCIFormat is also set as described in TS 36.101 Table

The EPDCCH format EPDCCHFormat is set for the particular Test number according to the "Aggregation level" noted in TS 36.101 Table The relationship between EPDCCH format and aggregation level is given by TS 36.211 [ 2 ] Table 6.8A.1-2, where the aggregation level is described as the "Number of ECCEs for one EPDCCH". For Test 1 the EPDCCH format is format 1, corresponding to an aggregation level of 4 ECCE (Enhanced Control Channel Elements), and for Test 2 the EPDCCH format is format 3, corresponding to an aggregation level of 16 ECCE.

% EPDCCH configuration according to TS 36.101 Table
epdcch = struct;
epdcch.EPDCCHTypeList = {'Distributed' 'Distributed'};
epdcch.EPDCCHPRBSetList = {[0; 7; 14; 21; 28; 35; 42; 49] [3; 17; 31; 45]};
epdcch.ControlChannelType = 'EPDCCH';
epdcch.DCIFormat = 'Format2A';

% EPDCCH configuration according to TS 36.101 Table
if (Test==1)
    epdcch.EPDCCHFormat = 1; % Aggregation level L = 4 ECCE
    epdcch.EPDCCHFormat = 3; % Aggregation level L = 16 ECCE

% Configure the EPDCCH scrambling identity and RNTI. These values are not
% mandated by the test configuration, but the parameters are required.
epdcch.EPDCCHNID = 0;
epdcch.RNTI = 1;

Propagation Channel Model Configuration

Create a propagation channel configuration structure, channel, according to TS 36.101 [ 1 ] Table This configuration structure will be used by the function lteFadingChannel.

channel = struct;
channel.NRxAnts = 2;
channel.DelayProfile = 'EVA';
channel.MIMOCorrelation = 'Low';
if (Test==1)
    channel.DopplerFreq = 5;
    channel.DopplerFreq = 70;

Channel Estimator Configuration

The logical variable perfectChannelEstimator controls channel estimator behavior. When set to true, a perfect channel estimator is used otherwise an imperfect estimator is used, based on the values of the received EPDCCH DM-RS. Set perfectChannelEstimator to false, and create channel estimation configuration structure, cec, which lteDLChannelEstimate will use to generate an imperfect channel estimate.

perfectChannelEstimator = false;

if (~perfectChannelEstimator)
    cec.PilotAverage = 'UserDefined';   % Type of pilot symbol averaging
    cec.FreqWindow = 1;                 % Frequency window size in REs
    cec.TimeWindow = 2;                 % Time window size in REs
    cec.InterpType = 'linear';          % 2D interpolation type
    cec.InterpWindow = 'Centered';      % Interpolation window type
    cec.InterpWinSize = 1;              % Interpolation window size
    cec.Reference = 'EPDCCHDMRS';       % EPDCCH DM-RS used as reference

Select EPDCCH Transmission Set

The EPDCCH set for transmission txSetIndex is configured in the code below as a function of the Test number. Note that because the EPDCCH receiver (channel estimation, demodulation, EPDCCH search) runs over both EPDCCH sets, the receiver does not need to be configured specifically for either Test 1 or Test 2, it will automatically decode the transmitted DCI message in the relevant EPDCCH set.

txSetIndex = 3-Test; % Test=1 -> 2nd set, Test=2 -> 1st set

% Configure EPDCCH set for transmission from the two EPDCCH sets according
% to 'txSetIndex'
epdcch.EPDCCHType = epdcch.EPDCCHTypeList{txSetIndex};
epdcch.EPDCCHPRBSet = epdcch.EPDCCHPRBSetList{txSetIndex};

Create Variables to Record Simulated Performance

The performance of the receiver is recorded in the matrix mdsg, representing missed downlink scheduling grants. This matrix has a row for each SNR point and a column for each subframe simulated. The elements will be set to 1 for SNR points/subframes where the downlink scheduling grant was missed. As described earlier, the EPDCCH and PCFICH are tested jointly and a misdetection of PCFICH implies a misdetection of EPDCCH. Therefore an element of mdsg is set to 1 if either the PCFICH or EPDCCH could not be demodulated. For convenience, a separate matrix mcfi is created to record the misdetections of PCFICH only.

% The 'mdsg' matrix will contain ones in the locations of missed downlink
% scheduling grants; the 'mcfi' matrix will contain ones in the locations
% of missed CFI decoding
mdsg = zeros(numel(SNRIn),10*nFrames);
mcfi = zeros(numel(SNRIn),10*nFrames);

Establish Number of Transmit Antennas

Establish the number of transmit antennas ntxants, which is the maximum of the number of antenna ports used for each set of reference signals configured in the example. Note that although the EPDCCH has 4 reference signal ports, only a maximum of 2 of these will be used for any given configuration (2 for distributed EPDCCH type, 1 for localized EPDCCH type), so only 2 physical antennas are required to support the transmission of EPDCCH.

epdcchports = 2;
portcounts = [enb.CellRefP epdcchports];
if (isfield(enb,'CSIRefP'))
    portcounts = [portcounts enb.CSIRefP];
ntxants = max(portcounts);

Print Parameter Summary

Print a summary of the simulation parameters, for the list of parameters in TS 36.101 [ 1 ] Annex A.3.10 "Reference Measurement Channels for EPDCCH performance requirements". Note that the aggregation level (number of ECCEs per EPDCCH) can be obtained for a given configuration by using the field NECCEPerEPDCCH of the 2nd output of lteEPDCCHSpace. enb.NSubframe is set here because it is a required parameter of lteEPDCCHSpace however it only affects the candidates (1st output), not the dimensionality information obtained from the 2nd output. (enb.NSubframe will be updated in the main subframe processing loop, meaning that over time the EPDCCH candidate locations used for transmission can vary.)

enb.NSubframe = 0;
[~,candidateInfo] = lteEPDCCHSpace(enb,epdcch);

fprintf('\n-- Parameter summary: --------------------------------------------\n');
fprintf('  Number of transmitter antennas: %d\n',ntxants);
fprintf('               Channel bandwidth: %gMHz\n',hNRBToBandwidth(enb.NDLRB));
fprintf('Number of OFDM symbols for PDCCH: %d symbols\n',enb.CFI + (enb.NDLRB <= 10));
fprintf('               Aggregation level: %d ECCE \n',candidateInfo.NECCEPerEPDCCH);
fprintf('                      DCI format: %s\n',epdcch.DCIFormat);
-- Parameter summary: --------------------------------------------
  Number of transmitter antennas: 2
               Channel bandwidth: 10MHz
Number of OFDM symbols for PDCCH: 2 symbols
               Aggregation level: 4 ECCE 
                      DCI format: Format2A


For each SNR point, the following operations are performed for each subframe:

  • EPDCCH candidate creation: lteEPDCCHSpace is used to create the possible EPDCCH candidates, and a candidate is selected for transmission.
  • DCI message creation: A set of random DCI message bits is created of the length given by lteDCIInfo for the DCI format specified in epdcch.DCIFormat.
  • DCI message encoding: lteDCIEncode is used to encode the DCI message bits, with the coded capacity given by the EPDCCHG field of the dimensionality information output of lteEPDCCHIndices. The EPDCCH indices are also stored for later use in mapping the EPDCCH.
  • EPDCCH modulation: lteEPDCCH is used to create modulation symbols for the encoded DCI message.
  • EPDCCH DM-RS creation: lteEPDCCHDMRS is used to create the EPDCCH DM-RS sequence, and lteEPDCCHDMRSIndices is used to create the corresponding indices for use in mapping the EPDCCH DM-RS.
  • EPDCCH beamforming: The EPDCCH symbols/indices are concatenated with the EPDCCH DM-RS symbols/indices to facilitate beamforming. Beamforming is performed according to TS 36.101 [ 1 ] Annex B.4.4 for Distributed type and Annex B.4.5 for Localized type.
  • CFI coding / PCFICH modulation: lteCFI, ltePCFICH and ltePCFICHIndices are used to encode the CFI, modulate the PCFICH and map the modulated symbols to the subframe resource grid.
  • Cell-Specific Reference Signal (CRS) addition: lteCellRS and lteCellRSIndices are used to create the CRS sequence and map it to the subframe resource grid.
  • Primary Synchronization Signal (PSS) and Secondary Synchronization Signal (SSS) addition: ltePSS, lteSSS, ltePSSIndices and lteSSSIndices are used to create the PSS and SSS sequences and map them to the subframe resource grid.
  • OCNG addition: As specified in the test, OP.7 OCNG (TS 36.101 [ 1 ] Annex A.5.1.7) is added, consisting of a single PDSCH in all resource blocks not used by the EPDCCH. A control region OCNG reference channel (TS 36.101 Annex A.5) is also added, including the PDCCH and PHICH locations but avoiding the PCFICH locations, to allow the CFI to be transmitted.
  • OFDM modulation: The subframe resource grid is OFDM modulated using lteOFDMModulate.
  • Propagation Channel Model: The OFDM modulated waveform is transmitted through the propagation channel. 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 PSS and SSS. OFDM demodulation is performed after synchronization.
  • Channel estimation for PCFICH reception: CRS-based channel estimation (or perfect channel estimation) is performed to provide a channel estimation for PCFICH equalization and demodulation
  • PCFICH / CFI reception: The PCFICH is demodulated (including equalization) and the CFI is decoded. If the decoded CFI does not match the transmitted CFI, a misdetection of downlink scheduling grant is noted (as is a misdetection of CFI), otherwise reception proceeds to EPDCCH reception

EPDCCH reception / EPDCCH blind search is attempted for each of the two EPDCCH sets configured in this test. For each EPDCCH set:

  • Configure the receiver for the EPDCCH set: An EPDCCH configuration structure epdcchRx is created by copying the structure used in the transmitter, epdcch. epdcchRx.EPDCCHType and epdcchRx.EPDCCHPRBSet are configured for the EPDCCH set to be received by setting them to the appropriate element of epdcchRx.EPDCCHTypeList and epdcchRx.EPDCCHPRBSetList respectively. The resulting configuration structure epdcchRx is then used to configure the channel estimation, EPDCCH demodulation and EPDCCH blind search steps. The fields in epdcchRx would be known to the UE by higher-layer signaling of the EPDCCH-Config Information Element (IE) in the Radio Resource Control (RRC) protocol TS 36.331 [ 4 ].
  • Channel estimation for EPDCCH reception: If perfect channel estimation is used, the perfect channel estimate previously obtained for PCFICH reception is beamformed according to the transmit beamforming used for the EPDCCH, to create a channel estimate for EPDCCH reception. Otherwise, if practical channel estimation is used, an EPDCCH DM-RS-based channel estimation is performed.
  • EPDCCH demodulation: lteEPDCCHDecode is used to demodulate the EPDCCH for all possible EPDCCH candidate locations, returning soft bit estimates for all possible candidates.
  • EPDCCH blind search: lteEPDCCHSearch is used to search for DCI messages by attempting DCI message decoding in all the possible candidate locations given by lteEPDCCHSpace, for all the possible DCI formats. If the search fails to decode a message of the format given by the transmitter configuration in the test, a misdetection of the downlink scheduling grant is noted.

For a more detailed description of the steps involved in EPDCCH transmission, see Enhanced Physical Downlink Control Channel (EPDCCH) Generation.

% For each SNR point:
for SNRIdx = 1:numel(SNRIn)

    % Set the random number generator to its default value

    % Get current SNR value
    SNRdB = SNRIn(SNRIdx);

    fprintf('\nSimulating at %gdB SNR for a total of %d Frame(s)\n',SNRdB,nFrames);

    % Initialize timing offset vector
    offsets = 0;

    % For each subframe:
    for sf = 0:(nFrames*10)-1

        % Update frame and subframe numbers
        enb.NFrame = floor(sf/10);
        enb.NSubframe = mod(sf,10);

        % Configure EPDCCH candidate; the first candidate from the set of
        % search space candidates is used
        candidates = lteEPDCCHSpace(enb,epdcch);
        epdcch.EPDCCHECCE = candidates(1,:);

        % Create random DCI message bits from the configured DCI format
        dciInfo = lteDCIInfo(enb,epdcch);
        [dci,dciBits] = lteDCI(enb,epdcch,randi([0 1],dciInfo.(epdcch.DCIFormat),1));

        % Create EPDCCH indices; the 2nd output contains the EPDCCH bit
        % capacity EPDCCHG
        [epdcchIndices,epdcchInfo] = lteEPDCCHIndices(enb,epdcch);

        % Encode the DCI message bits to match the bit capacity EPDCCHG
        codedDciBits = lteDCIEncode(epdcch,dciBits,epdcchInfo.EPDCCHG);

        % Modulate the coded DCI message on the EPDCCH
        epdcchSymbols = lteEPDCCH(enb,epdcch,codedDciBits);

        % Create EPDCCH Demodulation Reference Signal (DM-RS)
        epdcchDmrsSymbols = lteEPDCCHDMRS(enb,epdcch);
        epdcchDmrsIndices = lteEPDCCHDMRSIndices(enb,epdcch);

        % Create empty subframe resource grid
        subframe = lteDLResourceGrid(enb,ntxants);

        % Concatenate EPDCCH symbols/indices with EPDCCH DM-RS
        % symbols/indices to facilitate beamforming
        allSymbols = [epdcchSymbols; epdcchDmrsSymbols];
        allIndices = [epdcchIndices; epdcchDmrsIndices];

        % Perform EPDCCH beamforming according to TS 36.101 Annex B.4.4 for
        % Distributed type and Annex B.4.5 for Localized type
        [K,L,P] = size(subframe);
        [resubs,~,portsubs] = ind2sub([K L 4],allIndices);
        rbsubs = floor((resubs-1)/12)+1;
        rbs = unique(rbsubs);
        ports = unique(portsubs.');
        if (strcmpi(epdcch.EPDCCHType,'Localized'))
            codebookIdx = randi([0 3],1);
            W = lteDLPrecode(1,ntxants,'SpatialMux',codebookIdx);
        codebookIdxs = zeros(length(rbs),length(ports));
        for p=1:length(ports)
            thisport = (portsubs==ports(p));
            for r = 1:length(rbs)
                thisrb = (rbsubs==rbs(r));
                if (strcmpi(epdcch.EPDCCHType,'Distributed'))
                    unusedIdxs = setxor(0:3,codebookIdxs(r,1:p-1));
                    codebookIdx = unusedIdxs(randi(length(unusedIdxs),1));
                    W = lteDLPrecode(1,ntxants,'SpatialMux',codebookIdx);
                codebookIdxs(r,p) = codebookIdx;
                bfSymbols = allSymbols(thisport & thisrb) * W;
                [~,bfIndices] = lteExtractResources(allIndices(thisport & thisrb),subframe);
                subframe(bfIndices) = subframe(bfIndices) + bfSymbols;

        % Transmit CFI on the PCFICH
        subframe(ltePCFICHIndices(enb)) = ltePCFICH(enb,lteCFI(enb));

        % Transmit Cell-Specific Reference Signals (CRS)
        subframe(lteCellRSIndices(enb)) = lteCellRS(enb);

        % Transmit PSS and SSS
        subframe(ltePSSIndices(enb)) = ltePSS(enb);
        subframe(lteSSSIndices(enb)) = lteSSS(enb);

        % Add OCNG
        subframe = addOCNG(enb,epdcch,subframe);

        % Perform OFDM modulation
        [txwaveform,info] = lteOFDMModulate(enb,subframe);

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

        % Set channel time to current subframe
        channel.InitTime = sf/1000;

        % Reinitialize channel seed for each subframe to increase
        % variability
        channel.Seed = sf + 1;

        % 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(channel,[txwaveform; zeros(25,ntxants)]);

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

        % 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*ntxants*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
        if (enb.NSubframe==0)
            offset = lteDLFrameOffset(enb,rxwaveform);
            % Determine if frame synchronization was successful
            if (offset > 25)
                offset = offsets(end);
                offsets = [offsets offset]; %#ok
        if (offset>0)
            rxwaveform = rxwaveform(1+offset:end,:);

        % Perform OFDM demodulation
        rxsubframe = lteOFDMDemodulate(enb,rxwaveform);

        % Perform CRS-based (or perfect) channel estimation for PCFICH /
        % CFI reception
        if (perfectChannelEstimator)
            % Perform perfect channel estimation assuming the number of
            % transmit antennas is CellRefP (i.e. for CRS-based reception)
            hest = lteDLPerfectChannelEstimate(enb,channel,offset); %#ok<UNRCH>
            noiseGrid = lteOFDMDemodulate(enb,noise(1+offset:end ,:));
            nest = var(noiseGrid(:));
            % Perform channel estimation using the CRS. The channel
            % estimator averaging parameters are adjusted to use a
            % rectangular averaging window suited to the CRS, rather than
            % the 1-by-2 (frequency-by-time) window configured in 'cec'
            % which is suited to the EPDCCH DM-RS symbols (which are
            % adjacent in time).
            cec_crs = cec;
            cec_crs.Reference = 'CellRS';
            cec_crs.FreqWindow = 31;
            cec_crs.TimeWindow = 15;
            [hest,nest] = lteDLChannelEstimate(enb,cec_crs,rxsubframe);

        % Receive PCFICH / CFI
        pcfichIndices = ltePCFICHIndices(enb);
        [pcfichRx,pcfichHest] = lteExtractResources(pcfichIndices,rxsubframe,hest);
        rxCFI = lteCFIDecode(ltePCFICHDecode(enb,pcfichRx,pcfichHest,nest));

        % If the CFI was incorrectly decoded:
        if (rxCFI~=enb.CFI)

            % Record a misdetection of the CFI as a misdetection of the DCI
            % message (in 'mdsg'), in accordance with the test definition
            % in TS 36.101 Section 8.8. It is also recorded separately as a
            % misdetection of the CFI (in 'mcfi'). 'mcfi' can be used to
            % establish the probability of misdetection of the CFI on its
            % own. At low SNRs and for robust EPDCCH configurations (high
            % aggregation level), misdetection of the CFI may dominate the
            % overall misdetection of the DCI message.
            mdsg(SNRIdx,sf+1) = 1;
            mcfi(SNRIdx,sf+1) = 1;

        else % Proceed to EPDCCH / DCI decoding

            if (perfectChannelEstimator)
                if (ntxants~=enb.CellRefP) %#ok<UNRCH>
                    % Perform perfect channel estimation for 'ntxants'
                    % antennas (i.e. for EPDCCH reception) if this differs
                    % from CellRefP (used earlier for PCFICH/CFI reception)
                    hest = lteDLPerfectChannelEstimate(enb,channel,offset,ntxants);
                % Apply EPDCCH beamforming to the perfect channel estimate
                hest = beamformPerfectChannelEstimate(hest,rbs,ports,codebookIdxs);

            % Initialize array for received DCI message
            rxDCI = {};

            % Copy the structure 'epdcch' to 'epdcchRx' and remove fields
            % of 'epdcchRx' which are not required (they will be set during
            % decoding and search). This is not essential but provides
            % realism because |epdcchRx| then only contains system
            % information conveyed to the UE from the RRC
            epdcchRx = epdcch;
            epdcchRx = rmfield(epdcchRx,{'DCIFormat','EPDCCHFormat','EPDCCHECCE'});

            % For each EPDCCH set:
            for rxSetIndex = 1:numel(epdcchRx.EPDCCHTypeList)

                % Configure reception for current set
                epdcchRx.EPDCCHType = epdcchRx.EPDCCHTypeList{rxSetIndex};
                epdcchRx.EPDCCHPRBSet = epdcchRx.EPDCCHPRBSetList{rxSetIndex};

                if (~perfectChannelEstimator)
                    % Perform channel estimation using the EPDCCH DM-RS
                    [hest,nest] = lteDLChannelEstimate(enb,epdcchRx,cec,rxsubframe);

                % Perform EPDCCH demodulation
                [bits,symbols] = lteEPDCCHDecode(enb,epdcchRx,rxsubframe,hest,nest);

                % Perform EPDCCH blind search and DCI message decoding
                rxDCI = [rxDCI lteEPDCCHSearch(enb,epdcchRx,bits)]; %#ok<AGROW>


            % Record if the DCI message was missed; specifically if no DCI
            % messages were decoded or if none of the decoded messages
            % matched the transmitted message
            mdsg(SNRIdx,sf+1) = (isempty(rxDCI) || ~any(cellfun(@(x)isequal(x,dci),rxDCI)));



Simulating at -1.5dB SNR for a total of 1 Frame(s)

Simulating at 1dB SNR for a total of 1 Frame(s)

Simulating at 3.5dB SNR for a total of 1 Frame(s)

Calculate Probability of Missed Downlink Scheduling Grant (Pm-dsg)

The overall probability of missed downlink scheduling grant (Pm-dsg) is computed by averaging the mdsg matrix along its second dimension i.e. averaging each row, to produce a vector Pmdsg containing the Pm-dsg value for each SNR point tested.

Pmdsg = 100*mean(mdsg,2);

Plot Results

Finally, the test results are plotted. The probability of a missed downlink scheduling grant Pm-dsg is plotted for each SNR point. A marker is added at the target SNR and a Pm-dsg of 1%. A reference line is added for Pm-dsg of 1%, and observing the SNR at which the simulated performance crosses this line gives an indication of the SNR margin between the simulated performance and the test requirement.


The generated plot has been obtained with a low number of frames, therefore the results shown are not representative. A longer simulation obtained with 100 frames and including some additional SNR points produced the results shown below.

Selected Bibliography

  1. 3GPP TS 36.101 "User Equipment (UE) radio transmission and reception"
  2. 3GPP TS 36.211 "Physical channels and modulation"
  3. 3GPP TS 36.213 "Physical layer procedures"
  4. 3GPP TS 36.331 "Radio Resource Control (RRC) Protocol specification"

Local Functions

The following local functions are used in this example:

  • beamformPerfectChannelEstimate: apply EPDCCH beamforming to the perfect channel estimate
  • addOCNG: add EPDCCH OCNG to the subframe resource grid
  • plotResults: plot the results of the test
function hest = beamformPerfectChannelEstimate(hestperfect,rbs,ports,codebookIdxs)

    [K,L,nrxants,ntxants] = size(hestperfect);
    hest = zeros([K L nrxants 4]);
    for r = 1:length(rbs)
        resubs = (rbs(r)-1)*12 + (1:12).';
        allportW = zeros(4,ntxants);
        activeportW = arrayfun(@(x)lteDLPrecode(1,ntxants,'SpatialMux',x),codebookIdxs(r,:),'UniformOutput',false);
        allportW(ports,:) = cat(1,activeportW{:});
        hest(resubs,:,:,:) = reshape(reshape(hestperfect(resubs,:,:,:),[12*L*nrxants ntxants])*allportW.',[12 L nrxants 4]);


function subframe = addOCNG(enb,epdcch,subframe)

    % Add OP.7 OCNG (TS 36.101 Annex A.5.1.7). Consists of a single PDSCH
    % in all resource blocks not used by the EPDCCH.
    ocngPdsch.Modulation = 'QPSK';
    ocngPdsch.RNTI = 0;
    if (enb.CellRefP==1)
        ocngPdsch.TxScheme = 'Port0';
        ocngPdsch.TxScheme = 'TxDiversity';
    ocngPRBs = setdiff((0:enb.NDLRB-1).',epdcch.EPDCCHPRBSet);
    [ocngPdschInd,ocngPdschInfo] = ltePDSCHIndices(enb,ocngPdsch,ocngPRBs);
    ocngPdschData = randi([0 1],1,ocngPdschInfo.G);
    ocngPdschPower = -3.0; % rho + sigma = -3.0 + 0.0
    ocngPdschSym = ltePDSCH(enb,ocngPdsch,ocngPdschData)*(10^(ocngPdschPower/20));
    subframe(ocngPdschInd) = ocngPdschSym;

    % Add control region OCNG reference channel (TS 36.101 Annex A.5).
    % Includes PDCCH and PHICH locations but avoids PCFICH locations, to
    % allow the CFI to be transmitted
    pcfichRegInd = ltePCFICHIndices(enb,'reg');
    enbPdcch = enb;
    enbPdcch.PHICHDuration = 'Normal';
    enbPdcch.Ng = 'Sixth';
    exreg = pcfichRegInd(:,1);
    ocngPdcchInd = ltePDCCHIndices(enbPdcch,exreg);
    NRE = size(ocngPdcchInd,1);
    ocngPdcchData = randi([0 1],1,NRE*2);
    ocngPdcchPower = -3.0; % rho + sigma = -3.0 + 0.0
    ocngPdcchSym = ltePDCCH(enbPdcch,ocngPdcchData,NRE/4)*(10^(ocngPdcchPower/20));
    subframe(ocngPdcchInd) = ocngPdcchSym;


function plotResults(SNRIn,targetSNR,nFrames,Pmdsg)

    if (nFrames==1)
        frameStr = '1 frame';
        frameStr = [num2str(nFrames) ' frames'];
    title(sprintf('Probability of missed downlink scheduling grant\nfor %s',frameStr));
    xlabel('SNR (dB)'); ylabel('Pm-dsg (%)');
    grid on;
    hold on;
    plot(SNRIn, ones(1,numel(SNRIn)),'--r');
    legend('Simulation Result',sprintf('Target: 1%% Pm-dsg @ %0.1fdB SNR',targetSNR),'Location','NorthEast');
    xlim([min(SNRIn)-0.5 max(SNRIn)+0.5]);
    ylim([fix(min(Pmdsg)-2) fix(max(Pmdsg)+2)]);