rng('default'); % Reset the random number generator
simParameters = []; % Clear the simParameters variable
simParameters.NumFramesSim = 200; % 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 simulation parameters
% simParameters.UEDistance and simParameters.PacketPeriodicityUEs are
% array of length equal to NumUEs; and simParameters.PacketSizesUEs,
% properties of simParameters.RLCConfig, and simParameters.LCHConfig
% consists of number of rows equal to numUEs.
simParameters.NumUEs = 4;
% Number of logical channels in each UE. If you change the number of
% logical channels, ensure that the simulation parameters
% simParameters.PacketSizesUEs, properties of simParameters.RLCConfig, and
% simParameters.LCHConfig consists of number of columns equal to
% NumLogicalChannels.
simParameters.NumLogicalChannels = 3;
simParameters.UEDistance = [100; 250; 700; 750]; % Distance of UEs from gNB (in meters)

% Set the application traffic pattern for UEs. For example, the vector
% element value 50 at position 4 represents that for each of the logical
% channels of UE-4, a packet is generated every 50 ms
simParameters.PacketPeriodicityUEs = [50; 60; 60; 50]; % Periodicity at which UEs generate packets in logical channels (in ms)
% The N-by-P matrix represents the size of packet generated by
% the UE in each logical channel, where 'N' represents the number of UEs
% and 'P' represents the number of logical channels. For example, the value
% 1000 at position (4, 1) represents a packet of size 1000 bytes generated by
% UE-4 for logical channel id 1
simParameters.PacketSizesUEs = [3000 4000 100000;
    500  25000 60000;
    2000 80000 4000;
    1000 20000 4000];

% RLC configuration
% Each property of RLCConfig must be an N-by-P matrix, where 'N' represents the number of UEs
% and 'P' represents the number of logical channels. A matrix element at position
% (i, j) corresponds to property value of a UE with RNTI value 'i' and logical channel id 'j'.
% Sequence number field length (in bits) to be used by each UE for their logical channels
simParameters.RLCConfig.SNFieldLength = [6 6 12;
    6 6 12;
    6 12 6;
    6 6 12];
% Reassembly timer to be used by each UE for their logical channels
simParameters.RLCConfig.ReassemblyTimer = [5 10 15;
    5  5 10;
    5  5  5;
    5 10 15];
% Max buffer length of each logical channel (to model Tx buffer overflow)
simParameters.RLCConfig.MaxTxBufferLength = [10240 10240 1024000;
    1024 102400 204800;
    10240 10240 10240;
    10240 102400 102400];

% Logical channel configuration
% Each property of LCHConfig must be an N-by-P matrix, where 'N' represents the number of UEs
% and 'P' represents the number of logical channels. A matrix element at position
% (i, j) corresponds to property value of a UE with RNTI value 'i' and logical channel id 'j'.
% Mapping between logical channel and logical channel group id
simParameters.LCHConfig.LCGID = [1 3 2;
    1 2 2;
    1 2 3;
    5 1 2];
% Priority of each logical channel
simParameters.LCHConfig.Priority = [1 5 8;
    1 1 6;
    4 10 4;
    10 11 13];
% Prioritized bitrate (in kilo bytes per second) of each logical channel
simParameters.LCHConfig.PBR = [8 16 32;
    8 128 32;
    8 16 32;
    8 16 32];
% Bucket size duration (in ms) of each logical channel
simParameters.LCHConfig.BSD = [5 10 50;
    5 20 20;
    5 5 5;
    5 10 20];

% MAC configuration
% Set the scheduler run periodicity in terms of number of slots. Value must be
% less than the number of slots in a 10 ms frame
simParameters.SchedulerPeriodicity = 4;
simParameters.SchedulerStrategy = 'PF'; % Supported scheduling strategies: 'PF', 'RR' and 'BestCQI'
% 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.BSRPeriodicity = 5; % In ms
simParameters.EnableHARQ = true; % Flag to enable or disable HARQ. If disabled, there are no retransmissions
simParameters.NumHARQ = 16; % Number of HARQ processes in each UE
% PUSCH preparation time. gNB ensures that PUSCH assignment is received at
% UEs PUSCHPrepTime ahead of the transmission time
simParameters.PUSCHPrepTime = 200; % In microseconds
% Maximum RBs allotted to a UE in a slot for a PUSCH transmission (limit is
% applicable for new PUSCH assignments and not for the retransmissions)
simParameters.RBAllocationLimitUL = 15;

% Physical layer and channel configuration
% RB count for 5 MHz band with 15 kHz subcarrier spacing (SCS). The complete
% UL bandwidth is assumed to be allotted for PUSCH
simParameters.NumRBs = 25;
simParameters.SCS = 15;
% Set the RBG size configuration to 1 (configuration-1 RBG table) or 2
% (configuration-2 RBG table) as defined in 3GPP TS 38.214 Section
% 5.1.2.2.1
simParameters.RBGSizeConfig = 1;

