initDefault.m

function initDefault(self, nodes)
% INITDEFAULT(NODES)
 
% open classes empty
% closed classes initialized at ref station
% running jobs are allocated in class id order until all
% servers are busy
 
%refreshStruct(self);  % we force update of the model before we initialize
 
sn = self.getStruct(false);
 
R = sn.nclasses;
N = sn.njobs';
if nargin < 2
    nodes = 1:self.getNumberOfNodes;
end
 
for ind=nodes
    if sn.isstation(ind)
        ist = sn.nodeToStation(ind);
        n0 = zeros(1,length(N)); % number of jobs in the initial state
        s0 = zeros(1,length(N)); % number of active servers in the initial state
        s = sn.nservers(ist); % allocate
        for r=find(isfinite(N))' % for all closed classes
            if sn.nodeToStation(ind) == sn.refstat(r)
                n0(r) = N(r);
            end
            s0(r) = min(n0(r),s);
            s = s - s0(r);
        end
        switch sn.nodetype(ind)
            case NodeType.Cache
                state_i = State.fromMarginalAndStarted(sn,ind,n0(:)',s0(:)');
                % Cache state width = totalCacheCapacity + (per-item retrieval bitmap).
                % Initialize the cache region with items 1..totalCacheCapacity and the
                % retrieval-system region (one column per item) with zeros (nothing
                % being retrieved). The bitmap is omitted when no retrieval system.
                if isfield(sn.nodeparam{ind}, 'totalCacheCapacity')
                    tcc = sn.nodeparam{ind}.totalCacheCapacity;
                else
                    tcc = sn.nvars(ind,2*R+1);
                end
                rbw = 0;
                if isfield(sn.nodeparam{ind},'retrievalSystemCapacity') ...
                        && sn.nodeparam{ind}.retrievalSystemCapacity > 0
                    rbw = sn.nodeparam{ind}.nitems;
                end
                state_i = [state_i, 1:tcc, zeros(1,rbw)]; %#ok<AGROW>
            case NodeType.Place
                if sum(self.nodes{ind}.state)>0
                    % if the user pre-loaded manually some jobs, keep them
                    state_i = self.nodes{ind}.state;
                else
                    state_i = zeros(1,self.getNumberOfClasses);
                    for r=1:sn.nclasses
                        if sn.refstat(r) == ist
                            state_i(r) = sn.njobs(r);
                        else
                            state_i(r) = 0;
                        end
                    end
                end
            otherwise
                if sn.isstation(ind) && sn.sched(ist) == SchedStrategy.PAS
                    % Pass-and-swap stations: the full ordered state space (all
                    % placements of the marginal) is built independently of the
                    % initial state, while the user-specified placement (if any)
                    % is kept as the initial state. A closed PAS station holding
                    % more than one job under a non-empty swapping graph has a
                    % reducible generator (one recurrent component per placement
                    % order), so the placement is a required model input: error
                    % rather than fabricate a default ordering.
                    userState = self.nodes{ind}.getState();
                    hasUser = ~isempty(userState) && any(userState(:) > 0);
                    sg = [];
                    if numel(sn.nodeparam) >= ind && isstruct(sn.nodeparam{ind}) ...
                            && isfield(sn.nodeparam{ind}, 'swapGraph')
                        sg = sn.nodeparam{ind}.swapGraph;
                    end
                    hasSwap = ~isempty(sg) && any(sg(:) ~= 0);
                    isClosed = any(isfinite(N));
                    if hasUser
                        nUser = zeros(1, R);
                        present = userState(userState > 0);
                        for r = 1:R, nUser(r) = sum(present == r); end
                        sU = zeros(1, R); ss = sn.nservers(ist);
                        for r = 1:R, sU(r) = min(nUser(r), ss); ss = ss - sU(r); end
                        space_i = State.fromMarginalAndStarted(sn, ind, nUser, sU);
                        W = size(space_i, 2);
                        urow = zeros(1, W);
                        cols = min(numel(userState), W);
                        urow(1:cols) = userState(1:cols);
                        % keep the user placement as the initial state (row 1)
                        state_i = unique([urow; space_i], 'rows', 'stable');
                    elseif hasSwap && isClosed && sum(n0) > 1
                        line_error(mfilename, sprintf(['A closed pass-and-swap station with a non-empty swapping ' ...
                            'graph requires an explicit initial job placement (station %d). Call setState on the ' ...
                            'station with the ordered class list (oldest first) before solving.'], ind));
                    else
                        state_i = State.fromMarginalAndStarted(sn, ind, n0(:)', s0(:)');
                    end
                else
                    state_i = State.fromMarginalAndStarted(sn,ind,n0(:)',s0(:)');
                    if sn.isstation(ind)
                        for r=1:sn.nclasses
                            switch sn.procid(sn.nodeToStation(ind),r)
                                case ProcessType.MAP
                                    %state_i = State.cartesian(state_i, [1:sn.phases(i,r)]');
                                    state_i = State.cartesian(state_i, 1);
                            end
                        end
                    end
                end
        end
        for r=1:sn.nclasses
            switch sn.routing(ind,r)
                case {RoutingStrategy.RROBIN, RoutingStrategy.WRROBIN}
                    % start from first connected queue
                    state_i = [state_i, find(sn.connmatrix(ind,:),1)];
            end
        end
        if isempty(state_i)
            line_error(mfilename,sprintf('Default initialization failed on station %d.',ind));
        end
    elseif sn.isstateful(ind) % not a station
        switch sn.nodetype(ind)
            case NodeType.Cache
                % [class counts | cache contents (items 1..tcc) | per-item retrieval
                % bitmap (zeros, nothing being retrieved)]. The bitmap (one column per
                % item) is omitted when no retrieval system is configured.
                tcc = self.nodes{ind}.totalCacheCapacity;
                if self.nodes{ind}.retrievalSystemCapacity > 0
                    rbw = self.nodes{ind}.items.nitems;
                else
                    rbw = 0;
                end
                state_i = [zeros(1,self.getNumberOfClasses), 1:tcc, zeros(1,rbw)];
            case NodeType.Router
                state_i = zeros(1, self.getNumberOfClasses);
                for r=1:sn.nclasses
                    switch sn.routing(ind,r)
                        case RoutingStrategy.RROBIN
                            % RR slot holds destination value; start at first connected queue
                            state_i = [state_i, find(sn.connmatrix(ind,:),1)]; %#ok<AGROW>
                        case RoutingStrategy.WRROBIN
                            % WRR slot holds POSITION in weighted_outlinks; start at 1
                            state_i = [state_i, 1]; %#ok<AGROW>
                        case RoutingStrategy.KCHOICES
                            % KCHOICES with memory: -1 marks "no prior pick".
                            if isfield(self.nodes{ind}.output.outputStrategy{1, r}, 'withMemory') ...
                                    || (iscell(self.nodes{ind}.output.outputStrategy{1, r}) ...
                                        && length(self.nodes{ind}.output.outputStrategy{1, r}) >= 3 ...
                                        && length(self.nodes{ind}.output.outputStrategy{1, r}{3}) >= 2 ...
                                        && self.nodes{ind}.output.outputStrategy{1, r}{3}{2})
                                state_i = [state_i, -1]; %#ok<AGROW>
                            end
                    end
                end
            case NodeType.Transition
                % Differently from a server, the first nmodes states in a
                % transitions count the servers that are not enabled and
                % the last nodes count servers that just fired.
                % This is required as the local state does not encode the
                % buffer hence the enabling condition is not available.
                state_i = sn.nodeparam{ind}.nmodeservers;
                % For infinite servers, use large finite value for state (SSA needs finite states)
                state_i(isinf(state_i)) = GlobalConstants.MaxInt();
                % For non-Markovian distributions, firingphases is NaN - treat as 1 phase
                firingphases = sn.nodeparam{ind}.firingphases;
                firingphases(isnan(firingphases)) = 1;
                state_i = [state_i, zeros(1, sum(firingphases)), zeros(size(state_i))]; %#ok<AGROW>
            otherwise
                state_i = [];
        end
        %line_error(mfilename,'Default initialization not available on stateful node %d.',i);
    end
 
    if sn.isstateful(ind) % not a station
        if size(state_i,1)==1
            self.nodes{ind}.setStateSpace(state_i);
            self.nodes{ind}.setStatePrior(1);
            self.nodes{ind}.setState(state_i);
        elseif size(state_i,1)>1
            prior_state_i = zeros(1,size(state_i,1)); prior_state_i(1) = 1;
            self.nodes{ind}.setStateSpace(state_i);
            self.nodes{ind}.setStatePrior(prior_state_i);
            self.nodes{ind}.setState(state_i(1,:));
        else
            self.nodes{ind}.setStateSpace([]);
            self.nodes{ind}.setStatePrior([]);
            self.nodes{ind}.setState([]);
        end
    end
end
 
if self.isStateValid % problem with example_initState_2
    self.hasState = true;
else
    line_error(mfilename,sprintf('Default initialization failed.'));
end
end