LTE-based 5G Broadcast PMCH Throughput Simulation

R2026b

Since R2026b

This reference simulation measures the link-level throughput and BLER of the physical multicast channel (PMCH), including MCH transport channel coding and Release 19 time-frequency interleaving (TFI).

Introduction

Release 19 of the 3GPP LTE specification introduces time-frequency interleaving into LTE-based 5G terrestrial broadcast for MBMS-dedicated cells. This significantly improves the transmission performance in time-varying (e.g., mobile reception) and frequency-selective (e.g., SFN deployments) channels, especially in high-mobility scenarios [1].

The time interleaving part of 5G Broadcast TFI follows the principles of 5G NR TBoMS (transport block processing over multi-slot). One transport block (TB) is mapped to a set of non-consecutive subframes and the transport block size (TBS) is scaled by the number of subframes in the set. The transmissions in each of these subframes use a different HARQ retransmission and soft combining is used at the UE receiver. The transmission subframes associated with multiple TB can be interleaved together to form an overall interleaved depth of up to 512 ms.

The frequency interleaving part of the TFI employs a block matrix interleaver. The data for a single OFDM symbol is first written in column-wise. Then both the rows and elements of a row can be permutated based on a choice of algorithm. Finally the data is read out row-wise.

Simulation Configuration

In terms of 3GPP test specification, the PMCH minimum performance requirements are defined in TS 36.101 and the conformance performance specifications are defined in TS 36.521-1. This reference simulation includes the parameter configurations for the reference measurement channels for PMCH performance for LTE-based 5G terrestrial broadcast MBMS dedicated cells which includes time-frequency interleaving. These are R.108-1 FDD and R.108-2 FDD defined for 8 MHz channel bandwidth and 1.25 kHz subcarrier spacing, as specified in TS 36.101 Table A.3.8.1-11. However, the example can be parameterized for any MBSFN carrier bandwidth and subcarrier spacing combinations, and any PMCH configuration, with and without TFI.

The simulation uses the subcarrier spacing-dependent MBSFN propagation channel models (TS 36.101 Annex B.2.6), defined for multi-path fading in extended delay spread environments. Perfect channel estimation is used for the throughput results but MBSFN reference signals are transmitted alongside the PMCH.

The simulation runs for a small number of slots. For accurate BLER results, increase the number of slots.

To reduce the total simulation time, you can execute the SNR points in the SNR loop in parallel by using parfor from the Parallel Computing Toolbox™ product. This requires commenting and uncommenting lines of code at the start of the main SNR simulation loop.

Simulation Configuration

simParameters = struct();

% Cell-wide settings
simParameters.NDLRB = 40;
simParameters.SubcarrierSpacing = 15;
simParameters.NMBSFNID = 1;
simParameters.NonMBSFNRegionLength = 2; % For 15 kHz SCS only
simParameters.MBSFNRSType = 1; % For 0.37 kHz SCS only

% PMCH settings
simParameters.PMCH.Modulation = "16QAM";
simParameters.PMCH.ITBS = 4;  % 0 to 37 
% PMCH TFI related parameters
simParameters.PMCH.PMCHTimeInterleavingN = 1;
simParameters.PMCH.PMCHTimeInterleavingM = 4;
simParameters.PMCH.PMCHFreqInterleaving = "Off";
simParameters.PMCH.CyclicShiftAlpha = 1;

% Additional simulation parameters
simParameters.NRxAnts = 1;
simParameters.DopplerFreq = 50;

% SNR range in dB
simParameters.SNRIn = (0:8) - 7*(simParameters.NRxAnts > 1);

% Simulation length
simParameters.NumSubframes = 200;

% Display low-level information about the simulation progress
simParameters.DisplaySimulationInformation =false;

Select a PMCH reference measurement channel

% Apply a PMCH RMC configuration (TS 36.101) on top of the simulation parameters
ApplyRMC = {'R.108-1',0};

