rng('default'); % Reset the random number generator
simParameters = []; % Clear simParameters variable
simParameters.NumFramesSim = 100; % Simulation time in terms of number of 10 ms frames

% Number of UEs in the simulation. UEs are assumed to have sequential radio
% network temporary identifiers (RNTIs) from 1 to NumUEs. If you change the
% number of UEs, ensure that the following simulation parameters are array
% of length equal to NumUEs: simParameters.UEDistance,
% simParameters.ULPacketPeriodicityUEs, simParameters.ULPacketSizesUEs,
% simParameters.DLPacketPeriodicityUEs, simParameters.DLPacketSizesUEs,
% simParameters.RLCConfig.SNFieldLength,
% simParameters.RLCConfig.ReassemblyTimer,
% simParameters.RLCConfig.MaxTxBufferLength
simParameters.NumUEs = 4;

% Set the value of scheduling type to 0 (slot based scheduling) or 1
% (symbol based scheduling). If value is not set, the default value is 0
simParameters.SchedulingType = 1;

% Set the minimum time-domain assignment in terms of symbol duration.
% Applicable only for symbol based scheduling. For slot based scheduling,
% it is always full slot (14 symbols)
simParameters.TTIGranularity = 4;

% Define the TDD DL-UL pattern. The reference subcarrier spacing used for
% calculating slot duration for the pattern is assumed to be same as actual
% subcarrier spacing used for transmission as defined by simParameters.SCS.
% Keep only the symbols intended for guard period during DLULPeriodicity
% with type (DL or UL) unspecified
simParameters.DLULPeriodicity = 5; % Duration of the DL-UL pattern in ms
simParameters.NumDLSlots = 2; % Number of consecutive full DL slots at the beginning of each DL-UL pattern
% Define the number of consecutive DL symbols following the full DL slots
% and the number of consecutive UL symbols preceding the full UL slots. In
% the case of slot based scheduling, only simParameters.NumDLSyms is
% applicable and it defines the number of DL symbols at the start of the
% slot, while the remaining symbols of the slot are assumed to be allotted
% for guard period
simParameters.NumDLSyms = 8; % Number of consecutive DL symbols in the beginning of the slot following the last full DL slot
simParameters.NumULSyms = 4; % Number of consecutive UL symbols in the end of the slot preceding the first full UL slot
simParameters.NumULSlots = 2; % Number of consecutive full UL slots at the end of each DL-UL pattern

simParameters.UEDistance = [100; 400; 300; 700]; % Distance of UEs from gNB (in meters)
% Mapping between distance from gNB (first column in meters) and maximum
% achievable UL CQI value (second column). For example, if a UE is 700
% meters away from the gNB, it can achieve a maximum CQI value of 10 as the
% distance falls within the [501, 800] meters range, as per the mapping.
% Set the distance in increasing order and the maximum achievable CQI value
% in decreasing order
simParameters.CQIvsDistance = [
    200  15;
    500  12;
    800  10;
    1000  8;
    1200  7];

% Set the periodic UL and DL application traffic pattern for UEs
simParameters.ULPacketPeriodicityUEs = [20; 30; 20; 30]; % Periodicity at which the UL packets are generated by UEs
simParameters.ULPacketSizesUEs = [2000; 3000; 1500; 3000]; % Size of the UL packets (in bytes) generated by UEs
simParameters.DLPacketPeriodicityUEs = [20; 15; 15; 20]; % Periodicity at which the DL packets are generated for UEs at gNB
simParameters.DLPacketSizesUEs = [4000; 2500; 2500; 2000]; % Size of the DL packets generated (in bytes) for UEs at gNB

% RLC configuration
simParameters.RLCConfig.SNFieldLength = [6; 6; 6; 6]; % Sequence number field length (in bits) of the logical channel for each UE
simParameters.RLCConfig.ReassemblyTimer = [5; 5; 5; 5]; % Reassembly timer (in ms) of the logical channel for each UE
% Max buffer length of the logical channel for each UE (to model Tx buffer overflow)
simParameters.RLCConfig.MaxTxBufferLength = [100000; 200000; 200000; 200000];

