refreshCapacity.m

function [capacity, classcap, droprule] = refreshCapacity(self)
% [CAPACITY, CLASSCAP, DROPRULE] = REFRESHCAPACITY()
 
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
%I = getNumberOfStatefulNodes(self);
M = getNumberOfStations(self);
K = getNumberOfClasses(self);
C = self.sn.nchains;
% set zero buffers for classes that are disabled
classcap = Inf*ones(M,K);
chaincap = Inf*ones(M,K);
capacity = zeros(M,1);
droprule = DropStrategy.WAITQ*ones(M,K); 
sn = self.sn;
njobs = sn.njobs;
rates = sn.rates;
for c = 1:C
    inchain = sn.inchain{c};
    for r = inchain
        chainCap = sum(njobs(inchain));
        for ist=1:M
            station = self.getStationByIndex(ist);
            
            if sn.nodetype(sn.stationToNode(ist)) ~= NodeType.Source
                % Guard against dropRule array not having entry for class r.
                % A 0 also means "not set": assigning dropRule(k) for a class k
                % beyond the current length grows the array and fills the gap
                % with 0, which is not a DropStrategy member (WAITQ is -1), so
                % those classes must fall through to the default below rather
                % than leak a 0 into sn.droprule.
                if length(station.dropRule) >= r && ~isempty(station.dropRule(r)) ...
                        && station.dropRule(r) ~= 0
                    stationDropRule = station.dropRule(r);
                else
                    stationDropRule = [];
                end
                % An EXPLICIT setDropRule(WAITQ) at a plain finite buffer
                % reachable by an OPEN class asks for something LINE does not
                % implement: the arrival should wait until the buffer frees, but
                % there is no upstream queue to wait in (the Source is an
                % infinite generator). No solver honours it -- SolverCTMC drops
                % the arrival, SolverJMT blocks at the Source and ignores the cap
                % -- so reject rather than pick one silently. Only the explicit
                % rule is rejected: the WAITQ marker that this function derives
                % below for a no-buffer station or a closed class is untouched,
                % as are the blocking policies LINE does implement (BAS/BBS/RSRD).
                % Place and Join write the WAITQ marker themselves (Place in its
                % constructor, for every class), so for those nodes the marker is
                % an internal default and NOT a user request: exclude them, or a
                % bounded place would be rejected for a rule its user never set.
                isUserRuleNode = ~isa(station, 'Place') && ~isa(station, 'Join');
                % classCap(r) == 0 is the "no per-class constraint" sentinel
                % (a class absent from the station), NOT a real finite buffer, so
                % it must not count as a finite capacity here -- otherwise the gate
                % below rejects a WAITQ open class for a station it never visits
                % (e.g. InitClass at a Delay it does not route to). A real finite
                % per-class buffer is strictly positive and non-infinite.
                classCapIsFinite = length(station.classCap) >= r ...
                    && station.classCap(r) > 0 && ~isinf(station.classCap(r));
                stationCapIsFinite = ~isempty(station.cap) && station.cap >= 0 ...
                    && ~isinf(station.cap) && station.cap < intmax;
                if isUserRuleNode && ~isempty(stationDropRule) && stationDropRule == DropStrategy.WAITQ ...
                        && isinf(njobs(r)) && (stationCapIsFinite || classCapIsFinite)
                    line_error(mfilename, sprintf(['Station ''%s'' declares setDropRule(WAITQ) for the open class ''%s'' at a finite capacity. ' ...
                        'LINE does not implement waiting-room blocking for an open arrival at a plain finite buffer: no solver honours this combination ' ...
                        '(SolverCTMC drops the arrival, SolverJMT blocks at the Source and ignores the capacity). ' ...
                        'Use setDropRule(DropStrategy.DROP) for a loss station (M/M/1/K), or one of the blocking policies LINE implements ' ...
                        '(DropStrategy.BAS, DropStrategy.BBS, DropStrategy.RSRD) for blocking between stations.'], ...
                        station.getName(), self.classes{r}.getName()));
                end
                % Derive the rule from the final station capacity when the user
                % has not set one, so that the result does not depend on whether
                % setCapacity was called before or after setService.
                if isempty(stationDropRule)
                    if isinf(station.cap) || station.cap >= intmax
                        % No buffer: the rule is never consulted.
                        stationDropRule = DropStrategy.WAITQ;
                    elseif station.cap >= 0 && ~isinf(njobs(r))
                        % Real finite buffer and a CLOSED class. DROP would make
                        % the JMT export destroy jobs, and LINE's reference
                        % (CTMC) conserves the closed population instead, so DROP
                        % is not a defensible default here. What a closed class
                        % should do at a full station is currently unsettled in
                        % LINE itself (CTMC blocks and conserves the population,
                        % SSA and LDES drop), so leave the WAITQ marker rather
                        % than decide it here.
                        stationDropRule = DropStrategy.WAITQ;
                    else
                        % Real finite buffer and an OPEN class: LINE's reference
                        % (CTMC) loses the arrival, so DROP.
                        % Also the cap<0 case, which JMT2LINE produces by copying
                        % JMT's "size=-1 means unlimited" sentinel into cap: sn.cap
                        % below then ignores it and falls back to the population,
                        % and saveBufferCapacity emits size=-1, so the rule is
                        % unreachable and its historical DROP value is kept rather
                        % than churning every imported model.
                        stationDropRule = DropStrategy.DROP;
                    end
                end
                droprule(ist,r) = stationDropRule;
            end
            if isnan(rates(ist,r)) && sn.nodetype(sn.stationToNode(ist)) ~= NodeType.Place
                classcap(ist,r) = 0;
                chaincap(ist,c) = 0;
            else
                chaincap(ist,c) = chainCap;
                classcap(ist,r) = chainCap;
                % Guard against classCap array not having entry for class r
                if length(station.classCap) >= r && station.classCap(r) >= 0
                    classcap(ist,r) = min(classcap(ist,r), station.classCap(r));
                end
                if station.cap >= 0
                    classcap(ist,r) = min(classcap(ist,r), station.cap);
                end
            end
        end
    end
end
for ist=1:M
    station = self.getStationByIndex(ist);
    % If station has explicit finite cap set, use it directly (Kendall K notation)
    % Otherwise use minimum of chain cap sum and class cap sum
    if station.cap >= 0 && ~isinf(station.cap)
        % Explicit capacity set - use directly as total capacity
        capacity(ist,1) = station.cap;
    else
        capacity(ist,1) = min([sum(chaincap(ist,:)),sum(classcap(ist,:))]);
    end
end
self.sn.cap = capacity;
self.sn.classcap = classcap;
self.sn.droprule = droprule;
end