% Assign the associated cell-wide and PMCH-specific parameters, as required
switch ApplyRMC{1}
    case 'R.108-1'
        % Cell-wide settings
        simParameters.NDLRB = 40; % 8 MHz
        simParameters.SubcarrierSpacing = 1.25;
        % PMCH-specific settings
        simParameters.PMCH.Modulation = '16QAM';
        simParameters.PMCH.ITBS = 11;
        simParameters.PMCH.PMCHTimeInterleavingM = 8;
        simParameters.PMCH.PMCHTimeInterleavingN = 4;
        simParameters.PMCH.PMCHFreqInterleaving = 'on';    
        % Adjust the SNR range depending on the number of receive antennas
        if simParameters.NRxAnts == 1
            SNRdBRange = 4:11;  % 1 Rx ant
        else
            SNRdBRange = -2:3;  % 2 Rx ants 
        end
        configupdated = 1;
    case 'R.108-2'
        % Cell-wide settings
        simParameters.NDLRB = 40; % 8 MHz
        simParameters.SubcarrierSpacing = 1.25;
        % PMCH-specific settings
        simParameters.PMCH.Modulation = 'QPSK';
        simParameters.PMCH.ITBS = 4;
        simParameters.PMCH.PMCHTimeInterleavingM = 32;
        simParameters.PMCH.PMCHTimeInterleavingN = 16;
        simParameters.PMCH.PMCHFreqInterleaving = 'on';   
        % Adjust the SNR range depending on the number of receive antennas
        if simParameters.NRxAnts == 1
            SNRdBRange = -2:2;      % 1 Rx ant
        else
            SNRdBRange = -9:0.5:-6; % 2 Rx ants
        end
        configupdated = 1;
    otherwise
        configupdated = 0;
end
% Wrap up
if configupdated
    % Update the SNR range
    simParameters.SNRIn = SNRdBRange;
    % Turn off the TFI if required
    if ApplyRMC{2}
        simParameters.PMCH.PMCHTimeInterleavingM = 1;
        simParameters.PMCH.PMCHTimeInterleavingN = 1;
        simParameters.PMCH.PMCHFreqInterleaving = 'off';
        addtxt = 'without TFI enabled';
    else
        addtxt = '';
    end
    fprintf('Using %s PMCH reference measurement channel %s',ApplyRMC{1},addtxt);
end

Using R.108-1 PMCH reference measurement channel 

MBSFN Propagation Channel Model Configuration

% TS 36.101 Annex B.2.6 'MBSFN Propagation Channel Profile' models,
% which are dependent on the SCS used so this must be called
% after the subcarrier spacing is finalized
simParameters.ChannelModel = hMBSFNChannel(simParameters);
% Override default channel settings as required
simParameters.ChannelModel.DopplerFreq = simParameters.DopplerFreq;
simParameters.ChannelModel.NRxAnts = simParameters.NRxAnts;

Throughput Simulation

Simulation Initialization

% Add in required carrier-specific settings, compatible with MBMS 
simParameters.CyclicPrefix = 'extended';
simParameters.CellRefP = 1;
simParameters.NSubframe = -1;

% Optional channel specific parameters
simParameters.PMCH.NTurboDecIts = 5;  % Same as default value

% Determine the TBS from the I_TBS 
[tbs,tbs0] = hTBSPMCH(simParameters,simParameters.PMCH,simParameters.PMCH.ITBS);
% Store the derived TBS value
simParameters.PMCH.TBS = tbs;

% Finalize the channel model parameters, aligning with the OFDM waveform sample rate
ofdmInfo = lteOFDMInfo(simParameters);
simParameters.ChannelModel.SamplingRate = ofdmInfo.SamplingRate;
% Get the channel delays for use later (multipath and channel filtering)
[~,fchInfo] = lteFadingChannel(simParameters.ChannelModel,0);
filterChDelay = fchInfo.ChannelFilterDelay;
maxChDelay = ceil(max(fchInfo.PathSampleDelays)) + filterChDelay;

