refreshStruct.m

function refreshStruct(self, hardRefresh)
% REFRESHSTRUCT()
%
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
 
sanitize(self);
if nargin<2
    hardRefresh = true;
end
 
%% store invariant information
if self.hasStruct && ~hardRefresh
    rtorig = self.sn.rtorig; % this must be destroyed with resetNetwork
end
 
if self.hasStruct && ~hardRefresh
    nodetypes = sn.nodetypes;
    classnames = sn.classnames;
    nodenames = sn.nodenames;
    refstat = sn.refstat;
else
    nodetypes = getNodeTypes(self);
    classnames = getClassNames(self);
    nodenames = getNodeNames(self);
    refstat = getReferenceStations(self);
 
    % Append FCR names and types to node lists (only when refreshing)
    for f = 1:length(self.regions)
        fcr = self.regions{f};
        nodenames{end+1} = fcr.getName();
        nodetypes(end+1) = NodeType.FiniteCapacityRegion;
    end
end
conn = self.getConnectionMatrix;
njobs = getNumberOfJobs(self);
numservers = getStationServers(self);
lldscaling = getLimitedLoadDependence(self);
cdscaling = getLimitedClassDependence(self);
 
%% init minimal structure
sn = NetworkStruct(); % create in self to ensure propagation
if isempty(self.sn)
    sn.rtorig = {};
    sn.reward = {};
else
    sn.rtorig = self.sn.rtorig;
    if isfield(self.sn, 'reward')
        sn.reward = self.sn.reward;  % preserve reward definitions
    else
        sn.reward = {};
    end
end
% sn.nnodes counts physical nodes only; FCRs are virtual nodes appended to nodenames/nodetypes
sn.nnodes = numel(self.nodes);
sn.nclasses = length(classnames);
 
%% get routing strategies
routing = zeros(sn.nnodes, sn.nclasses);
for ind=1:sn.nnodes
    for r=1:sn.nclasses
        if isempty(self.nodes{ind}.output.outputStrategy{r})
            routing(ind,r) = RoutingStrategy.DISABLED;
        else
            routing(ind,r) = RoutingStrategy.fromText(self.nodes{ind}.output.outputStrategy{r}{2});
        end
    end
end
sn.isslc = false(sn.nclasses,1);
for r=1:sn.nclasses
    if isa(self.classes{r},'SelfLoopingClass')
        sn.isslc(r) = true;
    end
end
sn.issignal = false(sn.nclasses,1);
sn.signaltype = cell(sn.nclasses,1);
for r=1:sn.nclasses
    sn.signaltype{r} = NaN;
end
% Detect Signal classes and populate issignal/signaltype
for r=1:sn.nclasses
    if isa(self.classes{r},'Signal')
        sn.issignal(r) = true;
        sn.signaltype{r} = self.classes{r}.signalType;
    end
end
sn.nclosedjobs = sum(njobs(isfinite(njobs)));
sn.nservers = numservers;
sn.isstation = (nodetypes == NodeType.Source | nodetypes == NodeType.Delay | nodetypes == NodeType.Queue | nodetypes == NodeType.Join | nodetypes == NodeType.Place);
sn.nstations = sum(sn.isstation);
sn.scv = ones(sn.nstations,sn.nclasses);
sn.njobs = njobs(:)';
sn.refstat = refstat;
sn.space = cell(sn.nstations,1);
sn.routing = routing;
sn.chains = [];
sn.lst = {};
sn.lldscaling = lldscaling;
sn.cdscaling = cdscaling;
sn.nodetype = nodetypes;
sn.nstations = sum(sn.isstation);
sn.isstateful = (nodetypes == NodeType.Source | nodetypes == NodeType.Delay | nodetypes == NodeType.Queue | nodetypes == NodeType.Cache | nodetypes == NodeType.Join | nodetypes == NodeType.Router | nodetypes == NodeType.Place | nodetypes == NodeType.Transition);
sn.isstatedep = false(sn.nnodes,3); % col 1: buffer, col 2: srv, col 3: routing
sn.isfunction = [];
for ind = 1:sn.nstations
    if isa(self.stations{ind},'Queue')
        sn.isfunction(ind) = ~isempty(self.stations{ind}.setupTime);
    end
end
for ind=1:sn.nnodes
    switch sn.nodetype(ind)
        case NodeType.Cache
            sn.isstatedep(ind,2) = true; % state dependent service
            %         case NodeType.Place
            %             self.nodes{ind}.init();
            %         case NodeType.Transition
            %             self.nodes{ind}.init(); % this erases enablingConditions
    end
 
    for r=1:sn.nclasses
        switch sn.routing(ind,r)
            case {RoutingStrategy.RROBIN, RoutingStrategy.WRROBIN, RoutingStrategy.JSQ, RoutingStrategy.RL, RoutingStrategy.KCHOICES}
                sn.isstatedep(ind,3) = true; % state dependent routing
        end
    end
end
 
sn.nstateful = sum(sn.isstateful);
sn.state = cell(sn.nstations,1);
for i=1:sn.nstateful
    sn.state{i} = [];
end
sn.nodenames = nodenames;
sn.classnames = classnames;
sn.connmatrix = conn;
 
sn.nodeToStateful =[];
sn.nodeToStation =[];
sn.stationToNode =[];
sn.stationToStateful =[];
sn.statefulToNode =[];
sn.statefulToStation =[];
for ind=1:sn.nnodes
    sn.nodeToStateful(ind) = nd2sf(sn,ind);
    sn.nodeToStation(ind) = nd2st(sn,ind);
