Factory Simulation

This notebook contains the factory simulation data structures and functions, and the respective code to run the simulation. The code is divided in 2 cells; the first cell corresponds to the factory_simulation.jl file and the second to the factory_simulation_run.jl file

# factory_simulation.jl

# Load packages
using Distributions, DataStructures, StableRNGs, CSV, Dates, Printf

### Entity
# the struct Entity represents the entity in the factory in a FIFO queue
# it is mutable so you can add the start_service_time field after it is initialised
mutable struct Entity
    id::Int64               # a unique id to be allocated upon arrival
    arrival_time::Float64   # the time of arrival of the entity to the system (from start of simulation)
    start_service_time::Float64  # the time the service starts (from start of simulation)
    completion_time::Float64 # completion time of the service (from start of simulation)
    interrupted::Int64  # time the machine was interrupted because of breakdown
end

# generate a newly arrived entity with unknown start service time, completion time, and interrupted status equal zero
Entity(id::Int64, arrival_time::Float64) = Entity(id, arrival_time, Inf, Inf, 0)


### Events

abstract type Event end

mutable struct Arrival <: Event # entity arrives
    id::Int64         # a unique event id
    time::Float64     # the time of the event 
end


mutable struct Departure <: Event # entity completed
    id::Int64         # a unique event id
    time::Float64     # the time of the event 
end

mutable struct Breakdown <: Event # breakdown of the blades machine
    id::Int64         # a unique event id
    time::Float64     # the time of the event 
end

mutable struct Repair <: Event # repair of the machine
    id::Int64         # a unique event id
    time::Float64     # the time of the event 
end


### Parameters

struct Parameters
    seed::Int
    mean_interarrival::Float64
    mean_construction_time::Float64
    mean_interbreakdown_time::Float64
    mean_repair_time::Float64
end

# Output of the parameters
function write_parameters( output::IO, P::Parameters, T::Float64, units::String) 
    type = typeof(P)
    for name in fieldnames(type)
        println( output, "# parameter: $name = $(getfield(P,name))")
        
    end
    println(output, "# T = $T")
    println(output, "# units = $units")
end

write_parameters( P::Parameters ) = write_parameters( stdout, P )

# Output of the metadata

function write_metadata( output::IO ) 
    (path, prog) = splitdir( @__FILE__ )
    println( output, "# file created by code in $(prog)" )
    t = now()
    println( output, "# file created on $(Dates.format(t, "yyyy-mm-dd at HH:MM:SS"))" )
end

### State

# Represents the state of the system
mutable struct State
    time::Float64                               # the system time (simulation time)
    event_list::PriorityQueue{Event,Float64}    # to keep track of future events
    waiting_room::Queue{Entity}                 # to keep track of waiting entities
    in_service::Queue{Entity}                   # entity currently at server if server available
    n_entities::Int64                           # the number of entities to have been served
    n_events::Int64                             # tracks the number of events to have occur + queued
    machine_status::Bool                        # tracks the machine status (working, not working)
end

function State() # create an initial (empty) state
    init_time = 0.0
    init_event_list = PriorityQueue{Event,Float64}()
    init_waiting_room = Queue{Entity}()
    init_in_service = Queue{Entity}()
    init_n_entities = 0
    init_n_events = 0
    init_machine_status = false
    
    return State( init_time,
                        init_event_list,
                        init_waiting_room,
                        init_in_service,
                        init_n_entities,
                        init_n_events,
                        init_machine_status
                        

                    )
end


### Random generators

struct RandomNGs
    rng::StableRNGs.LehmerRNG
    interarrival_time::Function
    construction_time::Function
    interbreakdown_time::Function
    repair_time::Function
end

# Create function for all random parameters
function RandomNGs( P::Parameters )
    rng = StableRNG( P.seed ) # create a new RNG with seed set to that required
    interarrival_time() = rand( rng, Exponential( P.mean_interarrival))  # Create new interarrival time with exponential distribution
    construction_time() = P.mean_construction_time # Create deterministic contruction time
    interbreakdown_time() = rand( rng, Exponential( P.mean_interbreakdown_time)) # Create exponential interbreakdown time  
    repair_time() = rand( rng, Exponential( P.mean_repair_time)) # Create exponential repair time
    return RandomNGs( rng, interarrival_time,  construction_time, interbreakdown_time, repair_time)