% MAC configuration
simParameters.SchedulerStrategy = 'PF'; % Supported scheduling strategies: 'PF', 'RR' and 'BestCQI'
% PUSCH preparation time. gNB ensures that PUSCH assignment is received at
% UEs PUSCHPrepTime ahead of the transmission time
simParameters.PUSCHPrepTime = 200; % In microseconds
% Moving average weight parameter within the range [0, 1] calculates
% average data rate for a UE. The value is used in the PF scheduling strategy.
% Parameter value closer to 1 implies more weight on the instantaneous
% data rate. Parameter value closer to 0 implies more weight on the past
% data rate
% AverageDataRate = ((1-MovingAvgDataRateWeight)*PastDataRate) + (MovingAvgDataRateWeight*InstantaneousDataRate)
simParameters.MovingAvgDataRateWeight = 0.5;
simParameters.EnableHARQ = true; % Flag to enable or disable HARQ. If disabled, there are no retransmissions
simParameters.NumHARQ = 16; % Number of UL and DL HARQ processes for each UE
% Maximum RBs allotted to a UE for PUSCH and PDSCH transmissions (limit is
% applicable for new transmission assignments and not for the retransmissions)
simParameters.RBAllocationLimitUL = 15; % For PUSCH
simParameters.RBAllocationLimitDL = 15; % For PDSCH
simParameters.BSRPeriodicity = 1; % Buffer status report transmission periodicity (in ms)

% Physical layer and channel configuration
% RB count for 5 MHz band with 15 kHz subcarrier spacing (SCS). The complete
% bandwidth is assumed to be allotted for PUSCH/PDSCH
simParameters.NumRBs = 25;
simParameters.SCS = 15;
% Configure parameters to update channel conditions for the UEs. Channel
% quality is periodically improved or deteriorated by CQIDelta every
% channelUpdatePeriodicity seconds for all RBs of a UE. Whether channel
% conditions for a particular UE improve or deteriorate is randomly
% determined: RB_CQI = RB_CQI +/- CQIDelta
simParameters.ChannelUpdatePeriodicity = 0.2; % In sec
simParameters.CQIDelta = 1;
% Expression to calculate reception success probability of a PUSCH/PDSCH
% packet based on the channel quality. 'x' represents the average CQI of
% the RBs over which the packet is received
simParameters.CQISuccessProb = '.5 + (x/20)';

% Logging and visualization configuration
% Flag to enable or disable runtime CQI visualization
simParameters.CQIVisualization = true;
% Flag to enable or disable run time visualization of RB assignment. If enabled,
% then for slot based scheduling it updates every frame (10 ms) to show RB
% allocation to the UEs for different slots of the last frame. For
% symbol based scheduling, it updates every slot to show RB allocation to
% the UEs over different symbols of the last slot
simParameters.RBVisualization = false;
% The output metrics plots are updated periodically NumMetricsSteps times within the
% simulation duration
simParameters.NumMetricsSteps = 20;
% MAT-files to write the logs into. They are used for post simulation analysis and visualization
simParameters.ParametersLogFile = 'simParameters'; % For logging the simulation parameters
simParameters.SimulationLogFile = 'simulationLogs'; % For logging the simulation logs

hNRSchedulingTDDValidateConfig(simParameters); % Validate the simulation configuration

