Ich habe kürzlich ein Beispiel für eine Python-Simulationsmodellierung mit SimPy in Python geteilt. Mit SimPy, einer in Python verfügbaren Bibliothek zur Simulation diskreter Ereignisse, habe ich einen Parkplatz mit einer definierten Anzahl von Stellplätzen und einem definierten Autoankunftsprozess modelliert. In diesem Folge-Tutorial zur Visualisierung von SimPy- Simulationsmodellen zeige ich, wie anhand desselben Basisbeispiels Daten zur Parkplatznutzung gesammelt und visualisiert werden können . In kommenden Artikeln werde ich außerdem zeigen, wie der Parkplatz selbst mit Python und SimPy animiert werden kann.

Warum SimPy für Betriebs- und Logistikmanager relevant ist

SimPy, die Open-Source-Bibliothek für diskrete Ereignissimulationen für Python, bietet ein wertvolles Werkzeug für Supply-Chain-Manager. Es geht nicht um isolierte Funktionen, sondern vielmehr darum, wie SimPy diese Fachleute in die Lage versetzt, die Komplexität des Lieferkettenmanagements zu bewältigen.

Einer der herausragenden Vorteile von SimPy ist seine Fähigkeit, realistische Modelle von Lieferkettenabläufen zu erstellen. Diese Modelle ähneln stark den tatsächlichen Prozessen innerhalb einer Lieferkette und erleichtern es Managern, ihre Abläufe zu analysieren und zu verstehen. In einem Bereich, in dem die realen Abläufe unglaublich komplex sein können, ist ein Simulationstool, das diese Komplexitäten genau widerspiegelt, unverzichtbar.

Was SimPy noch attraktiver macht, ist seine Flexibilität. Es handelt sich um eine universelle Simulationsbibliothek, was bedeutet, dass Supply-Chain-Manager sie anpassen können, um verschiedene Aspekte ihrer Abläufe zu modellieren. Ob es um Bestandsverwaltung, Auftragsabwicklung, Bedarfsprognose, Transport oder ein anderes kritisches Element der Lieferkette geht, SimPy kann auf spezifische Herausforderungen zugeschnitten werden.

Die Stärke von SimPy liegt auch in seiner Fähigkeit, „Was-wäre-wenn“-Analysen zu ermöglichen. Supply-Chain-Manager können mit SimPy verschiedene Szenarien und Strategien testen. Sie können die Auswirkungen von Änderungen in ihren Abläufen untersuchen und so fundierte Entscheidungen zur Optimierung von Lieferkettenprozessen treffen. Diese Fähigkeit, verschiedene Szenarien zu modellieren und Ergebnisse vorherzusagen, ist für die strategische Planung von unschätzbarem Wert.

In einer Welt, in der Effizienz an erster Stelle steht, hilft SimPy bei der Leistungsoptimierung. Supply-Chain-Manager können ihre Prozesse simulieren, Engpässe und Ineffizienzen identifizieren und an Strategien zur Verbesserung der Gesamtleistung arbeiten. Diese Optimierung kann zu geringeren Kosten und einem verbesserten Kundenservice führen.

Die Widerstandsfähigkeit der Lieferkette ist von entscheidender Bedeutung und SimPy ist ein wertvolles Tool für das Risikomanagement. Durch die Modellierung verschiedener Risikoszenarien können Manager die Schwachstellen in ihren Lieferketten bewerten und Notfallpläne entwickeln, um potenzielle Störungen abzumildern. Dies ist in der heutigen globalisierten und oft unvorhersehbaren Lieferkettenlandschaft von entscheidender Bedeutung.

Die Ressourcenzuteilung ist ein weiterer Bereich, in dem sich SimPy bewährt. Es kann simulieren, wie Ressourcen wie Arbeitskräfte, Maschinen und Lagerraum in verschiedenen Szenarien zugewiesen werden. Diese Erkenntnisse helfen Managern, fundierte Entscheidungen über die Ressourcenplanung zu treffen und sicherzustellen, dass Ressourcen effizient und effektiv genutzt werden.

Kostenreduzierung ist ein wesentlicher Vorteil der Verwendung von SimPy. Durch die Identifizierung von Ineffizienzen und die Optimierung von Prozessen können Manager möglicherweise die Kosten im Zusammenhang mit Lagerbeständen, Transport und anderen betrieblichen Aspekten senken. Diese Kostensenkung wirkt sich direkt auf das Endergebnis eines Unternehmens aus.

Modellergänzungen zur Visualisierung des SimPy-Parkplatzmodells

In meinem vorherigen SimPy -Beispiel für ein Parkplatzmodell habe ich bereits den Code des Parkplatz- Basismodells verwendet. Das Codierungsbeispiel finden Sie hier: SimPy-Parkplatzsimulationsmodellierungsbeispiel

Im Basismodell gab es keine Visualisierung. Die Ankünfte und Abfahrten der Autos auf und vom Parkplatz wurden einfach in die Konsole gedruckt. Jetzt werden wir eine Visualisierung der SimPy-Simulationsergebnisse implementieren.

Um Simulationsergebnisse visualisieren zu können, müssen wir relevante Simulationsdaten sammeln und relevante Werte während der gesamten Simulation überwachen. Nach dem Ausführen der Simulation werden die gesammelten Daten mit matplotlib .pyplot visualisiert .

Es gibt mehrere Möglichkeiten, Werte in einem SimPy- Simulationsmodell zu überwachen , aber der einfachste Weg (für SimPy-Anfänger), mit der Überwachung der Anzahl belegter und verfügbarer Parkplätze zu beginnen, ist die Implementierung eines benutzerdefinierten SimPy-Überwachungsprozesses:

