solveCli.m

function data = solveCli(self, options, extraFlags)
% DATA = SOLVECLI(OPTIONS, EXTRAFLAGS)
%
% Fully JSON-mediated LDES solve. Serializes the model natively to model.json
% (linemodel_save, no in-process Java object marshalling), runs the LDES engine
% as a subprocess exchanging only JSON ("solve model.json -o result.json"), and
% returns the jsondecode'd result struct. Returns [] on any failure.
%
% The engine is either the native GraalVM binary (common/ldes) or, failing that,
% "java -jar common/ldes.jar" (same shaded engine). No JPype/JLINE path remains.
%
% EXTRAFLAGS is an optional cellstr of additional CLI tokens, e.g.
% {'--timespan','0,100','--trajectory'} or {'--export-histogram'}.
 
if nargin < 3 || isempty(extraFlags)
    extraFlags = {};
end
data = [];
 
tmpDir = tempname;
if ~mkdir(tmpDir)
    return;
end
cleaner = onCleanup(@() rmdirQuiet(tmpDir)); %#ok<NASGU>
modelPath = fullfile(tmpDir, 'model.json');
resultPath = fullfile(tmpDir, 'result.json');
 
% Serialize the model to the CLI model.json format natively (no LINE2JLINE).
try
    linemodel_save(self.model, modelPath);
catch ME
    line_debug('LDES solveCli: linemodel_save failed: %s', ME.message);
    return;
end
if exist(modelPath, 'file') ~= 2
    return;
end
 
% Resolve the ordered engine command prefixes (native binary, then jar).
runners = SolverLDES.getLdesRunners();
if isempty(runners)
    line_error(mfilename, ['No runnable LDES engine found (neither the native ' ...
        'common/ldes binary nor a Java runtime for common/ldes.jar).']);
end
 
% Marked (MMAP) source arrivals: an engine that predates the MMAP JSON schema
% deserializes no arrival process and idles forever instead of failing fast,
% so the fall-through never triggers. Prefer the jar runner (always rebuilt
% with the sources) over the AOT native binary for such models.
%
% Class dependence beta_{i,r}(n) is the same hazard and is worse, because it
% fails silently rather than by idling: an engine predating the classDependence
% JSON schema simply reads no scaling and simulates the UNSCALED network,
% returning plausible numbers that are wrong. Prefer the jar runner for such
% models too.
if numel(runners) > 1
    preferJar = false;
    for ni = 1:numel(self.model.nodes)
        nd = self.model.nodes{ni};
        if isa(nd, 'Source') && ~isempty(nd.markedClasses)
            preferJar = true;
            break;
        end
        if isa(nd, 'Station') && ~isempty(nd.lcdScaling)
            preferJar = true;
            break;
        end
    end
    if preferJar
        runners = runners(end:-1:1);
    end
end
 
% Flags shared across runners (mirror the Python-native flag set).
flags = sprintf('-s %d --seed %d', round(options.samples), round(options.seed));
if isfield(options, 'method') && (ischar(options.method) || isstring(options.method)) ...
        && ~strcmpi(char(options.method), 'default')
    flags = sprintf('%s --method %s', flags, char(options.method));
end
% Warm-start placement (station-major vector) via --initsol.
if isfield(options, 'init_sol') && ~isempty(options.init_sol)
    v = options.init_sol(:).';
    flags = sprintf('%s --initsol %s', flags, strjoin(arrayfun(@(x) num2str(x, '%.10g'), v, ...
        'UniformOutput', false), ','));
end
% Discrete-time (slotted) mode. --slotlength implies --slotted on the CLI side,
% but both are emitted when the length is non-default so the command line states
% the intent explicitly.
slottedOn = false;
if isfield(options, 'slotted') && ~isempty(options.slotted)
    slottedOn = logical(options.slotted);
elseif isfield(options, 'config') && isstruct(options.config) ...
        && isfield(options.config, 'slotted') && ~isempty(options.config.slotted)
    slottedOn = logical(options.config.slotted);
end
if slottedOn
    flags = sprintf('%s --slotted', flags);
    slotLen = 1;
    if isfield(options, 'slotlength') && ~isempty(options.slotlength)
        slotLen = options.slotlength;
    elseif isfield(options, 'config') && isstruct(options.config) ...
            && isfield(options.config, 'slotlength') && ~isempty(options.config.slotlength)
        slotLen = options.config.slotlength;
    end
    if slotLen ~= 1
        flags = sprintf('%s --slotlength %.10g', flags, slotLen);
    end
end
% Convergence-based stopping, if configured on the options.
if isfield(options, 'cnvgon') && ~isempty(options.cnvgon) && options.cnvgon
    flags = sprintf('%s --cnvgon', flags);
    if isfield(options, 'iter_tol') && ~isempty(options.iter_tol) && isfinite(options.iter_tol)
        flags = sprintf('%s --cnvgtol %.10g', flags, options.iter_tol);
    end
end
for i = 1:numel(extraFlags)
    flags = sprintf('%s %s', flags, extraFlags{i});
end
 
% Try each runner in order; the native binary may lack some reflective features
% (e.g. fork-join MMT serialization), so fall through to the JVM jar on failure.
lastOut = '';
for ri = 1:numel(runners)
    if exist(resultPath, 'file') == 2
        delete(resultPath);
    end
    cmd = sprintf('%s solve "%s" -o "%s" %s', runners{ri}, modelPath, resultPath, flags);
    [status, cmdout] = system(cmd);
    lastOut = cmdout;
    if status == 0 && exist(resultPath, 'file') == 2
        try
            data = jsondecode(fileread(resultPath));
        catch ME
            line_error(mfilename, sprintf('LDES result JSON parse failed: %s', ME.message));
        end
        if isstruct(data) && isfield(data, 'error')
            line_error(mfilename, sprintf('LDES engine error: %s', data.error));
        end
        return;
    end
    line_debug('LDES runner %d/%d failed (status=%d); trying next.', ri, numel(runners), status);
end
 
line_error(mfilename, sprintf('LDES engine failed on all %d runner(s): %s', ...
    numel(runners), lastOut));
end
 
function rmdirQuiet(d)
% RMDIRQUIET Remove directory d and contents, ignoring errors.
try
    if exist(d, 'dir')
        rmdir(d, 's');
    end
catch
end
end