end
for ist=1:sn.nstations
    sn.stationToNode(ist) = st2nd(sn,ist);
    sn.stationToStateful(ist) = st2sf(sn,ist);
end
for isf=1:sn.nstateful
    sn.statefulToNode(isf) = sf2nd(sn,isf);
    sn.statefulToStation(isf) = sf2st(sn,isf);
end
sn.fj = self.getForkJoins();
self.sn = sn;
refreshPriorities(self);
refreshProcesses(self);
 
% Check if priorities are specified but no priority-aware scheduling policy is used
sn = self.sn;
if any(sn.classprio(:) > 0)
    % Priority classes exist, check if any station uses priority-aware scheduling
    prioScheds = [SchedStrategy.PSPRIO, SchedStrategy.DPSPRIO, SchedStrategy.GPSPRIO, ...
                  SchedStrategy.HOL, SchedStrategy.FCFSPRIO, SchedStrategy.LCFSPRIO, ...
                  SchedStrategy.LCFSPRPRIO, SchedStrategy.LCFSPIPRIO];
    if ~any(ismember(sn.sched, prioScheds))
        line_warning(mfilename, 'Priority classes are specified but no priority-aware scheduling policy (PSPRIO, DPSPRIO, GPSPRIO, HOL, FCFSPRIO, LCFSPRIO, LCFSPRPRIO, LCFSPIPRIO) is used in the model. Priorities will be ignored.\n');
    end
end
 
if any(nodetypes == NodeType.Cache)
    % this also refreshes the routing matrix and the visits
    refreshChains(self, false); % wantVisits
else
    % this also refreshes the routing matrix and the visits
    refreshChains(self, true); % wantVisits
end
sn = self.sn;
refclasses = getReferenceClasses(self);
refclass = zeros(1,sn.nchains);
for c=1:sn.nchains
    isect = intersect(sn.inchain{c},find(refclasses));
    if any(isect)
        refclass(c) = isect;
    end
end
sn.refclass = refclass;
self.sn = sn;
refreshLocalVars(self); % depends on chains (rtnodes)
refreshPetriNetNodes(self);
refreshSync(self); % this assumes that refreshChain is called before
refreshGlobalSync(self);
 
sn = self.sn;
self.hasStruct = true;
 
if any(sn.fj(:)) % if there are forks
    % try to recompute visits after mixed-model transformation:
    % we obtain the visits of auxiliary class from the transformed model
    % then we sum them to the original classes
    %try
    [nonfjmodel, fjclassmap, forkmap, fanOut] = ModelAdapter.mmt(self);
    if any(fanOut==1)
        % in this case, one of the forks is degenerate with a single
        % outgoing link so no visit correction is needed
        line_warning(mfilename,'The specified fork-join topology has partial support, only SolverJMT simulation results may be reliable.\n');
        %    return;
    end
    fsn = nonfjmodel.getStruct();
    for new_chain=(sn.nchains+1):fsn.nchains
        anyAuxClass = fsn.inchain{new_chain}(1);
        origFork = forkmap(anyAuxClass);
        origChain = find(sn.chains(:,fjclassmap(anyAuxClass))); % original chain of the class
        fsn.nodevisits{new_chain}(fsn.nodetype == NodeType.Source | fsn.nodetype == NodeType.Sink | fsn.nodetype == NodeType.Fork,:) = 0;
        Vaux = fsn.nodevisits{new_chain}(:,fsn.inchain{new_chain});
        if fsn.nnodes > sn.nnodes % if source-sink were added
            Vaux(fsn.nodetype == NodeType.Source | fsn.nodetype == NodeType.Sink,:) = [];
        end
        X = sn.nodevisits{origChain};
        for jaux=1:length(fsn.inchain{new_chain})
            j = sn.inchain{origChain}(jaux); % class in the original chain
            self.sn.nodevisits{origChain}(:,j) = sn.nodeparam{origFork}.fanOut*(X(:,j) + Vaux(:,jaux));
        end
    end
end
 
sn = refreshRegions(self);
self.sn = sn;
end
 
function stat_idx = nd2st(sn, node_idx)
% STAT_IDX = ND2ST(NODE_IDX)
 
if sn.isstation(node_idx)
    stat_idx = at(cumsum(sn.isstation),node_idx);
else
    stat_idx = NaN;
end
end
 
function node_idx = st2nd(sn,stat_idx)
% NODE_IDX = ST2ND(SELF,STAT_IDX)
 
v = cumsum(sn.isstation) == stat_idx;
if any(v)
    node_idx =  find(v, 1);
else
    node_idx = NaN;
end
end
 
function sful_idx = st2sf(sn,stat_idx)
% SFUL_IDX = ST2SF(SELF,STAT_IDX)
 
sful_idx = nd2sf(sn,st2nd(sn,stat_idx));
end
 
function sful_idx = nd2sf(sn, node_idx)
% SFUL_IDX = ND2SF(NODE_IDX)
 
if sn.isstateful(node_idx)
    sful_idx = at(cumsum(sn.isstateful),node_idx);
else
    sful_idx = NaN;
end
end
 
function node_idx = sf2nd(sn,stat_idx)
% NODE_IDX = SF2ND(SELF,STAT_IDX)
 
v = cumsum(sn.isstateful) == stat_idx;
if any(v)
    node_idx =  find(v, 1);
else
    node_idx = NaN;
end
end
 
function stat_idx = sf2st(sn,sful_idx)
% STAT_IDX = SF2ST(SELF,SFUL_IDX)
 
stat_idx = nd2st(sn,sf2nd(sn,sful_idx));
end