afterEventJoin.m

function [outspace, outrate, outprob, eventCache] = afterEventJoin(sn, ind, inspace, event, class, isSimulation, eventCache, key)
% [OUTSPACE, OUTRATE, OUTPROB, EVENTCACHE] = AFTEREVENTJOIN(SN, IND, INSPACE, EVENT, CLASS, ISSIMULATION, EVENTCACHE, KEY)
%
% Handle afterEvent logic for Join stations on FJ-augmented structs
% (see ModelAdapter.fjtag). The join state is a plain per-class count
% vector [n_1..n_R] of buffered jobs: auxiliary-class entries count the
% sibling tasks waiting for synchronization.
%
% ARV (passive): buffer the arriving job/sibling.
% DEP in an original class r (active, immediate): enabled when a plain
% class-r job is buffered, or when some tag t has the full required
% sibling multiset present (all B branches, identity matching by tag).
% The firing consumes the siblings of the LOWEST complete tag and lets
% one class-r job depart; the r->destination move is the regular sync
% pairing generated by refreshSync from the join routing.
 
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
 
outspace = [];
outrate = [];
outprob = 1;
 
R = sn.nclasses;
n = inspace(:,(end-R+1):end); % per-class counts (rows x R)
 
switch event
    case EventType.ARV
        n(:,class) = n(:,class) + 1;
        outspace = n;
        outrate = -1*ones(size(outspace,1),1); % passive action, rate is unspecified
    case EventType.DEP
        fjp = [];
        if iscell(sn.nodeparam) && length(sn.nodeparam) >= ind && isstruct(sn.nodeparam{ind}) && isfield(sn.nodeparam{ind},'fj')
            fjp = sn.nodeparam{ind}.fj;
        end
        % auxiliary sibling classes never depart individually: they are
        % consumed only by the original-class join firing below
        isaux = false;
        if ~isempty(fjp)
            for rr=fjp.origclasses(:)'
                if ~isempty(fjp.auxmatrix{rr}) && any(any(fjp.auxmatrix{rr} == class))
                    isaux = true;
                    break
                end
            end
        end
        if isaux
            return
        end
        outspace = zeros(0,R);
        outrate = zeros(0,1);
        outprob = zeros(0,1);
        for row=1:size(n,1)
            nrow = n(row,:);
            if nrow(class) > 0
                % plain (non-forked) job buffered in the departing class
                nrow(class) = nrow(class) - 1;
                outspace(end+1,:) = nrow; %#ok<AGROW>
                outrate(end+1,1) = GlobalConstants.Immediate; %#ok<AGROW>
                outprob(end+1,1) = 1; %#ok<AGROW>
            elseif ~isempty(fjp) && length(fjp.auxmatrix) >= class && ~isempty(fjp.auxmatrix{class})
                auxm = fjp.auxmatrix{class}; % B x T matrix of auxiliary class indices
                req = fjp.required{class};   % B x 1 required siblings per branch
                T = size(auxm,2);
                tstar = 0;
                for t=1:T
                    if all(nrow(auxm(:,t)) >= req(:)')
                        tstar = t; % lowest complete tag, canonical consumption
                        break
                    end
                end
                if tstar > 0
                    nrow(auxm(:,tstar)) = nrow(auxm(:,tstar)) - req(:)';
                    outspace(end+1,:) = nrow; %#ok<AGROW>
                    outrate(end+1,1) = GlobalConstants.Immediate; %#ok<AGROW>
                    outprob(end+1,1) = 1; %#ok<AGROW>
                end
            end
        end
        if isempty(outspace)
            outspace = [];
            outrate = [];
            outprob = 1;
        end
end
 
if isSimulation
    if nargin>=7 && isobject(eventCache)
        eventCache(key) = {outprob, outspace, outrate};
    end
    if size(outspace,1) > 1
        tot_rate = sum(outrate);
        cum_rate = cumsum(outrate) / tot_rate;
        firing_ctr = 1 + max([0,find( rand > cum_rate' )]); % select action
        outspace = outspace(firing_ctr,:);
        outrate = sum(outrate);
        outprob = outprob(firing_ctr,:);
    end
end
 
end