% Calculate the equivalent AWGN noise gain for the SNR points, normalizing to take 
% account of sampling rate, which is a function of the IFFT size used in OFDM modulation, 
% and the number of receive antennas
SNRLinear = 10.^(simParameters.SNRIn/20);
N0 = 1./(sqrt(2.0*simParameters.ChannelModel.NRxAnts*double(ofdmInfo.Nfft))*SNRLinear); 

% Calculate the sequence of IDs and RVs associated with the PMCH transmitted
% in a time interleaved block. If no time interleaving then single ID and RV = 0
N = simParameters.PMCH.PMCHTimeInterleavingN;
tfioff = isempty(N) || N <= 1;
if ~tfioff && simParameters.SubcarrierSpacing == 0.37
    warning('Time-frequency interleaving is not applicable to 0.37 kHz SCS and is not being applied.');
    tfioff = 1;
end
if tfioff
    % These values signal that time interleaving is off
    N = 1;
    simParameters.PMCH.PMCHTimeInterleavingN = 1;
    simParameters.PMCH.PMCHTimeInterleavingM = 1;
end
M = simParameters.PMCH.PMCHTimeInterleavingM;
pmchidSequence = repmat(1:M,1,N);       % ID = 1 2 3, 1 2 3, 1 2...
pmchrvSequence = kron(0:N-1,ones(1,M)); % RV = 0 0 0, 1 1 1, 2 2...

% Time interval between PMCH transmissions 
pmchtti = (1+2*(simParameters.SubcarrierSpacing==0.37))*1e-3; % 1ms subframe or a 3ms slot when SCS = 0.37 kHz

% Simulation length, in terms of number of blocks of PMCH transmissions
numblocks = ceil(simParameters.NumSubframes/(M*N));

% Storage for the overall simulation results
numsnrpts = numel(simParameters.SNRIn);
bler = zeros(1,numsnrpts);
throughput = zeros(1,numsnrpts);
allblkerrors = zeros(numsnrpts,numblocks*M);

Main SNR Loop

% Simulation configuration summary
disp(join(["PMCH Throughput Simulation Configuration:" simSummary(simParameters)],newline));

PMCH Throughput Simulation Configuration:
NDLRB = 40, SCS = 1.25 kHz
PMCH Mod = 16QAM, ITBS = 11 (TBS = 31704)
TFI On (M = 8, N = 4, Alpha = 1, Freq Interleaving = on)
Max Ch Delay = 111 us, Doppler = 50 Hz, 1x1 Low