% 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: RBCQI = RBCQI +/- CQIDelta
simParameters.ChannelUpdatePeriodicity = 0.5; % In sec
simParameters.CQIDelta = 1;
% 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 achievable CQI value in decreasing
% order
simParameters.CQIvsDistance = [
    200  15;
    500  12;
    800  10;
    1000  8;
    1200  7];
% Expression to calculate reception success probability of a PUSCH packet
% based on the channel quality. 'x' represents the average CQI of the RBs
% over which the PUSCH packet is received
simParameters.CQISuccessProb = '.4 + (x/20)';

% Logging and visualization configuration
% Flag to enable or disable run time 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.
simParameters.RBVisualization = true;

% The output metrics plots are updated NumMetricsSteps times during
% simulation
simParameters.NumMetricsSteps = 20;

% MAT-files used for post simulation visualization
simParameters.ParametersLogFile = 'simParameters'; % For logging the simulation parameters
simParameters.SimulationLogFile = 'simulationLogs'; % For logging the simulation logs

hNRULSchedulingValidateConfig(simParameters); % Validate the simulation configuration

% Slot duration for the selected SCS and number of slots in a 10 ms frame
slotDuration = 1/(simParameters.SCS/15); % Slot duration in ms
numSlotsFrame = 10/slotDuration; % Number of slots in 10 ms frame
numSlotsSim = simParameters.NumFramesSim * numSlotsFrame; % Number of slots in the simulation

% Packet periodicities of UEs in terms of number of slots
appPeriodicityUEsSlots = simParameters.PacketPeriodicityUEs ./ slotDuration;

% Maximum RLC SDU length (in bytes)
simParameters.maxRLCSDULength = 9000;

% RLC entity direction. Value 0 represents downlink only, 1
% represents UL only and 2 represents both UL and downlink
% direction. Setting entity direction to have only UL
simParameters.RLCConfig.EntityDir = ones(simParameters.NumUEs, simParameters.NumLogicalChannels);