simParameters.DuplexMode = 1; % TDD (Example specific constant)
simParameters.NumLogicalChannels = 1; % Only 1 logical channel is assumed in each UE (Example specific constant)
slotDuration = 1/(simParameters.SCS/15); % Slot duration in ms
numSlotsFrame = 10/slotDuration; % Number of slots in 10 ms frame
numSlotsSim = simParameters.NumFramesSim * numSlotsFrame; % Simulation time in units of slot duration
numSymbolsSim = numSlotsSim * 14; % Simulation time in units of symbol duration
% Interval at which metrics visualization updates in terms of number of
% slots. Make sure that MetricsStepSize is an integer
simParameters.MetricsStepSize = ceil(numSlotsSim / simParameters.NumMetricsSteps);
if mod(numSlotsSim, simParameters.NumMetricsSteps) ~= 0
    % Update the NumMetricsSteps parameter if numSlotsSim is not
    % completely divisible by it
    simParameters.NumMetricsSteps = floor(numSlotsSim / simParameters.MetricsStepSize);
end

% DL and UL packet periodicities for UEs in terms of number of slots
appPeriodicityUEsSlotsUL = simParameters.ULPacketPeriodicityUEs ./ slotDuration;
appPeriodicityUEsSlotsDL = simParameters.DLPacketPeriodicityUEs ./ slotDuration;

% Mapping between logical channel and logical channel group id
simParameters.LCHConfig.LCGID = ones(simParameters.NumUEs, simParameters.NumLogicalChannels);
% Priority of each logical channel 
simParameters.LCHConfig.Priority = ones(simParameters.NumUEs, simParameters.NumLogicalChannels);
% Prioritized bitrate (in kilo bytes per second) of each logical channel
simParameters.LCHConfig.PBR = 8*ones(simParameters.NumUEs, simParameters.NumLogicalChannels);
% Bucket size duration (in ms) of each logical channel. However, the priority,
% PBR and BSD for logical channel is not relevant with single logical
% channel assumed in this example
simParameters.LCHConfig.BSD = 10*ones(simParameters.NumUEs, simParameters.NumLogicalChannels);
% Logical channel id
simParameters.LCHConfig.LCID = ones(simParameters.NumUEs, simParameters.NumLogicalChannels) .* (1:simParameters.NumLogicalChannels);

% RLC entity direction. Value 0 represents DL only, 1
% represents UL only and 2 represents both UL and DL
% direction. Setting entity direction to have both UL and DL
simParameters.RLCConfig.EntityDir = 2*ones(simParameters.NumUEs, simParameters.NumLogicalChannels);
% Construct information for RLC logger
lchInfo = repmat(struct('LCID',[],'EntityDir',[]), [simParameters.NumUEs 1]);
for idx=1:simParameters.NumUEs
    lchInfo(idx).LCID = simParameters.LCHConfig.LCID(idx, :);
    lchInfo(idx).EntityDir = simParameters.RLCConfig.EntityDir(idx, :);
end
% Maximum RLC SDU length (in bytes)
simParameters.maxRLCSDULength = 9000;

% Calculate maximum achievable CQI value for the UEs based on their distance
% from the gNB
maxUECQIs = zeros(simParameters.NumUEs, 1); % To store the maximum achievable CQI value for UEs
for ueIdx = 1:simParameters.NumUEs
    % Based on the distance of the UE from gNB, find matching row in CQIvsDistance mapping
    matchingRowIdx = find(simParameters.CQIvsDistance(:, 1) > simParameters.UEDistance(ueIdx));
    if isempty(matchingRowIdx)
        maxUECQIs(ueIdx) = simParameters.CQIvsDistance(end, 2);
    else
        maxUECQIs(ueIdx) = simParameters.CQIvsDistance(matchingRowIdx(1), 2);
    end
end

% Periodicity of channel update in terms of number of slots
channelUpdatePeriodicitySlots = floor((simParameters.ChannelUpdatePeriodicity * 1000)/...
    slotDuration);
% Update periodicity of RB assignment visualization in terms of number of slots
if ~isfield(simParameters, 'SchedulingType') || simParameters.SchedulingType == 0 % If no scheduling type is specified or slot based scheduling is specified
    rbAssignmentPlotPeriodicity = numSlotsFrame; % Update every frame (10 ms)
else % Symbol based scheduling
    rbAssignmentPlotPeriodicity = 1; % Update every slot