for s = 1:numel(simParameters.SNRIn)   % comment out for parallel computing
% parfor s = 1:numel(simParameters.SNRIn)  % uncomment for parallel computing
% To reduce the total simulation time, you can execute this loop in
% parallel by using the Parallel Computing Toolbox. Comment out the 'for'
% statement and uncomment the 'parfor' statement. If the Parallel Computing
% Toolbox is not installed, 'parfor' defaults to normal 'for' statement.
% Because parfor-loop iterations are executed in parallel in a
% nondeterministic order, the simulation information displayed for each SNR
% point can be intertwined. To switch off simulation information display,
% set the 'displaySimulationInformation' variable above to false

    % Reset the random number generator so that each SNR point
    % experiences the same noise realization
    rng('default');

    % Take local copies to help with PCT variable classification, broadcast variables etc.
    enb = simParameters;
    chs = simParameters.PMCH;
    channelmodel = simParameters.ChannelModel;
    pmchid = pmchidSequence;
    pmchrv = pmchrvSequence;
    SNRdB = simParameters.SNRIn;
    
    numpmchperblock = numel(pmchid);

    fprintf('Simulating PMCH at %g dB SNR (#%d/%d) for %d subframes/slots\n',SNRdB(s),s,numel(SNRdB),numblocks*numpmchperblock);

    numblkerrors = 0;
    blkerrors = zeros(1,numblocks*M);
    dstateset = repmat(struct(CBSBuffers=[],CBSCRC=[],BLKCRC=[],LastRV = 0),1,M);

    for b = 1:numblocks
    
        % Get new transport data for this block of PMCH transmissions
        trblkdata = randi([0 1],[tbs M]);
    
        % Reset soft buffers of the MCH transport channel decoders
        [dstateset.CBSBuffers] = deal([]);
        [dstateset.BLKCRC] = deal(1);
        [dstateset.LastRV] = deal(0);
    
        % Process all the transmissions in this block of PMCH
        for i = 1:numpmchperblock
      
            enb.NSubframe = enb.NSubframe + 1;
           
            dstate = dstateset(pmchid(i));
        
            % Only continue to send/receive this PMCH in its RV sequence
            % if it has not previously passed, otherwise skip it for speed
            if dstate.BLKCRC

                % Set the RV value
                chs.RV = pmchrv(i);

                % Get the PMCH resource indices
                [dataInd,chinfo] = hPMCHIndices(enb,chs);
                cwlen = chinfo.G;
    
                % MCH encode
                [cw,estate] = hMCH(chs,cwlen,trblkdata(:,pmchid(i)));
            
                % PMCH encode
                symbs = ltePMCH(enb,chs,tbs,cw);
                
                % Map PMCH and MBSFN RS resources
                sfgrid = lteResourceGrid(enb);
                sfgrid(dataInd) = symbs;
    
                % For completeness, map the MBSFN reference signals as well
                rsSym = hMBSFNRS(enb);
                rsInd = hMBSFNRSIndices(enb);
                sfgrid(rsInd) = rsSym;
                
                % OFDM Modulation 
                basebandiq = lteOFDMModulate(enb,sfgrid);
            
                % Fading propagation channel
                channelmodel.InitTime = enb.NSubframe*pmchtti; % Set channel offset to current frame (1 frame = 10ms)
                rxWaveform = lteFadingChannel(channelmodel,[basebandiq; zeros(maxChDelay,1)]);
        
                % Create additive white Gaussian noise
                noise = N0(s)*complex(randn(size(rxWaveform)),randn(size(rxWaveform)));
    
                % Add AWGN to the received time domain waveform        
                rxWaveform = rxWaveform + noise;
    
                % Perfect channel and noise estimation
                enb.TotSubframes = 1; % Length of the estimate required here
                offset = filterChDelay;
                hest = lteDLPerfectChannelEstimate(enb,channelmodel,offset);
                noiseGrid = lteOFDMDemodulate(enb, noise(1+offset:end ,:));
                noiseest = var(noiseGrid(:));
            
                % Trim waveform
                rxWaveform = rxWaveform(1+offset:end,:);

                % OFDM demodulation 
                rxgrid = lteOFDMDemodulate(enb,rxWaveform);
            
                % Extract PMCH resources and associated channel estimates
                [rxsymbs,hest] = lteExtractResources(dataInd,rxgrid,hest);
                
                % PMCH decode
                rxcw = ltePMCHDecode(enb,chs,tbs,rxsymbs,hest,noiseest);
            
                % MCH decode
                [trblkout,err,dstate] = hMCHDecode(chs,tbs,rxcw,dstate);
                dstate.LastRV = chs.RV;
            
                % Write back the updated decoder state into the set
                dstateset(pmchid(i)) = dstate;

                extratxt = '';
            else
                extratxt = sprintf(' (Block passed at RV idx = %d)',dstate.LastRV);
            end
    
            if enb.DisplaySimulationInformation
                fprintf('PMCH #%2d, RV idx = %2d, CBSCRC = %s, TBCRC = %d%s\n',...
                    pmchid(i)-1,pmchrv(i),mat2str(double(dstate.CBSCRC)),double(dstate.BLKCRC),extratxt);
            end
        end
    
        % Record the results for this block of transmissions
        blkcrcs = [dstateset.BLKCRC];
        numblkerrors = numblkerrors + sum(blkcrcs);
        blkerrors((b-1)*M+1:b*M) = blkcrcs;

    end 

    % Record simulation results for the SNR point
    blksent = numblocks*M;
    bler(s) = numblkerrors/blksent;
    throughput(s) = 100*(blksent-numblkerrors)/blksent;
    allblkerrors(s,:) = blkerrors;

    averageRV = mean([dstateset.LastRV]);   