def monitor_parkingspot(self) -> None:

 
        while self.env.now <= self.simdata.duration:

            self.simdata.data_timeseries[self.env.now, 0] = self.env.now
            self.simdata.data_timeseries[self.env.now, 1] = self.spots_occupied
            self.simdata.data_timeseries[self.env.now, 2] = self.spots_available

            yield self.env.timeout(1)

Ich habe der ParkingLot-Klasse eine Methode zum Implementieren eines benutzerdefinierten Überwachungsprozesses hinzugefügt. Dieser Prozess überprüft die Simulationszeit, die Anzahl der verfügbaren Plätze und die Anzahl der verfügbaren Plätze und schreibt diese Werte in ein Numpy- Ndarray . Aus dem obigen Beispiel können Sie ersehen, dass die ParkingLot-Klasse einige zusätzliche Attribute und Variablen hat: .data_timeseries (: numpy .ndarray), .spots_occupied (: int) und .spots_available (: int). So sehen der Header und der Konstruktor der Klasse jetzt aus:

class ParkingLot:

    env             :simpy.Environment
    capacity        :int
    spots           :simpy.resources.container.Container
    spots_occupied  :int
    spots_available :int
    simdata         :Simdata

    def __init__(self, 
        env      :simpy.Environment, 
        capacity :int,
        duration :int
        ):
        
        """ constructor """
        
        self.env = env
        self.capacity = capacity
        self.spots = simpy.resources.container.Container(env, capacity, init=capacity)
        self.spots_occupied = 0
        self.spots_available = capacity
        self.simdata = Simdata(duration= duration)
        self.simdata.data_timeseries = np.zeros([duration+1, 3], dtype = int)

Für das .simdata-Attribut habe ich eine kleine Klasse geschrieben, Simdata. Ich werde in zukünftigen Tutorials weitere Methoden und Attribute in diese Klasse schreiben, daher wollte ich sie an dieser Stelle vorstellen.

class Simdata:

    duration         :int
    data_timeseries  :np.ndarray

    def __init__(self, 
        duration :int,
        ):
    
        """ constructor """

        self.duration = duration
        self.data_timeseries = np.zeros(duration+1, dtype = float)

Die Anzahl der belegten und verfügbaren Plätze, jetzt Variablen der Klasse „ParkingLot“, werden während des gesamten Fahrzeugankunftsprozesses aktualisiert:

def car_arrival(self,
        car_id          :int, 
        dwelltime_min   :float,
        dwelltime_max   :float
        )               -> None:
        """ 
    
        implement simpy process; 
        models car arrivals in the parking lot, occupying a slot for a randomly distributed duration
    
        """
    
        #print(f"Car {car_id} arrives at {self.env.now}")
    
        yield self.spots.get(1)

        self.spots_occupied += 1
        self.spots_available -= 1
        
        #print(f"Car {car_id} parks at {self.env.now}")
        
        yield self.env.timeout(random.uniform(dwelltime_min, dwelltime_max))
        
        #print(f"Car {car_id} leaves at {self.env.now}")
        
        self.spots_occupied -= 1
        self.spots_available += 1

        yield self.spots.put(1)

Dies erleichtert die Ergebniserfassung während der Simulation. Ich kann jetzt Ergebnisse grafisch darstellen, nachdem der Simulationslauf abgeschlossen ist.

Visualisierung belegter und verfügbarer Slots mithilfe der von SimPy generierten Ergebnisse

Der letzte Schritt ist einfach: Ich verwende matplotlib .pyplot, um eine Linienlinie zu erstellen, die die Anzahl der belegten und verfügbaren Parkplätze auf dem Parkplatz während der Simulationszeit anzeigt.

env.process(parking_lot.monitor_parkingspot())

# run the model
env.run()

# plot simulation results
plt.plot(parking_lot.simdata.data_timeseries[:,1], linestyle = 'dotted', color = "red", label = "occupied")
plt.plot(parking_lot.simdata.data_timeseries[:,2], linestyle = 'dotted', color = "green", label = "available")
plt.legend()
plt.xlabel("sim time")
plt.ylabel("# of spots")
plt.title("parking lot utilization over time")
plt.show()

Sie können sehen, dass ich beim Einrichten des Simulationsmodells vor seiner Ausführung einen weiteren SimPy-Prozess hinzugefügt habe. Dies ist der Überwachungsprozess. Es sammelt Simulationsergebnisse bei jedem Simulationsinkrement und speichert diese Werte in einem numpy ndarray .

So sehen die Ergebnisse aus.

Der Parkplatz ist in diesem Szenario nicht ausreichend genutzt. Für dieses spezielle Autoankunftsszenario hätten 2 Parkplätze ausgereicht.

Abschließende Bemerkungen und zugehöriger Inhalt

In diesem Tutorial habe ich gezeigt, wie Sie relevante SimPy-Modellwerte während der gesamten Simulationszeit überwachen und wie Sie die Visualisierung von SimPy-Simulationsergebnissen mithilfe von matplotlib .pyplot in Python implementieren können.

Hier sind einige verwandte Artikel, die Sie auch interessieren könnten:

• Link : Parkplatzsimulator mit Simmer in R
• Link : SimPy-Simulation für Binnenschifftransport
• Link : Jobshop SimPy Python-Simulation
• Link : LinnartSF/DesViz

Linnart Felkl

Wirtschaftsingenieur mit Interesse an Optimierung, Simulation und mathematischer Modellierung in R, SQL, VBA und Python