getAvgHandles.m

function [Q,U,R,T,A,W] = getAvgHandles(self)
% [Q,U,R,T,A,W] = GETAVGHANDLES()
% Get handles for mean performance metrics.
%
% Q(i,r): mean queue-length of class r at node i
% U(i,r): mean utilization of class r at node i
% R(i,r): mean response time of class r at node i (summed across visits)
% T(i,r): mean throughput of class r at node i
% A(i,r): mean arrival rate of class r at node i
% W(i,r): mean residence time of class r at node i
%
% For tardiness metrics, use getAvgTrdnHandles() and getAvgSysTrdnHandles()
 
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
% Q = self.getAvgQLenHandles;
% U = self.getAvgUtilHandles;
% R = self.getAvgRespTHandles;
% T = self.getAvgTputHandles;
% A = self.getAvgArvRHandles;
% W = self.getAvgResidTHandles;
 
M = getNumberOfStations(self);
K = getNumberOfClasses(self);
classes = self.classes;
stations = self.stations;
 
isSource = false(M,1);
isSink = false(M,1);
hasServiceTunnel = false(M,1);
isServiceDefined = true(M,K);
for ist=1:M
    isSource(ist) = isa(stations{ist},'Source');
    isSink(ist) = isa(stations{ist},'Sink');
    hasServiceTunnel(ist) = strcmpi(class(stations{ist}.server),'ServiceTunnel');
    if ~hasServiceTunnel(ist)
        for r=1:K
            if isempty(stations{ist}.server.serviceProcess{r}) || stations{ist}.server.serviceProcess{r}{end}.isDisabled()
                isServiceDefined(ist,r) = false;
            end
        end
    end
end
 
if isempty(self.handles) || ~isfield(self.handles,'Q')
    Q = cell(M,K); % queue-length
    for ist=1:M
        for r=1:K
            Qir = Metric(MetricType.QLen, classes{r}, stations{ist});
            if isSource(ist)
                Qir.disabled = true;
            end
            if isSink(ist)
                Qir.disabled = true;
            end
            if ~hasServiceTunnel(ist)
                if ~isServiceDefined(ist,r)
                    Qir.disabled = true;
                end
            end
            Q{ist,r} = Qir;
        end
    end
    self.handles.Q = Q;
else
    Q = self.handles.Q;
end
 
if isempty(self.handles) || ~isfield(self.handles,'U')
    M = getNumberOfStations(self);
    K = getNumberOfClasses(self);
    
    U = cell(M,1); % utilizations
    for ist=1:M
        for r=1:K
            Uir = Metric(MetricType.Util, classes{r}, stations{ist});
            if isSource(ist)
                Uir.disabled = true;
            end
            if isSink(ist)
                Uir.disabled = true;
            end
            if isa(stations{ist},'Join') || isa(stations{ist},'Fork')
                Uir.disabled = true;
            end
            if ~hasServiceTunnel(ist)
                if ~isServiceDefined(ist,r)
                    Uir.disabled = true;
                end
            end
            U{ist,r} = Uir;
        end
    end
    self.handles.U = U;
else
    U = self.handles.U;
end
 
if isempty(self.handles) || ~isfield(self.handles,'R')
    M = getNumberOfStations(self);
    K = getNumberOfClasses(self);
    
    R = cell(M,K); % response times
    for ist=1:M
        for r=1:K
            Rir = Metric(MetricType.RespT, classes{r}, stations{ist});
            if isSource(ist)
                Rir.disabled = true;
            end
            if isSink(ist)
                Rir.disabled = true;
            end
            if ~hasServiceTunnel(ist)
                if ~isServiceDefined(ist,r)
                    Rir.disabled = true;
                end
            end
            R{ist,r} = Rir;
        end
    end
    self.handles.R = R;
else
    R = self.handles.R;
end
 
if isempty(self.handles) || ~isfield(self.handles,'W')
    M = getNumberOfStations(self);
    K = getNumberOfClasses(self);
    
    W = cell(M,K); % response times
    for ist=1:M
        for r=1:K
            Wir = Metric(MetricType.ResidT, classes{r}, stations{ist});
            if isSource(ist)
                Wir.disabled = true;
            end
            if isSink(ist)
                Wir.disabled = true;
            end
            if ~hasServiceTunnel(ist)
                if ~isServiceDefined(ist,r)
                    Wir.disabled = true;
                end
            end
            W{ist,r} = Wir;
        end
    end
    self.handles.W = W;
else
    W = self.handles.W;
end
 
 
if isempty(self.handles) || ~isfield(self.handles,'T')
    M = getNumberOfStations(self);
    K = getNumberOfClasses(self);
    
    T = cell(1,K); % throughputs
    for ist=1:M
        for r=1:K
            Tir = Metric(MetricType.Tput, classes{r}, stations{ist});
            if ~hasServiceTunnel(ist)
                if ~isServiceDefined(ist,r)
                    Tir.disabled = true;
                end
            end
            T{ist,r} = Tir;
        end
    end
    self.handles.T = T;
else
    T = self.handles.T;
end
 
if isempty(self.handles) || ~isfield(self.handles,'A')
    M = getNumberOfStations(self);
    K = getNumberOfClasses(self);
 
    A = cell(1,K); % arrival rate
    for ist=1:M
        for r=1:K
            Air = Metric(MetricType.ArvR, classes{r}, stations{ist});
            if ~hasServiceTunnel(ist)
                if ~isServiceDefined(ist,r)
                    Air.disabled = true;
                end
            end
            A{ist,r} = Air;
        end
    end
    self.handles.A = A;
else
    A = self.handles.A;
end
 
if isempty(self.handles) || ~isfield(self.handles,'Trdn')
    M = getNumberOfStations(self);
    K = getNumberOfClasses(self);
 
    Trdn = cell(M,K); % tardiness
    for ist=1:M
        for r=1:K
            Trdnir = Metric(MetricType.Trdn, classes{r}, stations{ist});
            if isSource(ist)
                Trdnir.disabled = true;
            end
            if ~hasServiceTunnel(ist)
                if ~isServiceDefined(ist,r)
                    Trdnir.disabled = true;
                end
            end
            Trdn{ist,r} = Trdnir;
        end
    end
    self.handles.Trdn = Trdn;
else
    Trdn = self.handles.Trdn;
end
 
if isempty(self.handles) || ~isfield(self.handles,'SysTrdn')
    M = getNumberOfStations(self);
    K = getNumberOfClasses(self);
 
    SysTrdn = cell(1,K); % system tardiness
    for r=1:K
        SysTrdnr = Metric(MetricType.SysTrdn, classes{r}, []);
        SysTrdn{1,r} = SysTrdnr;
    end
    self.handles.SysTrdn = SysTrdn;
else
    SysTrdn = self.handles.SysTrdn;
end
 
end