end

Simulating PMCH at 4 dB SNR (#1/8) for 224 subframes/slots
Simulating PMCH at 5 dB SNR (#2/8) for 224 subframes/slots
Simulating PMCH at 6 dB SNR (#3/8) for 224 subframes/slots
Simulating PMCH at 7 dB SNR (#4/8) for 224 subframes/slots
Simulating PMCH at 8 dB SNR (#5/8) for 224 subframes/slots
Simulating PMCH at 9 dB SNR (#6/8) for 224 subframes/slots
Simulating PMCH at 10 dB SNR (#7/8) for 224 subframes/slots
Simulating PMCH at 11 dB SNR (#8/8) for 224 subframes/slots

% Combine simulation parameters and results into a single structure for recording
simResults = struct();
simResults.simParameters = simParameters;
simResults.simThroughput = throughput;
simResults.simBLER = bler;
simResults.blockErrors = allblkerrors;

Results

Display the PMCH simulation results.

plotResults(simResults);

Selected Bibliography

1. 3GPP TR 21.919. "Release 19 Description; Summary of Rel-19 Work Items." 3rd Generation Partnership Project; Technical Specification Group Services and System Aspects.

Local Functions

function simsum = simSummary(simparams)
% Create a text summary of the simulation configuration

    % Extract the parameter parts for ease of reference
    pmch = simparams.PMCH;
    chmodel = simparams.ChannelModel;

    if pmch.PMCHTimeInterleavingN == 1
        tfitxt = "TFI Off";
    else
        tfitxt = sprintf("TFI On (M = %d, N = %d, Alpha = %d, Freq Interleaving = %s)",pmch.PMCHTimeInterleavingM,pmch.PMCHTimeInterleavingN,pmch.CyclicShiftAlpha,pmch.PMCHFreqInterleaving);
    end
    carrytxt = sprintf("NDLRB = %s, SCS = %0.3g kHz",string(simparams.NDLRB),simparams.SubcarrierSpacing);
    pmchtxt = sprintf("PMCH Mod = %s, ITBS = %d (TBS = %d)",pmch.Modulation,pmch.ITBS,pmch.TBS);
    chtxt = sprintf("Max Ch Delay = %d us, Doppler = %d Hz, 1x%d %s",fix(max(chmodel.PathDelays)*1e6),chmodel.DopplerFreq,chmodel.NRxAnts,chmodel.MIMOCorrelation);
    simsum = [carrytxt,pmchtxt,tfitxt,chtxt];
end

function plotResults(sres)
% Display simulation BLER and throughput results

    sim = sres.simParameters;
    stitletxt = simSummary(sim);

    % BLER plot
    figure;
    semilogy(sim.SNRIn,sres.simBLER,'o-');
    [snrlb, snrub]=bounds(sim.SNRIn);
    if snrub > snrlb
        ax = axis; axis([snrlb snrub ax(3:4)]); % Fix the range of the SNR x-axis (semilogy might have rescaled it for SNR points with no errors)
    end
    xlabel('SNR (dB)'); ylabel('Block Error Rate'); grid on;
    title('PMCH BLER')
    subtitle(stitletxt,FontSize=9);
    
    % Throughput plot
    figure;
    plot(sim.SNRIn,sres.simThroughput,'o-');
    xlabel('SNR (dB)'); ylabel('Throughput (%)'); grid on;
    title('PMCH Throughput')
    subtitle(stitletxt,FontSize=9);
    
    % Block errors across the simulation
    figure;
    image(100*sres.blockErrors);
    axis xy;
    xlabel('Complete Block Transmissions'); ylabel('SNR (dB)');
    yticks(0:numel(sim.SNRIn)+1);
    yticklabels(["" string(sim.SNRIn) ""]);
    title('Transport Block Errors');
end