end


### Update functions

function update!( S::State, R::RandomNGs, E::Event)
    throw( DomainError("invalid event type" ))
end

# Create function for moving the entity to service (i.e. move the parts of the lawnmower to the machine)

function move_to_machine!( S::State, R::RandomNGs)

    
    entity = dequeue!(S.waiting_room) # remove entity from waiting room
    entity.start_service_time = S.time     # start production 'now'
    entity.completion_time = entity.start_service_time + R.construction_time() # total completion time includes contruction time
    enqueue!(S.in_service, entity) # add the entity to the service queue

    
    
    # Create a departure event for this entity
    S.n_events += 1 # add an event
    departure_event = Departure( S.n_events, entity.completion_time) # create departure event
    enqueue!(S.event_list, departure_event, entity.completion_time) # add departure event to event list

   return nothing
end


# Create update function for the Arrival event

function update!( S::State, R::RandomNGs, E::Arrival )

    # Create an arriving entity and add it to the 1st queue
    S.n_entities += 1    # new entity will enter the system
    new_entity = Entity(S.n_entities, E.time)
    
    # Add the entity to the waiting room
    enqueue!(S.waiting_room, new_entity)
    
    # Generate next arrival and add it to the event list
    future_arrival = Arrival(S.n_events, S.time + R.interarrival_time()) # Create an arrival event
    enqueue!(S.event_list, future_arrival, future_arrival.time) # add arrival event to event list

    # If the machine is available and not broken, the entity goes to service
    if isempty(S.in_service) && S.machine_status == false
        move_to_machine!(S, R)
    end
    return nothing
end

# Create update function for the Breakdown event

function update!(S::State, R::RandomNGs, E::Breakdown)  

    # Change machine status
    S.machine_status = true # machine not working
    repair_time = R.repair_time() # generate repair time
     
     
      if !isempty(S.in_service)
         # Change completion time and interrupted status of entity in service
         entity = dequeue!(S.in_service)
         entity.completion_time = entity.completion_time + repair_time
         entity.interrupted = 1
         enqueue!(S.in_service, entity)
 
         # Change priority of departure event in event list
         peek(S.event_list)[1].time = entity.completion_time
         S.event_list[peek(S.event_list)[1]] = entity.completion_time         
         
      end
     
     
     # Create a repair event
     
     repair_event = Repair(S.n_events, S.time + repair_time)
     enqueue!(S.event_list, repair_event, repair_event.time)
 
     
     
     return nothing
 
 
 end


# Create update function for the Repair event

function update!(S::State, R::RandomNGs, E::Repair)
    
    # Change machine status
    S.machine_status = false # machine is working

    # Create new breakdown event
    interbreakdown_time = R.interbreakdown_time()
    new_breakdown = Breakdown(S.n_events, S.time + interbreakdown_time)
    enqueue!(S.event_list, new_breakdown, S.time + interbreakdown_time)

    if !isempty(S.waiting_room) && isempty(S.in_service)# if someone is waiting, move them to service 
         move_to_machine!(S, R)
    end
    
    return nothing


end

# Create update function for the Departure event

function update!( S::State, R::RandomNGs, E::Departure )

    # Remove entity from service queue
    departing_entity = dequeue!(S.in_service)

    # If someone waiting room is not empty, move entity to the machine
    if !isempty(S.waiting_room) 
        move_to_machine!(S, R)
    end
    
    return departing_entity
end

### Initialise

function initialise( P::Parameters ) 
    R = RandomNGs(P) # create the RNGs
    system = State() # create the initial state structure

    # add an arrival at time 0.0
    t0 = 0.0
    system.n_events += 1 # your system state should keep track of events
    enqueue!( system.event_list, Arrival(0,t0), t0)
    # add a breakdown at time 150.0
    t1 = 150.0
    system.n_events += 1
    enqueue!( system.event_list, Breakdown(system.n_events, t1), t1 ) 
    return  (system, R)
end

### Output functions 

