Station.m

classdef Station < StatefulNode
    % An abstract class for nodes where jobs station
    %
    % Copyright (c) 2012-2026, Imperial College London
    % All rights reserved.
 
    properties
        numberOfServers;
        cap;
        dropRule;
        classCap;
        lldScaling; % limited load-dependence scaling factors
        lcdScaling; % limited class-dependence scaling factors
        lcdScalingPeak; % peak (max) class-dependent rate scaling per class, used to normalize Util (T*S/peak)
        stationIndex;
        patienceDistributions; % per-class patience distributions (cell array indexed by class)
    end
 
    methods(Hidden)
        %Constructor
        function self = Station(name)
            % SELF = STATION(NAME)
 
            self@StatefulNode(name);
            self.cap = Inf;
            self.classCap = [];
            self.lldScaling = [];
            self.patienceDistributions = [];
        end
 
        % don't expose to avoid accidental call without checking the queue
        % scheduling discipline
        function setLimitedLoadDependence(self, alpha)
            % SETLIMITEDLOADDEPENDENCE(self, alpha)
            % alpha(ni) is the service rate scaling when there are ni>=1
            % jobs in the system
            self.lldScaling = alpha;
        end
 
        % don't expose to avoid accidental call without checking the queue
        % scheduling discipline
        function setLimitedClassDependence(self, gamma, peakRatePerClass)
            % SETLIMITEDCLASSDEPENDENCE(self, gamma, peakRatePerClass)
            %
            % gamma(ni) is a function handle, where ni=[ni1,...,niR]
            % is the service rate scaling when there are nir jobs at
            % station i in class r.
            % peakRatePerClass is the peak (maximum) value of the rate
            % scaling per class (e.g. the effective number of servers). It is
            % REQUIRED and is used to normalize utilization as Util = T*S/peak,
            % matching the T*S/c convention of ordinary multiserver stations.
            % A scalar is broadcast to every class.
            if ~isa(gamma,'function_handle')
                line_error(mfilename, 'Class dependence must be specified through a function handle.');
            end
            if nargin < 3 || isempty(peakRatePerClass)
                line_error(mfilename, 'Class dependence requires an explicit peak rate: setClassDependence(beta, peakRatePerClass). Pass a scalar (identical peak for every class) or a per-class vector.');
            end
            if ~isnumeric(peakRatePerClass) || any(peakRatePerClass(:) <= 0)
                line_error(mfilename, 'peakRatePerClass must be a positive scalar or per-class vector.');
            end
            self.lcdScaling = gamma;
            self.lcdScalingPeak = peakRatePerClass(:)';
        end
 
        % don't expose to avoid accidental call without checking the queue
 
 
        % don't expose to avoid accidental call without checking the queue
 
 
    end
 
    methods
 
        function self = setDropRule(self, class, drop)
            % SELF = SETDROPRULE(CLASS, DROPRULE)
 
            self.dropRule(class) = drop;
        end
 
 
        function setNumServers(self, value)
            % SETNUMSERVERS(VALUE)
 
            self.numberOfServers = value;
        end
 
        function setNumberOfServers(self, value)
            % SETNUMBEROFSERVERS(VALUE)
 
            self.numberOfServers = value;
        end
 
        function value = getNumServers(self)
            % VALUE = GETNUMSERVERS()
 
            value = self.numberOfServers;
        end
 
        function value = getNumberOfServers(self)
            % VALUE = GETNUMBEROFSERVERS()
 
            value = self.numberOfServers;
        end
 
        function setCapacity(self, value)
            % SETCAPACITY(VALUE)
 
            self.cap = value;
        end
 
        function setCap(self, value)
            % SETCAP(VALUE)
            % Alias for setCapacity() for backwards compatibility
 
            self.setCapacity(value);
        end
 
        function setChainCapacity(self, values)
            % SETCHAINCAPACITY(VALUES)
 
            sn = self.model.getStruct;
            if numel(values) ~= sn.nchains
                line_error(mfilename,'The method requires in input a capacity value for each chain.');
            end
            for c = 1:sn.nchains
                inchain = sn.inchain{c};
                for r = inchain
                    if ~self.isServiceDisabled(r)
                        self.classCap(r) = values(c);
                    else
                        self.classCap(r) = Inf;
                    end
                end
            end
            self.cap = min(sum(self.classCap(self.classCap>0)), self.cap);
        end
 
 
        function isD = isServiceDefined(self, class)
            K = size(self.model.getClasses(),2);
            isD = true(1, K);
            switch self.server.className
                case 'ServiceTunnel'
                    %noop
                otherwise
                    for r=1:K
                        if isempty(self.server.serviceProcess{1,r})
                            isD(r) = false;
                        end
                    end
            end
        end
 
        function isD = isServiceDisabled(self, class)
            % ISD = ISSERVICEDISABLED(CLASS)
            if nargin>=2
                switch self.server.className
                    case 'ServiceTunnel'
                        isD = false;
                    otherwise
                        isD = self.server.serviceProcess{1,class}{end}.isDisabled();
                end
            else
                K = size(self.model.getClasses(),2);
                isD = false(1, K);
                switch self.server.className
                    case 'ServiceTunnel'
                        %noop
                    otherwise
                        %isD = cellfun(@(sp) sp{end}.isDisabled, self.server.serviceProcess);
                        for r=1:K
                            isD(r) = self.server.serviceProcess{1,r}{end}.isDisabled();
                        end
                end
            end
        end
 
        function isI = isServiceImmediate(self, class)
            % ISI = ISSERVICEIMMEDIATE(CLASS)
 
            isI = self.server.serviceProcess{1,class}{end}.isImmediate();
        end
 
        function R = getNumberOfServiceClasses(self)
            % R = GETNUMBEROFSERVICECLASSES()
 
            R = size(self.server.serviceProcess,2);
        end
 
        function [p] = getSelfLoopProbabilities(self)
            % [P] = GETSELFLOOPPROBABILITIES()
 
            R = getNumberOfServiceClasses(self);
            p = zeros(1,R);
            for k=1:R
                nOutLinks = length(self.output.outputStrategy{k}{end});
                switch RoutingStrategy.toText(self.output.outputStrategy{k}{2})
                    case 'Random'
                        p(k) = 1 / nOutLinks;
                    case RoutingStrategy.PROB
                        for t=1:nOutLinks % for all outgoing links
                            if strcmp(self.output.outputStrategy{k}{end}{t}{1}.name, self.name)
                                p(k) = self.output.outputStrategy{k}{end}{t}{2};
                                break
                            end
                        end
                end
            end
        end
 
        function [map, mu, phi] = getSourceRates(self)
            % [PH,MU,PHI] = GETSOURCERATES()
 
            nclasses = size(self.input.sourceClasses,2);
            map = cell(1,nclasses);
            mu = cell(1,nclasses);
            phi = cell(1,nclasses);
            for r=1:nclasses
                if isempty(self.input.sourceClasses{r})
                    self.input.sourceClasses{r} = {[],ServiceStrategy.LI,Disabled.getInstance()};
                    map{r}  = {[NaN],[NaN]};
                    mu{r}  = NaN;
                    phi{r}  = NaN;
                elseif ~self.input.sourceClasses{r}{end}.isDisabled()
                    switch class(self.input.sourceClasses{r}{end})
                        case {'Replayer', 'Trace'}
                            aph = self.input.sourceClasses{r}{end}.fitAPH;
                            map{r} = aph.getProcess();
                            mu{r} = aph.getMu;
                            phi{r} = aph.getPhi;
                        case {'Exp','Coxian','Erlang','HyperExp','Markovian','APH','PH','ME','CME','RAP'}
                            map{r} = self.input.sourceClasses{r}{end}.getProcess;
                            mu{r} = self.input.sourceClasses{r}{end}.getMu;
                            phi{r} = self.input.sourceClasses{r}{end}.getPhi;
                        case {'Det','Uniform','Pareto','Gamma','Lognormal','Weibull'}
                            map{r}  = self.input.sourceClasses{r}{end}.getProcess();
                            mu{r}  = [1/self.input.sourceClasses{r}{end}.getMean];
                            phi{r}  = [1];
                        case {'Bernoulli','Binomial','Poisson'}
                            % Counting distributions used as an interarrival
                            % time. Like the other non-Markovian cases they
                            % carry no MAP representation, so the struct records
                            % the {mean, SCV} pair getProcess() returns. Their
                            % support includes 0; the LDES engine resolves that
                            % zero atom to an immediate interval.
                            map{r}  = self.input.sourceClasses{r}{end}.getProcess();
                            mu{r}  = [self.input.sourceClasses{r}{end}.getRate];
                            phi{r}  = [1];
                        case 'Geometric'
                            % Lattice-valued interarrival time supported on
                            % {1,2,...}. Like the continuous non-Markovian
                            % cases above it has no MAP representation, so the
                            % struct records the {mean, SCV} pair its
                            % getProcess() returns. Without this arm map{r} is
                            % left unassigned and sn.proc comes out empty.
                            map{r}  = self.input.sourceClasses{r}{end}.getProcess();
                            mu{r}  = [self.input.sourceClasses{r}{end}.getRate];
                            phi{r}  = [1];
                        case 'MMPP2'
                            map{r} = self.input.sourceClasses{r}{end}.getProcess();
                            mu{r} = self.input.sourceClasses{r}{end}.getMu;
                            phi{r} = self.input.sourceClasses{r}{end}.getPhi;
                        case 'MAP'
                            map{r} = self.input.sourceClasses{r}{end}.getProcess();
                            mu{r} = self.input.sourceClasses{r}{end}.getMu;
                            phi{r} = self.input.sourceClasses{r}{end}.getPhi;
                        case 'NHPP'
                            map{r} = self.input.sourceClasses{r}{end}.getProcess();
                            mu{r} = self.input.sourceClasses{r}{end}.getTimeAverageRate();
                            phi{r} = 1;
                        case 'BMAP'
                            % {D0, D1, D_batch1, ..., D_batchK}: same layout
                            % as the JAR MatrixCell for batch arrivals
                            map{r} = self.input.sourceClasses{r}{end}.getProcess();
                            mapAggr = self.input.sourceClasses{r}{end}.toMAP;
                            mu{r} = mapAggr.getMu;
                            phi{r} = mapAggr.getPhi;
                        case 'MarkedMAP'
                            % {D0, D1, D11, ..., D1K} (M3A): one shared
                            % modulating chain; the per-mark D1k matrices
                            % select the emitted class (Source.setMarkedArrival
                            % records the mark->class binding). mu/phi describe
                            % the shared chain, so they coincide across the
                            % marked classes.
                            map{r} = self.input.sourceClasses{r}{end}.getProcess();
                            mu{r} = self.input.sourceClasses{r}{end}.getMu;
                            phi{r} = self.input.sourceClasses{r}{end}.getPhi;
                        otherwise
                            % leave everything empty
                    end
                else
                    map{r}  = {[NaN],[NaN]};
                    mu{r}  = NaN;
                    phi{r}  = NaN;
                end
            end
        end
 
        function [map,mu,phi] = getServiceRates(self)
            % [PH,MU,PHI] = GETSERVICERATES()
            
            nclasses = size(self.server.serviceProcess,2);
            map = cell(1,nclasses);
            mu = cell(1,nclasses);
            phi = cell(1,nclasses);
            for r=1:nclasses
                serviceProcess_r = self.server.serviceProcess{r};
                if isempty(serviceProcess_r)
                    serviceProcess_r = {[],ServiceStrategy.LI,Disabled.getInstance()};
                    map{r}  = {[NaN],[NaN]};
                    mu{r}  = NaN;
                    phi{r}  = NaN;
                elseif serviceProcess_r{end}.isImmediate()
                    map{r}  = {[-GlobalConstants.Immediate],[GlobalConstants.Immediate]};
                    mu{r}  = [GlobalConstants.Immediate];
                    phi{r}  = [1];
                elseif ~serviceProcess_r{end}.isDisabled()
                    switch class(serviceProcess_r{end})
                        case {'Det','Uniform','Pareto','Gamma','Weibull','Lognormal'}
                            map{r}  = serviceProcess_r{end}.getProcess();
                            mu{r}  = [serviceProcess_r{end}.getRate];
                            phi{r}  = [1];
                        case {'Bernoulli','Binomial','Poisson'}
                            % Counting distributions used as a service time; see
                            % the matching arm in getSourceRates above.
                            map{r}  = serviceProcess_r{end}.getProcess();
                            mu{r}  = [serviceProcess_r{end}.getRate];
                            phi{r}  = [1];
                        case 'Geometric'
                            % Lattice-valued service time supported on
                            % {1,2,...}; see the matching arm in
                            % getSourceRates above.
                            map{r}  = serviceProcess_r{end}.getProcess();
                            mu{r}  = [serviceProcess_r{end}.getRate];
                            phi{r}  = [1];
                        case {'Replayer', 'Trace'}
                            aph = serviceProcess_r{end}.fitAPH;
                            map{r} = aph.getProcess();
                            mu{r} = aph.getMu;
                            phi{r} = aph.getPhi;
                        case {'Exp','Coxian','Erlang','HyperExp','Markovian','APH','MAP','PH','ME','CME','RAP'}
                            map{r} = serviceProcess_r{end}.getProcess();
                            mu{r} = serviceProcess_r{end}.getMu;
                            phi{r} = serviceProcess_r{end}.getPhi;
                        case 'NHPP'
                            % Mirrors the Source arm above. Without this case the
                            % switch falls through with map/mu/phi unassigned, so a
                            % time-varying service rate reached sn.proc empty.
                            map{r} = serviceProcess_r{end}.getProcess();
                            mu{r} = serviceProcess_r{end}.getTimeAverageRate();
                            phi{r} = 1;
                        case 'MMPP2'
                            map{r} = serviceProcess_r{end}.getProcess();
                            mu{r} = serviceProcess_r{end}.getMu;
                            phi{r} = serviceProcess_r{end}.getPhi;
                    end
                else
                    map{r}  = {[NaN],[NaN]};
                    mu{r}  = NaN;
                    phi{r}  = NaN;
                end
            end
        end
 
        function summary(self)
            % SUMMARY()
 
            line_printf('\nNode: <strong>%s</strong>',self.getName);
            line_printf('\nScheduling: %s',self.schedStrategy);
            line_printf('\nNumber of Servers: %d',self.numberOfServers);
            for r=1:length(self.output.outputStrategy)
                classes = self.model.getClasses();
                line_printf('\nRouting %s: %s',classes{r}.name,self.output.outputStrategy{r}{2});
            end
            %            self.input.summary;
            %            self.server.summary;
            %            self.output.summary;
        end
 
    end
end