← Back to Tutorials Prev: Tutorial 10 Next: Tutorial 12

Tutorial 11: Random Environments

This example demonstrates how to model a queueing system operating in a random environment, where system parameters change according to an underlying environmental process. A server alternates between "Fast" and "Slow" modes with different service rates.

Random Environment Network Diagram 
warning off;

% Example 11: Random environments and ENV solver
%% Block 1: Create base network model
baseModel = Network('BaseModel');
delay = Delay(baseModel, 'ThinkTime');
queue = Queue(baseModel, 'Server', SchedStrategy.FCFS);

N = 5;
jobclass = ClosedClass(baseModel, 'Jobs', N, delay);
delay.setService(jobclass, Exp(1.0));
queue.setService(jobclass, Exp(2.0));
baseModel.link(Network.serialRouting(delay, queue));

%% Block 2: Create the random environment
env = Environment('ServerModes');

% Stage 1: Fast mode (service rate = 4.0)
fastModel = baseModel.copy();
fastQueue = fastModel.getNodeByName('Server');
fastQueue.setService(fastModel.classes{1}, Exp(4.0));
env.addStage('Fast', 'operational', fastModel);

% Stage 2: Slow mode (service rate = 1.0)
slowModel = baseModel.copy();
slowQueue = slowModel.getNodeByName('Server');
slowQueue.setService(slowModel.classes{1}, Exp(1.0));
env.addStage('Slow', 'degraded', slowModel);

% Define transitions
env.addTransition('Fast', 'Slow', Exp(0.5));
env.addTransition('Slow', 'Fast', Exp(1.0));

%% Block 3: Solve using SolverENV
env.init();
solverFactory = @(m) FLD(m);
envSolver = ENV(env, solverFactory);
envAvgTable = envSolver.getAvgTable()
Coming soon: Kotlin implementation for random environments is under development. 
from line_solver import Network, ClosedClass, Delay, Queue
from line_solver import Environment, ENV, FLD, MVA
from line_solver.constants import SchedStrategy
from line_solver.distributions import Exp

# Block 1: Create base network model
base_model = Network('BaseModel')
delay = Delay(base_model, 'ThinkTime')
queue = Queue(base_model, 'Server', SchedStrategy.FCFS)

N = 5
jobclass = ClosedClass(base_model, 'Jobs', N, delay)
delay.setService(jobclass, Exp(1.0))
queue.setService(jobclass, Exp(2.0))
base_model.link(Network.serialRouting(delay, queue))

# Block 2: Create the random environment
env = Environment('ServerModes', 2)

# Stage 0: Fast mode (service rate = 4.0)
fast_model = base_model.copy()
fast_queue = fast_model.getNodeByName('Server')
fast_queue.setService(fast_model.classes[0], Exp(4.0))
env.addStage(0, 'Fast', 'operational', fast_model)

# Stage 1: Slow mode (service rate = 1.0)
slow_model = base_model.copy()
slow_queue = slow_model.getNodeByName('Server')
slow_queue.setService(slow_model.classes[0], Exp(1.0))
env.addStage(1, 'Slow', 'degraded', slow_model)

# Define transitions
env.addTransition(0, 1, Exp(0.5))  # Fast -> Slow
env.addTransition(1, 0, Exp(1.0))  # Slow -> Fast

# Block 3: Solve using SolverENV
env_solver = ENV(env, lambda m: FLD(m))
env_avg_table = env_solver.getAvgTable()
print(env_avg_table)

Expected Output

envAvgTable =
  2x6 table
     Station     JobClass     QLen      Util      RespT      Tput
    _________    ________    ______    ______    _______    ______
    ThinkTime      Jobs      2.9966    2.9966          1    2.9966
    Server         Jobs      2.0034         1    0.66779         3
← Back to Tutorials Prev: Tutorial 10 Next: Tutorial 12