end

gNB = hNRGNB(simParameters); % Create the gNB node
scheduler = hNRGNBMACScheduler(simParameters); % Create MAC scheduler
addScheduler(gNB, scheduler); % Add scheduler to gNB

% Create the set of UE nodes
UEs = cell(simParameters.NumUEs, 1); 
for ueIdx=1:simParameters.NumUEs
    UEs{ueIdx} = hNRUE(simParameters, ueIdx);
end

% Define initial UL and DL channel quality as an N-by-P matrix,
% where N is the number of UEs and P is the number of RBs in the carrier
% bandwidth. The initial value of CQI for each RB, for each UE, is given
% randomly and is limited by the maximum achievable CQI value corresponding
% to the distance of the UE from gNB
for ueIdx = 1:simParameters.NumUEs
    % Assign random CQI values for the RBs, limited by the maximum achievable CQI value
    uplinkChannelQuality = randi([1 maxUECQIs(ueIdx)], 1, simParameters.NumRBs);
    downlinkChannelQuality = uplinkChannelQuality; % For TDD, UL and DL channel quality are same
    % Update the UL and DL CQI values at gNB with respect to UE. gNB uses
    % UL CQI values to calculate UL packet reception success probability
    % and for channel quality based UL assignments. It uses DL channel
    % quality for channel quality based DL assignments
    updateChannelQualityStatus(gNB, uplinkChannelQuality, 1, ueIdx); % 1 represents UL direction
    updateChannelQualityStatus(gNB, downlinkChannelQuality, 0, ueIdx); % 0 represents DL direction
    % Update the DL CQI values at UE. UE uses DL channel quality to calculate DL packet reception success probability
    updateChannelQualityStatus(UEs{ueIdx}, downlinkChannelQuality);
end

% Setup the logical channel
lcid = 1;
for ueIdx=1:simParameters.NumUEs
    % Create RLC channel configuration structure
    rlcChannelConfigStruct.LCID = simParameters.LCHConfig.LCID(ueIdx, lcid);
    rlcChannelConfigStruct.SnFieldLength = simParameters.RLCConfig.SNFieldLength(ueIdx, lcid);
    rlcChannelConfigStruct.MaxTxBufferLength = simParameters.RLCConfig.MaxTxBufferLength(ueIdx, lcid);
    rlcChannelConfigStruct.ReassemblyTime = simParameters.RLCConfig.ReassemblyTimer(ueIdx, lcid);
    rlcChannelConfigStruct.EntityDir = simParameters.RLCConfig.EntityDir(ueIdx, lcid);
    rlcChannelConfigStruct.LCGID = simParameters.LCHConfig.LCGID(ueIdx, lcid);
    rlcChannelConfigStruct.Priority = simParameters.LCHConfig.Priority(ueIdx, lcid);
    rlcChannelConfigStruct.PBR = simParameters.LCHConfig.PBR(ueIdx, lcid);
    rlcChannelConfigStruct.BucketSizeDuration = simParameters.LCHConfig.BSD(ueIdx, lcid);
    % Setup logical channel at gNB for the UE
    configureLogicalChannel(gNB, ueIdx, rlcChannelConfigStruct);
    % Setup logical channel at UE
    configureLogicalChannel(UEs{ueIdx}, ueIdx, rlcChannelConfigStruct);
end

% Initialize buffers to exchange packets between UEs and gNB
hNRPacketExchangeBuffer(simParameters);

