refreshLocalVars.m

function nvars = refreshLocalVars(self)
% NVARS = REFRESHLOCALVARS()
 
R = self.getNumberOfClasses;
nvars = zeros(self.getNumberOfNodes, 2*R+1);
nodeparam = cell(self.getNumberOfNodes, 1);
rtnodes = self.sn.rtnodes;
% Draft SPN code:
% isp = [];
% ist = [];
% nodeToPlace = zeros(1, self.getNumberOfNodes);
% nodeToTransition = zeros(1, self.getNumberOfNodes);
% for ind=1:self.getNumberOfNodes
%     node = self.getNodeByIndex(ind);
%     switch class(node)
%     case 'Place'
%         isp = [isp, ind];
%         nodeToPlace(ind) = length(isp);
%     case 'Transition'
%         ist = [ist, ind];
%         nodeToTransition(ind) = length(ist);
%     end
% end
sn = self.sn;
 
for ind=1:self.getNumberOfNodes
    node = self.getNodeByIndex(ind);
    switch class(node)
        case 'Cache'
            nodeparam{ind} = struct();
            nodeparam{ind}.nitems = 0;
            nodeparam{ind}.accost = node.accessProb;
            for r=1:self.getNumberOfClasses
                if length(node.popularity) >= r && isa(node.popularity{r}, 'Distribution') && ~node.popularity{r}.isDisabled
                    nodeparam{ind}.nitems = max(nodeparam{ind}.nitems,node.popularity{r}.support(2));
                end
            end
            % nvars holds the cache state width: cache contents plus, when a retrieval
            % system is configured, a per-item occupancy bitmap (one column per item);
            % otherwise only the cache contents are stored.
            if node.retrievalSystemCapacity > 0
                retrievalBitmapWidth = nodeparam{ind}.nitems;
            else
                retrievalBitmapWidth = 0;
            end
            nvars(ind,2*R+1) = node.totalCacheCapacity + retrievalBitmapWidth;
            nodeparam{ind}.itemcap = node.itemLevelCap;
            nodeparam{ind}.totalCacheCapacity = node.totalCacheCapacity;
            nodeparam{ind}.retrievalSystemCapacity = node.retrievalSystemCapacity;
            nodeparam{ind}.pread = cell(1,self.getNumberOfClasses);
            for r=1:self.getNumberOfClasses
                if length(node.popularity) < r || ~isa(node.popularity{r}, 'Distribution') || node.popularity{r}.isDisabled
                    nodeparam{ind}.pread{r} = NaN;
                else
                    nodeparam{ind}.pread{r} = node.popularity{r}.evalPMF(1:nodeparam{ind}.nitems);
                end
            end
            nodeparam{ind}.replacestrat = node.replacestrategy;
            nodeparam{ind}.hitclass = zeros(1,self.getNumberOfClasses);
            nodeparam{ind}.hitclass(1:length(node.server.hitClass)) = round(node.server.hitClass);
            nodeparam{ind}.missclass = zeros(1,self.getNumberOfClasses);
            nodeparam{ind}.missclass(1:length(node.server.missClass)) = round(node.server.missClass);
 
            % retrieval-system class matrix: pad to current class count and -1 outside known entries
            K = self.getNumberOfClasses;
            if isprop(node.server, 'retrievalClasses') && ~isempty(node.server.retrievalClasses)
                rc = -ones(nodeparam{ind}.nitems, K);
                rc(1:size(node.server.retrievalClasses,1), 1:min(size(node.server.retrievalClasses,2),K)) = ...
                    node.server.retrievalClasses(1:size(node.server.retrievalClasses,1), 1:min(size(node.server.retrievalClasses,2),K));
                nodeparam{ind}.retrievalClasses = rc;
            else
                nodeparam{ind}.retrievalClasses = -ones(max(nodeparam{ind}.nitems,1), K);
            end
            nodeparam{ind}.retrievalClassIndices = node.retrievalClassIndices;
            nodeparam{ind}.retrievalSystemQueueIndices = containers.Map('KeyType','int32','ValueType','any');
            keysList = keys(node.retrievalSystemQueueIndices);
            for kk = 1:numel(keysList)
                nodeparam{ind}.retrievalSystemQueueIndices(keysList{kk}) = node.retrievalSystemQueueIndices(keysList{kk});
            end
 
            % Store actual hit/miss/latency from solver results (if available)
            if isprop(node.server, 'actualHitProb') && ~isempty(node.server.actualHitProb)
                nodeparam{ind}.actualhitprob = full(node.server.actualHitProb);
                nodeparam{ind}.actualmissprob = full(node.server.actualMissProb);
            end
            if isprop(node.server, 'actualDelayedHitProb') && ~isempty(node.server.actualDelayedHitProb)
                nodeparam{ind}.actualdelayedhitprob = full(node.server.actualDelayedHitProb);
            end
            if isprop(node.server, 'actualResidT') && ~isempty(node.server.actualResidT)
                nodeparam{ind}.actualresidt = full(node.server.actualResidT);
            end
        case 'Fork'
            nodeparam{ind}.fanOut = node.output.tasksPerLink;
        case 'Join'
            nodeparam{ind}.joinStrategy = node.input.joinStrategy;
            nodeparam{ind}.fanIn = cell(1,self.getNumberOfClasses);
            for r=1:self.getNumberOfClasses
                nodeparam{ind}.fanIn{r} = node.input.joinRequired{r};
            end
        case 'Logger'
            nodeparam{ind}.fileName = node.fileName;
            nodeparam{ind}.filePath = node.filePath;
            nodeparam{ind}.startTime = node.getStartTime;
            nodeparam{ind}.loggerName = node.getLoggerName;
            nodeparam{ind}.timestamp = node.getTimestamp;
            nodeparam{ind}.jobID = node.getJobID;
            nodeparam{ind}.jobClass = node.getJobClass;
            nodeparam{ind}.timeSameClass = node.getTimeSameClass;
            nodeparam{ind}.timeAnyClass = node.getTimeAnyClass;            
        case {'Source'}
            for r=1:self.getNumberOfClasses
                if ~iscell(node.arrivalProcess) || length(node.arrivalProcess) < r || isempty(node.arrivalProcess{r})
                    continue;
                end
                switch class(node.arrivalProcess{r})
                    case 'MAP'
                        nvars(ind,r) = nvars(ind,r) + 1;
                    case {'Replayer', 'Trace'}
                        if isempty(nodeparam{ind})
                            nodeparam{ind} = cell(1,self.getNumberOfClasses);
                        end
                        if isempty(nodeparam{ind}{r})
                            nodeparam{ind}{r} = struct();
                        end
                        nodeparam{ind}{r}.(node.arrivalProcess{r}.params{1}.paramName) = node.arrivalProcess{r}.params{1}.paramValue;
                end
            end
        case {'Queue','QueueingStation','Delay','DelayStation','Transition'}
            for r=1:self.getNumberOfClasses
                switch class(node.server.serviceProcess{r}{3})
                    case 'MAP'
                        nvars(ind,r) = nvars(ind,r) + 1;
                    case {'Replayer', 'Trace'}
                        if isempty(nodeparam{ind})
                            nodeparam{ind} = cell(1,self.getNumberOfClasses);
                        end
                        if isempty(nodeparam{ind}{r})
                            nodeparam{ind}{r} = struct();
                        end
                        nodeparam{ind}{r}.(node.server.serviceProcess{r}{3}.params{1}.paramName) = node.server.serviceProcess{r}{3}.params{1}.paramValue;
                end
                if ~isa(node,'Delay') && ~isa(node,'Transition') && ~isempty(node.setupTime) && ~isempty(node.setupTime{r})
                    if isempty(nodeparam{ind})
                        nodeparam{ind} = cell(1,self.getNumberOfClasses);
                    end
                    if isempty(nodeparam{ind}{r})
                        nodeparam{ind}{r} = struct();
                    end
                    nodeparam{ind}{r}.setupTime = node.setupTime{r}.getProcess();
                    nodeparam{ind}{r}.delayoffTime = node.delayoffTime{r}.getProcess();
                end
                if (isa(node,'Queue') || isa(node,'QueueingStation'))
                    if isempty(nodeparam{ind}) && (~isempty(node.pollingType) || ~isempty(node.switchoverTime))
                        nodeparam{ind} = cell(1,self.getNumberOfClasses);
                        for s=1:self.getNumberOfClasses
                            nodeparam{ind}{s} = struct();
                        end
                    end
                    if ~isempty(node.pollingType) && ~isempty(node.pollingType{r})
                        nodeparam{ind}{r}.pollingType = node.pollingType{r};
                        nodeparam{ind}{r}.pollingPar = node.pollingPar;
                    end
                    if ~isempty(node.switchoverTime) && ~isempty(node.switchoverTime{r})
                        if min(size(node.switchoverTime))==1
                            nodeparam{ind}{r}.switchoverTime = node.switchoverTime{r}.getProcess();
                            nodeparam{ind}{r}.switchoverProcId = ProcessType.toId(ProcessType.fromText(class(node.switchoverTime{r})));
                        else
                            for t=1:length(node.switchoverTime)
                                nodeparam{ind}{r}.switchoverTime{t} = node.switchoverTime{r,t}.getProcess();
                                nodeparam{ind}{r}.switchoverProcId(t) = ProcessType.toId(ProcessType.fromText(class(node.switchoverTime{r,t})));
                            end
                        end
                    end
                end
            end
            % Pass-and-swap (PAS) queues carry a node-level class
            % compatibility/swap graph rather than per-class parameters.
            if (isa(node,'Queue') || isa(node,'QueueingStation')) && ...
                    SchedStrategy.toId(node.schedStrategy) == SchedStrategy.PAS
                if isempty(nodeparam{ind})
                    nodeparam{ind} = struct();
                end
                if isempty(node.swapGraph)
                    % Default to a complete compatibility graph (any class may
                    % swap with any other; no self-loops) when none was set.
                    nodeparam{ind}.swapGraph = ones(R,R) - eye(R);
                else
                    nodeparam{ind}.swapGraph = node.swapGraph;
                end
                % Total service rate function mu(c) of the ordered state vector c.
                nodeparam{ind}.svcRateFun = node.svcRateFun;
            end
    end
 
    for r=1:R
        switch sn.routing(ind,r)
            case RoutingStrategy.KCHOICES
                nodeparam{ind}{r}.k = node.output.outputStrategy{r}{3}{1};
                nodeparam{ind}{r}.withMemory = node.output.outputStrategy{r}{3}{2};
                if nodeparam{ind}{r}.withMemory
                    % Reserve a state slot per class to record the last
                    % selected destination so sub_kchoices can replicate the
                    % "Power-of-K with memory" semantics (Mitzenmacher 2002).
                    nvars(ind, R+r) = nvars(ind, R+r) + 1;
                end
            case RoutingStrategy.WRROBIN
                nvars(ind,R+r) = nvars(ind,R+r) + 1;
                % save indexes of outgoing links
                if isempty(nodeparam) || isempty(nodeparam{ind}) % reinstantiate if not a cache
                    nodeparam{ind}{r} = struct();
                end
                nodeparam{ind}{r}.weights = zeros(1,self.sn.nnodes);
                nodeparam{ind}{r}.outlinks = find(self.sn.connmatrix(ind,:));
                for c=1:size(node.output.outputStrategy{1, r}{3},2)
                    destination = node.output.outputStrategy{1, r}{3}{c}{1};
                    weight = node.output.outputStrategy{1, r}{3}{c}{2};
                    nodeparam{ind}{r}.weights(destination.index) = weight;
                end
                % Build the WRR cycle by replicating each outlink by its weight.
                % afterEventRouter walks this list one position per DEP. With
                % unit weights this collapses to ordinary RR.
                cycle = [];
                for ol = nodeparam{ind}{r}.outlinks
                    w = nodeparam{ind}{r}.weights(ol);
                    if w > 0
                        cycle = [cycle, repmat(ol, 1, max(1, round(w)))]; %#ok<AGROW>
                    else
                        cycle = [cycle, ol]; %#ok<AGROW>
                    end
                end
                nodeparam{ind}{r}.weighted_outlinks = cycle;
            case RoutingStrategy.RROBIN
                nvars(ind,R+r) = nvars(ind,R+r) + 1;
                % save indexes of outgoing links
                if isempty(nodeparam) || isempty(nodeparam{ind}) % reinstantiate if not a cache
                    nodeparam{ind}{r} = struct();
                end
                nodeparam{ind}{r}.outlinks = find(self.sn.connmatrix(ind,:));
        end
    end
end
 
if ~isempty(self.sn) %&& isprop(self.sn,'nvars')
    self.sn.nvars = nvars;
    self.sn.nodeparam = nodeparam;
end
end