solver_nc_mem_supports.m

function [supported, reason] = solver_nc_mem_supports(sn)
% [SUPPORTED, REASON] = SOLVER_NC_MEM_SUPPORTS(SN)
%
% Checks whether the Maximum Entropy Method (Kouvatsos 1994) supports the
% model described by the network structure SN. Returns SUPPORTED=true and
% an empty REASON when the model is a plain open queueing network
% (Section 3.2: Source, Queue, Delay and Sink nodes; GE/GE/1, GE/GE/c and
% GE/GE/inf building blocks), a plain closed queueing network
% (Section 3.3: Queue and Delay nodes; G/G/1 and G/G/inf building blocks
% only, so finite multiserver stations are rejected), or a mixed
% open/closed network (composition of the two algorithms; single-server
% and IS stations only), in all cases without class switching and with
% non-priority scheduling disciplines only; otherwise SUPPORTED=false and
% REASON explains the first unsupported feature found.
%
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
 
supported = false;
reason = '';
 
isopen = sn_is_open_model(sn);
isclosed = sn_is_closed_model(sn);
ismixed = ~isopen && ~isclosed;
 
R = sn.nclasses;
 
% Node types: open models are Source/Queue/Delay/Sink networks, closed
% models are Queue/Delay networks
for ind = 1:sn.nnodes
    switch sn.nodetype(ind)
        case {NodeType.Queue, NodeType.Delay}
            % supported
        case {NodeType.Source, NodeType.Sink}
            if isclosed
                reason = 'MEM supports only Queue and Delay nodes in closed models.';
                return
            end
        otherwise
            reason = 'MEM supports only Source, Queue, Delay and Sink nodes.';
            return
    end
end
 
% Class switching is not part of the Kouvatsos (1994) network model
if any(any(sn.csmask & ~eye(R)))
    reason = 'MEM does not support class switching.';
    return
end
 
% Absorbing self-loops (p_ii=1) make the routing reducible and the
% geometric feedback transform 1/(1-p_ii) degenerate
for ist = 1:sn.nstations
    ind = sn.stationToNode(ist);
    for r = 1:R
        if sn.rtnodes((ind-1)*R + r, (ind-1)*R + r) >= 1 - 1e-9
            reason = 'MEM does not support absorbing self-loop routing (reducible network).';
            return
        end
    end
end
 
% Only non-priority disciplines are supported; the PR/HOL constraint
% formulae are not given in Kouvatsos (1994)
for ist = 1:sn.nstations
    switch sn.sched(ist)
        case {SchedStrategy.EXT, SchedStrategy.INF, SchedStrategy.FCFS, ...
                SchedStrategy.PS, SchedStrategy.SIRO, SchedStrategy.LCFS, ...
                SchedStrategy.LCFSPR}
            % supported
        otherwise
            reason = sprintf('MEM does not support the %s scheduling strategy.', SchedStrategy.toText(sn.sched(ist)));
            return
    end
end
 
if isopen || ismixed
    % A Source node must be present for the external arrival extraction
    hasSource = false;
    for ind = 1:sn.nnodes
        if sn.nodetype(ind) == NodeType.Source
            hasSource = true;
            break;
        end
    end
    if ~hasSource
        reason = 'MEM requires a Source node when open classes are present.';
        return
    end
end
if isclosed || ismixed
    % Closed classes build on G/G/1 and G/G/inf queues only (Section 3.3)
    for ist = 1:sn.nstations
        if isfinite(sn.nservers(ist)) && sn.nservers(ist) > 1
            reason = 'MEM does not support multiserver stations in closed or mixed models.';
            return
        end
    end
end
 
supported = true;
end