% To store the following UE metrics for each symbol: throughput
% bytes transmitted, goodput bytes transmitted, and pending buffer amount
% bytes. The number of goodput bytes is calculated by excluding the retransmissions from the
% total transmissions. Metrics are for DL direction if symbol type is DL
% (likewise, for UL symbol)
UEMetrics = zeros(simParameters.NumUEs, 3);
% To store Rx result: 'RxSuccess', 'RxFailure', 'NoRx' for a symbol
rxResultUEs = cell(simParameters.NumUEs, 1);
% To store the current value of last received NDI flag for HARQ processes
% of UEs. NDI values are for DL HARQ processes, if symbol type is DL
% (likewise, for UL symbol)
HARQProcessStatus = zeros(simParameters.NumUEs, simParameters.NumHARQ);
% To store the RLC statistics of a slot
ueRLCStats = cell(simParameters.NumUEs, 1);
gNBRLCStats = cell(simParameters.NumUEs, 1);
% To store current CQI values on the RBs for the UEs
channelQuality = zeros(simParameters.NumUEs, simParameters.NumRBs);
% Create logging and visualization objects for MAC scheduling and RLC
simSchedulingLogger = hNRSchedulingLogger(simParameters);  
simRLCLogger = hNRRLCLogger(simParameters, lchInfo);
if ~isfield(simParameters, 'SchedulingType') || simParameters.SchedulingType == 0 % If no scheduling type is specified or slot based scheduling is specified
    tickGranularity = 14; % Operations are only at slot boundary. Simulation jumps from one slot boundary to next
else % Symbol based scheduling
    tickGranularity = 1; % Operations can be at symbol boundary. Simulation moves symbol-by-symbol
end

