SimPy-pakket: planning van events beheren

Discrete Event Simulation in Python

Dr Diogo Costa

Adjunct Professor, University of Saskatchewan, Canada & CEO of ImpactBLUE-Scientific

Optreden van events beheren

Het optreden van events in realistische problemen kan door verschillende situaties worden beïnvloed.
De meest voorkomende zijn:
- conditionele events
- onderbreking van events
- wachten op processen

Deze situaties kun je modelleren met een SimPy discrete-eventmodel.

Conditionele events

Sommige events hangen af van andere events
Ze worden alleen geactiveerd als aan een voorwaarde is voldaan

Voorbeeld

Klanten komen aan bij een kledingwinkel
```
def customer_arrivals(env, shop)
```
Zoeken naar een specifiek item
```
env.timeout(search_time)
```

Kopen het alleen als het beschikbaar is

if shop.available[item]:

Generator: alle code samenbrengen

def customer_arrivals(env, shop):


    while True:

        yield env.timeout(search_time)


        # Koop item alleen als beschikbaar
        if shop.available[item]:
            env.process(shop_buyer(env, item, 
                    num_items, shop))

Onderbreking van events

Bepaalde events kunnen worden onderbroken door:

Events met hogere prioriteit
Vrijwillige onderbreking (bijv. auto opladen)
Geforceerde onderbreking (bijv. machine valt uit)

Methode

simpy_process_1.interrupt()

Voorbeeld

Machine valt periodiek uit en onderbreekt de productielijn.

def break_machine(env):

  # Laat de machine af en toe uitvallen.
  while True:

    # Tijd tussen storingen
    yield env.timeout(fail_time())


    # Storing: onderbreek proces
    simpy_process_1.interrupt()

Wachten op processen

Sommige processen moeten wachten tot andere klaar zijn
Dit komt vaak door beperkte resources
Voorbeeld: gedeelde resources met capacity=5:
```
simpy.Resource(env, capacity=5)
```
Daardoor moet een proces wachten als alle resources bezet zijn

Voorbeeld: Brandstofvoorraad in een tankstation moet regelmatig worden aangevuld

with gas_station.request() as request:

  # Vraag een van de pompen aan
  yield request


  # Zodra een pomp vrij is: tank brandstof 
  liters_request = 10
  yield fuel_reserve.get(liters_request)

  # Het “echte” tanken kost tijd
  refuel_duration = liters_request 
                      / refuel_speed


  yield env.timeout(refuel_duration)

Events combineren met bitwise-operators

Bitwise-operators

Voeren bitwise-berekeningen uit op integers
Verwachten twee operanden
- Voorbeeld: a & b, a >> b, a ^ b

In SimPy

Genereert een conditie-event
Tussen 2 events

Relevante bitwise-operators voor SimPy

Wacht op beide processen: __and__() of &
Wacht op een van beide processen: __or__() of |

Events combineren met bitwise-operators

Voorbeeld: Bezoeker wacht in de rij tot z’n/haar beurt of tot de film is uitverkocht

with counter.request() as my_turn:


  # Wacht tot beurt of uitverkocht
  result = yield my_turn | counter.sold_out[movie]


  # Als er kaarten zijn
  if my_turn in result:
    theater.num_moviegoers[movie] += 1
    return


  # Als uitverkocht
  if my_turn not in result:
    theater.num_renegers[movie] += 1
    return

Laten we oefenen!

Discrete Event Simulation in Python