# Function to write the state file
function write_state( event_file::IO, system::State, event::Event)
    
    type_of_event = typeof(event)
    
    
     
    @printf(event_file,
            "%12.3f,%6d,%9s,%4d,%4d,%4d,%4d\n",
            event.time,
            event.id,
            type_of_event,
            length(system.event_list),
            length(system.waiting_room ),
            isempty(system.in_service) ? 0 : 1,
            Int64(system.machine_status) 
            )
end

# Function to write the entity header
function write_entity_header( entity_file::IO, entity )
    T = typeof( entity )
    x = Array{Any,1}(undef, length( fieldnames(typeof(entity)) ) )
    for (i,name) in enumerate(fieldnames(T))
        tmp = getfield(entity,name)
        if isa(tmp, Array)
            x[i] = join( repeat( [name], length(tmp) ), ',' )
        else
            x[i] = name
        end
    end
    println( entity_file, join( x, ',') )
end

# Function to write the entity values
function write_entity( entity_file::IO, entity)
    T = typeof( entity )
    x = Array{Any,1}(undef,length( fieldnames(typeof(entity)) ) )
    for (i,name) in enumerate(fieldnames(T))
        tmp = getfield(entity,name)
        if isa(tmp, Array)
            x[i] = join( tmp, ',' )
        else
            x[i] = tmp
        end
    end
    println( entity_file, join( x, ',') )
end

### Run

# Create function that runs the simulation
function run!(state::State, R::RandomNGs, T::Float64, fid_state::IO, fid_entities::IO; output_level::Integer=2)
    # Main simulation loop that occurs until time "T"
    while state.time < T

        # Obtain the next event and time from the event list
        (event, time) = dequeue_pair!(state.event_list)
        state.time = time  # advance system time to the new arrival
        state.n_events += 1      # increase the event counter
        
        # Write the state before updating the event
        write_state(fid_state, state, event)

        # Generate an update event
        entity = update!(state,R, event)
        
        # Output the entity just if it is completed
        if typeof(event) <: Departure 
            write_entity(fid_entities, entity)        
        end       

    end
    return state
end

run! (generic function with 1 method)

# factory_simulation_run.jl
# include(factory_simulation.jl) - code to include the factory_simulation.jl file if files were separated

# load packages
using CSV, DataFrames

# Create simulation harness
max_seed = 100 # specify max seed 
rerun = false # specify if should rerun simulation if file exists
# this code assumes that the parameters csv will always have the same column names and column position
parameters = CSV.read("parameters_simulation.csv", DataFrame ; comment="#") # read parameters
units = "minutes" # specify units
T = 1000.0 # specify T

for seed = 1:max_seed
    for i = 1:nrow(parameters)
        P = Parameters(seed, parameters[i,1], parameters[i,2], parameters[i,3], parameters[i,4])
        dir = pwd()*"/factory_simulation/"*"/data/"*"/seed"*string(P.seed)*
        "/"*names(parameters)[1]*string(parameters[i,1])*
        "/"*names(parameters)[2]*string(parameters[i,2])*
        "/"*names(parameters)[3]*string(parameters[i,3])*
        "/"*names(parameters)[4]*string(parameters[i,4]) # directory name
    
        if rerun || (!ispath(dir))
            mkpath(dir)                          # this creates the directory 
            file_entities = dir*"/entities.csv"  # the name of the data file (informative) 
            file_state = dir*"/state.csv"        # the name of the data file (informative) 
            fid_entities = open(file_entities, "w") # open the file for writing
            fid_state = open(file_state, "w")       # open the file for writing

            write_metadata( fid_entities ) # Write metadata for entities file
            write_metadata( fid_state ) # Write metadata for state file
            write_parameters( fid_entities, P, T, units) # Write parameters for entities file
            write_parameters( fid_state, P, T, units ) # Write parameters for state file

            # Entity headers
            write_entity_header( fid_entities,  Entity(0, 0.0) )
            println(fid_state,"time,event_id,event_type,length_event_list,length_queue,in_service,machine_status")


            # Run the actual simulation
            (new_system, R) = initialise(P) 
            run!(new_system, R, T, fid_state, fid_entities)
    

            # Close the files
            close( fid_entities )
            close( fid_state )
        end
    end
end