slotNum = 0;
% Execute all the symbols in the simulation
for symbolNum = 1 : tickGranularity : numSymbolsSim
    resourceAssignmentsUL = [];
    resourceAssignmentsDL = [];
    UEMetrics(:) = 0;
    rxResultUEs(:) = {[]};
    HARQProcessStatus(:) = 0;
    
    symbolType = currentSymbolType(gNB); % Get current symbol type: DL/UL/Guard
    % Perform the slot boundary operations
    if mod(symbolNum - 1, 14) == 0
        slotNum = slotNum + 1;
        
        % Update the channel quality, if channel update periodicity has reached
        if mod(slotNum, channelUpdatePeriodicitySlots) == 0
            for ueIdx = 1:simParameters.NumUEs
                % Current UL CQI values for the UE (Assuming TDD channel reciprocity, DL CQIs would also be same)
                currentCQIs = getChannelQualityStatus(gNB, 1, ueIdx);
                % Update CQI values for RBs by randomly varying current
                % values by CQIDelta, limited by the minimum and maximum
                % achievable CQI index value. You can customize the
                % updating of CQI values as necessary
                updateType = [1 -1]; % Improvement/deterioration
                channelQualityChange = updateType(randi(length(updateType)));
                updatedCQIs = min(max(currentCQIs + simParameters.CQIDelta*channelQualityChange, 1), maxUECQIs(ueIdx));
                % Update the DL and UL channel quality information at gNB
                % and UEs (1 represents UL direction, 0 represents DL
                % direction)
                updateChannelQualityStatus(gNB, updatedCQIs, 1, ueIdx); 
                updateChannelQualityStatus(gNB, updatedCQIs, 0, ueIdx);
                updateChannelQualityStatus(UEs{ueIdx}, updatedCQIs);
            end
        end
        
        % Generate application traffic
        for ueIdx = 1:simParameters.NumUEs
            
            % Generate UL traffic
            if mod(slotNum-1, appPeriodicityUEsSlotsUL(ueIdx)) == 0 % Check if UL packet generation periodicity is reached for the UE
                % Receive UL data for the UE from upper layers based on UL application traffic
                % pattern
                % Divide application packet into multiple RLC SDUs if
                % it is bigger than maximum RLC SDU size
                numRLCSDU = floor(simParameters.ULPacketSizesUEs(ueIdx, lcid) / simParameters.maxRLCSDULength);
                rlcSDU = randi([0 255], simParameters.maxRLCSDULength, 1);
                for i = 1:numRLCSDU % Generate UL packets of max RLC SDU size (if any)
                    receiveRLCSDU(UEs{ueIdx}, ueIdx, lcid , rlcSDU);
                end
                if mod(simParameters.ULPacketSizesUEs(ueIdx, lcid),simParameters.maxRLCSDULength) ~= 0
                    % Generate UL packet which is smaller than maxRLCSDULength
                    rlcSDU = randi([0 255], mod(simParameters.ULPacketSizesUEs(ueIdx, lcid),simParameters.maxRLCSDULength), 1);
                    receiveRLCSDU(UEs{ueIdx}, ueIdx, lcid , rlcSDU);
                end
            end
            
            % Generate DL traffic
            if mod(slotNum-1, appPeriodicityUEsSlotsDL(ueIdx)) == 0 % If DL packet generation periodicity reached for UE
                % Receive DL data for the UE from upper layers based on application traffic
                % pattern
                % Divide application packet into multiple RLC SDUs, if it is bigger than maximum RLC SDU size
                numRLCSDU = floor(simParameters.DLPacketSizesUEs(ueIdx, lcid) / simParameters.maxRLCSDULength);
                rlcSDU = randi([0 255], simParameters.maxRLCSDULength, 1);
                for i = 1:numRLCSDU
                    receiveRLCSDU(gNB, ueIdx, lcid, rlcSDU); % Generate DL packets of max RLC SDU size (if any)
                end
                if mod(simParameters.DLPacketSizesUEs(ueIdx, lcid),simParameters.maxRLCSDULength) ~= 0
                    % Generate DL packet which is smaller than maxRLCSDULength
                    rlcSDU = randi([0 255], mod(simParameters.DLPacketSizesUEs(ueIdx, lcid),simParameters.maxRLCSDULength), 1);
                    receiveRLCSDU(gNB, ueIdx, lcid, rlcSDU);
                end
            end
        end
        
        % Run the schedulers. Functions internally check if the UL/DL
        % scheduler is set to run in this slot. If yes, schedule the
        % resources and send the corresponding UL and DL assignments
        resourceAssignmentsUL = runULSchedulerTDD(gNB);
        resourceAssignmentsDL = runDLSchedulerTDD(gNB);
        if ~isempty(resourceAssignmentsUL) || ~isempty(resourceAssignmentsDL) % Check if UL/DL assignments are done
            controlTx(gNB, resourceAssignmentsUL, resourceAssignmentsDL); % Construct and send UL and DL assignments
        end
        
        % Run the Rx operation at UEs for simultaneous reception of control packets
        for ueIdx = 1:simParameters.NumUEs % For all UEs
            controlRx(UEs{ueIdx}); % Receive UL and DL assignments, if any sent by gNB
            % Get RLC statistics
            ueRLCStats{ueIdx} = getRLCStatistics(UEs{ueIdx}, ueIdx);
            gNBRLCStats{ueIdx} = getRLCStatistics(gNB, ueIdx);
        end
        logRLCStats(simRLCLogger, ueRLCStats, gNBRLCStats); % Update RLC statistics logs
    end
    
    % Perform the symbol boundary operations
    if symbolType == 0 % DL symbol
        dataTx(gNB); % Send the PDSCH packets, if any scheduled
        for ueIdx = 1:simParameters.NumUEs % For all UEs
            % Read current NDI value at UEs for DL HARQ processes (for logging purpose)
            HARQProcessStatus(ueIdx, :) = getLastNDIFlagHarq(UEs{ueIdx}, 0); % 0 for DL
            % Receive the PDSCH packets from gNB that are scheduled to be
            % received in this symbol. Return the information of Rx
            % success/failure
            rxResultUEs{ueIdx} = dataRx(UEs{ueIdx});
            % Read the UL channel quality at gNB for each of the UEs (for logging purpose)
            channelQuality(ueIdx,:) = getChannelQualityStatus(gNB, 1, ueIdx); % 1 for UL direction
        end
        [UEMetrics(:, 1), UEMetrics(:, 2)]  = getCurrTTIBytes(gNB); % Read throughput and goodput bytes sent for each UE (for logging purpose)
        UEMetrics(:, 3) = getBufferStatus(gNB); % Read pending DL buffer (in bytes) for each UE at gNB (for logging purpose)
    end
    
    if symbolType == 1 % UL Symbol
        for ueIdx = 1:simParameters.NumUEs % For all UEs
            % Read current NDI value at UEs for UL HARQ processes (for logging purpose)
            HARQProcessStatus(ueIdx, :) = getLastNDIFlagHarq(UEs{ueIdx}, 1); % 1 for UL
            % UE sends the PUSCH packet if it is a Tx start symbol (as conveyed by gNB in
            % earlier received UL assignments)
            dataTx(UEs{ueIdx});
            % UE sends the BSR packet and ACK/NACK for PDSCHs
            controlTx(UEs{ueIdx});
            % Read throughput and goodput bytes transmitted by this UE in the current TTI (for logging purpose)
            [UEMetrics(ueIdx, 1), UEMetrics(ueIdx, 2)] = getCurrTTIBytes(UEs{ueIdx});
            % Read pending UL buffer (in bytes) on UE (for logging purpose)
            UEMetrics(ueIdx, 3) = getBufferStatus(UEs{ueIdx}); 
             % Read the DL channel quality at gNB for each of the UEs (for logging purpose)
            channelQuality(ueIdx,:) = getChannelQualityStatus(gNB, 0, ueIdx); % 0 for DL direction
        end
        % Receive PUSCH packets from UEs that are scheduled to be received
        % in this symbol. Return the information of Rx success/failure
        rxResultUEs = dataRx(gNB);
        controlRx(gNB); % Receive BSRs and PDSCH feedback
    end
    
    % Update logs based on the current symbol run of UEs and gNB
    logScheduling(simSchedulingLogger, symbolNum, [resourceAssignmentsUL resourceAssignmentsDL], UEMetrics, channelQuality, HARQProcessStatus, rxResultUEs, symbolType);
    
    % RB assignment visualization (if enabled)
    if simParameters.RBVisualization
        if symbolNum > 1 && (simParameters.SchedulingType == 1 && (mod(symbolNum, 14) == 0)) || (simParameters.SchedulingType == 0 && (mod(slotNum, rbAssignmentPlotPeriodicity) == 0))
            % Plot at slot boundary, if the update periodicity is
            % reached
            plotRBGrids(simSchedulingLogger);
        end
    end
    % CQI grid visualization (if enabled)
    if simParameters.CQIVisualization
        if symbolNum > 1 && mod(symbolNum-1, 14) == 0 && mod(slotNum, numSlotsFrame) == 0 % Plot at frame boundary
            plotCQIRBGrids(simSchedulingLogger);
        end
    end
    % Plot scheduler metrics and RLC metrics visualization at slot
    % boundary, if the update periodicity is reached
    if symbolNum > 1 && mod(symbolNum-1, 14) == 0 && mod(slotNum, simParameters.MetricsStepSize) == 0
        plotMetrics(simSchedulingLogger);
        plotMetrics(simRLCLogger);
    end
    
    % Advance timer ticks for gNB and UEs by 'tickGranularity' symbols
    advanceTimer(gNB, tickGranularity);
    for ueIdx = 1:simParameters.NumUEs % For all UEs
        advanceTimer(UEs{ueIdx}, tickGranularity);
    end
end

% Read the logs and write them to MAT-files
timeStepLogs = getSchedulingLogs(simSchedulingLogger); % MAC scheduling logs
schedulingGrantLogs = getGrantLogs(simSchedulingLogger); % Scheduling assignments log
rlcLogs = getRLCLogs(simRLCLogger); % RLC statistics logs
save(simParameters.SimulationLogFile, 'timeStepLogs', 'schedulingGrantLogs', 'rlcLogs'); % Save simulation logs in a MAT-file
save(simParameters.ParametersLogFile, 'simParameters'); % Save simulation parameters in a MAT-file