% Logical channel id
simParameters.LCHConfig.LCID = ones(simParameters.NumUEs, simParameters.NumLogicalChannels) .* (1: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

% Periodicity of channel update in terms of number of slots
channelUpdatePeriodicitySlots = floor((simParameters.ChannelUpdatePeriodicity * 1000)/...
    slotDuration);
% Find maximum achievable CQI value for 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

% 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

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

% Create and store UE node objects
UEs = cell(simParameters.NumUEs, 1);
for ueIdx=1:simParameters.NumUEs
    UEs{ueIdx} = hNRUE(simParameters, ueIdx);
end

% Define UL 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. Update the defined channel quality information to UEs and
% gNB
uplinkChannelQuality = zeros(simParameters.NumUEs, simParameters.NumRBs); % To store current UL CQI values on the RBs for different UEs
for ueIdx = 1:simParameters.NumUEs
    % Assign random CQI values for the RBs, limited by the maximum achievable CQI value
    uplinkChannelQuality(ueIdx, :) = randi([1 maxUECQIs(ueIdx)], 1, simParameters.NumRBs);
    % Update the UL CQI values at gNB (UL direction is represented as 1)
    updateChannelQualityStatus(gNB, uplinkChannelQuality(ueIdx, :), 1, ueIdx);
end

% Setup logical channels
for ueIdx=1:simParameters.NumUEs
    for lcid = 1:simParameters.NumLogicalChannels
        % 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
end

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

% To store the following UE metrics for each slot: 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
UEMetrics = zeros(simParameters.NumUEs, 3);

% To store the RLC statistics for each slot
ueRLCStats = cell(simParameters.NumUEs, 1);
gNBRLCStats = cell(simParameters.NumUEs, 1);

% Create an object for MAC scheduling information visualization and logging (UL direction is represented as 1)
simSchedulingLogger = hNRSchedulingLogger(simParameters, 1);
% Create an object for RLC visualization and logging (UL direction is represented as 1)
simRLCLogger = hNRRLCLogger(simParameters, lchInfo, 1);

symbolNum = 0;
% Run processing loop
for slotNum = 1:numSlotsSim
    
    % Update the UL channel quality for UEs periodically
    if mod(slotNum, channelUpdatePeriodicitySlots) == 0
        for ueIdx = 1:simParameters.NumUEs
            CQIRBs = getChannelQualityStatus(gNB, 1, ueIdx); % Current CQI values
            % Update CQI values for RBs by randomly increasing or
            % decreasing 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(CQIRBs + simParameters.CQIDelta*channelQualityChange, 1), maxUECQIs(ueIdx));
            % Update the UL channel quality at gNB for the UE (UL direction is represented as 1)
            updateChannelQualityStatus(gNB, updatedCQIs, 1, ueIdx);
        end
    end
    
    % Run the gNB scheduler. Check whether the scheduler is set to run in
    % the slot. If yes, schedule the resources and send the corresponding
    % UL assignments
    resourceAssignments = runULSchedulerFDD(gNB);
    if ~isempty(resourceAssignments)
        controlTx(gNB, resourceAssignments, []);
    end
    
    % Run the UE operations
    HARQProcessStatus = zeros(simParameters.NumUEs, simParameters.NumHARQ); % To store last sent HARQ process NDI flag
    for ueIdx = 1:simParameters.NumUEs % For all UEs
        
        % Generate UL traffic if UL packet generation periodicity is reached for the UE
        if mod(slotNum-1, appPeriodicityUEsSlots(ueIdx)) == 0
            % Receive UL data for the UE from upper layers based on
            % UL application traffic pattern
            for lcid = 1:simParameters.NumLogicalChannels
                % Divide application packet into multiple RLC SDUs if it is
                % bigger than maximum RLC SDU size
                numRLCSDU = floor(simParameters.PacketSizesUEs(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.PacketSizesUEs(ueIdx, lcid),simParameters.maxRLCSDULength) ~= 0
                    % Generate UL packet which is smaller than maxRLCSDULength
                    rlcSDU = randi([0 255], mod(simParameters.PacketSizesUEs(ueIdx, lcid),simParameters.maxRLCSDULength), 1);
                    receiveRLCSDU(UEs{ueIdx}, ueIdx, lcid , rlcSDU);
                end
            end
        end
        
        % UE sends the PUSCH packet if it is a Tx slot (as conveyed by gNB in
        % earlier received UL assignments).
        dataTx(UEs{ueIdx});
        
        % UE sends BSR packet, if scheduled to send in this slot
        controlTx(UEs{ueIdx});
        
        % For logging
        % Read throughput and goodput bytes transmitted for this UE in the current TTI
        [UEMetrics(ueIdx, 1), UEMetrics(ueIdx, 2)] = getCurrTTIBytes(UEs{ueIdx});
        % Read pending UL buffer (in bytes) on UE
        UEMetrics(ueIdx, 3) = getBufferStatus(UEs{ueIdx});
        % Read the last received NDI flags for UE HARQ processes (UL direction is represented as 1)
        HARQProcessStatus(ueIdx, :) = getLastNDIFlagHarq(UEs{ueIdx}, 1);
        % Read the UL channel quality at gNB for each of the UEs (UL direction is represented as 1)
        uplinkChannelQuality(ueIdx, :) = getChannelQualityStatus(gNB, 1, ueIdx);
    end
    
    % Run the Rx operation at gNB for simultaneous reception of packets
    controlRx(gNB); % Receive BSRs
    
    % Receive UL MAC packets from UEs that are scheduled to transmit in
    % this slot. Return the information of Rx success/failure
    rxResultUEs = dataRx(gNB);
    
    % Run the Rx operation at UEs for simultaneous reception of packets
    for ueIdx = 1:simParameters.NumUEs % For all UEs
        controlRx(UEs{ueIdx}); % Receive UL assignments, if any sent by gNB
    end
    
    % RLC statistics of each UE
    for ueIdx = 1:simParameters.NumUEs
        ueRLCStats{ueIdx} = getRLCStatistics(UEs{ueIdx}, ueIdx);
        gNBRLCStats{ueIdx} = getRLCStatistics(gNB, ueIdx);
    end
    
    % Update uplink logs based on the current slot run of UEs and gNB. Logs are
    % updated in each slot
    logScheduling(simSchedulingLogger,  symbolNum + 1, resourceAssignments, UEMetrics, uplinkChannelQuality, HARQProcessStatus, rxResultUEs, 1);
    % Update RLC statistics logs
    logRLCStats(simRLCLogger, ueRLCStats, gNBRLCStats);
    
    % If RB Visualization flag is set, update the RB assignment grid at the
    % last slot of each frame
    if simParameters.RBVisualization && mod(slotNum, numSlotsFrame) == 0
        plotRBGrids(simSchedulingLogger);
    end
    
    % If CQI Visualization flag is set, update the CQI grid at the last
    % slot of each frame
    if simParameters.CQIVisualization && mod(slotNum, numSlotsFrame) == 0
        plotCQIRBGrids(simSchedulingLogger);
    end
    
    % Plot MAC scheduling performance, RLC throughput metrics at every metricsStepSize slots
    if mod(slotNum, simParameters.MetricsStepSize) == 0
        plotMetrics(simSchedulingLogger);
        plotMetrics(simRLCLogger);
    end
    
    tickGranularity = 14; % Number of symbols in a slot
    % 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
    
    % Symbol number in the simulation
    symbolNum = symbolNum + tickGranularity;
end

% Read the logs and write them to MAT-files
[~, ulTimeStepLogs] = getSchedulingLogs(simSchedulingLogger); % UL time step scheduling logs
schedulingGrantLogs = getGrantLogs(simSchedulingLogger); % DCI message log
% RLC statistics logs
rlcLogs = getRLCLogs(simRLCLogger);
save(simParameters.SimulationLogFile, 'ulTimeStepLogs', 'schedulingGrantLogs', 'rlcLogs'); % Save simulation logs in a MAT-file
save(simParameters.ParametersLogFile, 'simParameters'); % Save simulation parameters in a MAT-file