LineEvaluator.m

classdef LineEvaluator < handle
    % LineEvaluator  Interface between the optimizer and SolverAuto. Applies
    % decision variable values to a per-evaluation model copy, solves, and
    % extracts per-(station,class) and system metrics. Mirrors native-Python
    % line_solver.opt.evaluator.LineEvaluator.
    %
    % A copied model carries a cached NetworkStruct that scalar setters do not
    % invalidate, so evaluateValues forces refreshStruct after applying
    % variables.
 
    properties
        baseModel
        variables       % cell of opt.DecisionVariable
        fixedVariables  % cell of {var, value}
        evaluationCount = 0;
        totalDimension
        varOffsets
    end
 
    methods
        function obj = LineEvaluator(model, variables, fixedVariables)
            obj.baseModel = model;
            obj.variables = variables;
            if nargin >= 3 && ~isempty(fixedVariables)
                obj.fixedVariables = fixedVariables;
            else
                obj.fixedVariables = {};
            end
            dim = 0;
            obj.varOffsets = zeros(1, numel(variables));
            for i = 1:numel(variables)
                obj.varOffsets(i) = dim;
                dim = dim + variables{i}.getDimension();
            end
            obj.totalDimension = dim;
        end
 
        function n = getEvaluationCount(obj), n = obj.evaluationCount; end
 
        function b = getBounds(obj)
            b = [];
            for i = 1:numel(obj.variables)
                b = [b; obj.variables{i}.getBounds()]; %#ok<AGROW>
            end
        end
 
        function values = decodeVariables(obj, x)
            values = containers.Map('KeyType', 'char', 'ValueType', 'any');
            for i = 1:numel(obj.variables)
                var = obj.variables{i};
                offset = obj.varOffsets(i);
                dim = var.getDimension();
                slice = x(offset+1 : offset+dim);
                values(var.getName()) = var.decode(slice);
            end
        end
 
        function applyVariables(obj, model, values)
            for i = 1:numel(obj.variables)
                var = obj.variables{i};
                if isKey(values, var.getName())
                    var.apply(model, values(var.getName()));
                end
            end
        end
 
        function m = copyModel(obj)
            m = obj.baseModel.copy();
        end
 
        function result = evaluateValues(obj, values)
            obj.evaluationCount = obj.evaluationCount + 1;
            result = opt.EvaluationResult();
            try
                model = obj.copyModel();
                for k = 1:numel(obj.fixedVariables)
                    fv = obj.fixedVariables{k};
                    fv{1}.apply(model, fv{2});
                end
                obj.applyVariables(model, values);
                model.refreshStruct();
 
                solver = SolverAuto(model);
                [QN, UN, RN, ~, ~, TN] = solver.getAvg();
                result.feasible = true;
                try
                    result.solverUsed = solver.getSelectedSolverName();
                catch
                    result.solverUsed = '';
                end
                obj.extractMetrics(model, QN, UN, RN, TN, result);
                obj.extractSystemMetrics(solver, model, result);
                result.sensitivities = opt.sens.computeModelSensitivities(model);
            catch ME %#ok<NASGU>
                result.feasible = false;
            end
        end
 
        function extractMetrics(~, model, QN, UN, RN, TN, result)
            sn = model.getStruct();
            R = sn.nclasses;
            for ist = 1:sn.nstations
                nodeIdx = sn.stationToNode(ist);
                st = sn.nodenames{nodeIdx};
                for r = 1:R
                    cl = sn.classnames{r};
                    if ~isempty(RN), result.setResponseTime(st, cl, RN(ist, r)); end
                    if ~isempty(TN), result.setThroughput(st, cl, TN(ist, r)); end
                    if ~isempty(QN), result.setQueueLength(st, cl, QN(ist, r)); end
                    if ~isempty(UN)
                        if isKey(result.utilizations, st)
                            result.utilizations(st) = result.utilizations(st) + UN(ist, r);
                        else
                            result.utilizations(st) = UN(ist, r);
                        end
                    end
                end
            end
        end
 
        function extractSystemMetrics(~, solver, model, result)
            try
                [SysRespT, SysTput] = solver.getAvgSys();
            catch
                return;
            end
            SysRespT = SysRespT(:); SysTput = SysTput(:);
            sn = model.getStruct();
            chains = sn.chains; classnames = sn.classnames;
            njobs = sn.njobs(:);
            nchains = size(chains, 1); nclasses = size(chains, 2);
            for ci = 1:nchains
                members = {};
                isOpen = false;
                for k = 1:nclasses
                    if chains(ci, k) > 0
                        members{end+1} = classnames{k}; %#ok<AGROW>
                        if isinf(njobs(k)), isOpen = true; end
                    end
                end
                if isempty(members), continue; end
                tput = 0.0; if ci <= numel(SysTput), tput = SysTput(ci); end
                respt = NaN; if ci <= numel(SysRespT), respt = SysRespT(ci); end
                if isOpen && tput > 0 && result.queueLengths.Count > 0
                    jobsInSystem = 0.0;
                    ks = keys(result.queueLengths);
                    for kk = 1:numel(ks)
                        parts = strsplit(ks{kk}, '||');
                        if any(strcmp(parts{2}, members))
                            jobsInSystem = jobsInSystem + result.queueLengths(ks{kk});
                        end
                    end
                    respt = jobsInSystem / tput;
                end
                for mi = 1:numel(members)
                    if ~isnan(respt), result.systemResponseTimes(members{mi}) = respt; end
                    result.systemThroughputs(members{mi}) = tput;
                end
            end
        end
 
        function result = evaluateValuesWithCache(obj, values, cache)
            key = opt.LineEvaluator.valuesKey(values);
            if isKey(cache, key)
                result = cache(key);
            else
                result = obj.evaluateValues(values);
                cache(key) = result; %#ok<NASGU>
            end
        end
    end
 
    methods (Static)
        function key = valuesKey(values)
            ks = sort(keys(values));
            parts = cell(1, numel(ks));
            for i = 1:numel(ks)
                v = values(ks{i});
                if isnumeric(v)
                    parts{i} = [ks{i} '=' mat2str(round(v(:).' * 1e9) / 1e9)];
                else
                    parts{i} = [ks{i} '=' num2str(v)];
                end
            end
            key = strjoin(parts, ';');
        end
    end
end