SimPy-Paket: Ereignisplanung steuern

Diskrete-Ereignis-Simulation mit Python

Dr Diogo Costa

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

Ereignisauftreten steuern

Das Auftreten von Ereignissen kann durch verschiedene Situationen beeinflusst werden.
Häufige Fälle:
- bedingte Ereignisse
- Unterbrechung von Ereignissen
- Warten auf Prozesse

Diese Situationen lassen sich in ein SimPy-Ereignismodell übersetzen.

Bedingte Ereignisse

Manche Ereignisse hängen vom Eintreten anderer ab
Sie werden nur ausgelöst, wenn eine Bedingung erfüllt ist

Beispiel

Kund:innen kommen in ein Kleidungsgeschäft
```
def customer_arrivals(env, shop)
```
Suchen nach einem bestimmten Artikel
```
env.timeout(search_time)
```

Kauf nur, wenn verfügbar

if shop.available[item]:

Generator: Code zusammenführen

def customer_arrivals(env, shop):


    while True:

        yield env.timeout(search_time)


        # Artikel nur kaufen, wenn verfügbar
        if shop.available[item]:
            env.process(shop_buyer(env, item, 
                    num_items, shop))

Unterbrechung von Ereignissen

Bestimmte Ereignisse können unterbrochen werden durch:

Ereignisse höherer Priorität
Freiwillige Unterbrechung (z. B. Auto laden)
Erzwungene Unterbrechung (z. B. Maschinenausfall)

Methode

simpy_process_1.interrupt()

Beispiel

Maschine fällt periodisch aus und unterbricht die Produktion.

def break_machine(env):

  # Maschine fällt hin und wieder aus.
  while True:

    # Zeit zwischen Ausfällen
    yield env.timeout(fail_time())


    # Ausfall: Prozess unterbrechen
    simpy_process_1.interrupt()

Auf Prozesse warten

Manche Prozesse müssen auf andere warten
Oft wegen begrenzter Ressourcen
Beispiel: geteilte Ressourcen mit capacity=5:
```
simpy.Resource(env, capacity=5)
```
Dann muss ein Prozess warten, wenn alle Ressourcen belegt sind

Beispiel: Treibstoffvorräte an einer Tankstelle müssen regelmäßig aufgefüllt werden

with gas_station.request() as request:

  # Eine Zapfsäule anfordern
  yield request


  # Sobald frei: tanken
  liters_request = 10
  yield fuel_reserve.get(liters_request)

  # Das eigentliche Tanken dauert
  refuel_duration = liters_request 
                      / refuel_speed


  yield env.timeout(refuel_duration)

Ereignisse mit bitweisen Operatoren verknüpfen

Bitweise Operatoren

Führen bitweise Berechnungen auf Ganzzahlen aus
Erfordern zwei Operanden
- Beispiel: a & b, a >> b, a ^ b

In SimPy

Erzeugt Bedingungsereignis
Zwischen 2 Ereignissen

Relevante bitweise Operatoren für SimPy

Wartet auf beide Prozesse: __and__() oder &
Wartet auf einen der Prozesse: __or__() oder |

Ereignisse mit bitweisen Operatoren verknüpfen

Beispiel: Kinobesucher wartet an der Kasse bis er/sie dran ist oder der Film ausverkauft ist

with counter.request() as my_turn:


  # Warten bis dran oder ausverkauft
  result = yield my_turn | counter.sold_out[movie]


  # Wenn Tickets verfügbar
  if my_turn in result:
    theater.num_moviegoers[movie] += 1
    return


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

Lass uns üben!

Diskrete-Ereignis-Simulation mit Python