Jeg delte for nylig et Python-simuleringsmodelleringseksempel ved hjælp af SimPy i Python. Ved at bruge SimPy, et simuleringsbibliotek for diskret begivenhed, der er tilgængeligt i Python, modellerede jeg en parkeringsplads med et defineret antal slots og en defineret bilankomstproces. I denne opfølgende tutorial om visualisering af SimPy- simuleringsmodeller viser jeg, hvordan data om parkeringspladsudnyttelse kan indsamles og visualiseres ved hjælp af det samme baseline-eksempel . I kommende artikler vil jeg desuden vise, hvordan selve parkeringspladsen kan animeres ved hjælp af Python og SimPy.

Hvorfor SimPy er relevant for drifts- og logistikchefer

SimPy, open source-simuleringsbiblioteket for diskrete begivenheder til Python, tilbyder et værdifuldt værktøj til forsyningskædeledere. Det handler ikke om isolerede funktioner, men snarere om, hvordan SimPy giver disse fagfolk mulighed for at tackle kompleksiteten af ​​supply chain management.

En af SimPys iøjnefaldende fordele er dens evne til at skabe realistiske modeller for forsyningskædedrift. Disse modeller ligner meget de faktiske processer i en forsyningskæde, hvilket gør det lettere for ledere at analysere og forstå deres operationer. I et felt, hvor operationerne i den virkelige verden kan være utroligt indviklede, er det uundværligt at have et simuleringsværktøj, der nøjagtigt afspejler disse kompleksiteter.

Det, der gør SimPy endnu mere tiltalende, er dens fleksibilitet. Det er et simulationsbibliotek til generelle formål, hvilket betyder, at forsyningskædeledere kan tilpasse det til at modellere forskellige aspekter af deres operationer. Uanset om det er lagerstyring, ordrebehandling, efterspørgselsprognose, transport eller ethvert andet kritisk element i forsyningskæden, kan SimPy skræddersyes til at løse specifikke udfordringer.

SimPys styrke ligger også i dens evne til at facilitere “hvad hvis”-analyse. Supply chain managers kan bruge SimPy til at teste forskellige scenarier og strategier. De kan udforske virkningen af ​​ændringer i deres drift og hjælpe dem med at træffe informerede beslutninger om optimering af forsyningskædeprocesser. Denne evne til at modellere forskellige scenarier og forudsige resultater er uvurderlig for strategisk planlægning.

I en verden, hvor effektivitet er altafgørende, hjælper SimPy med ydeevneoptimering. Supply chain managers kan simulere deres processer, identificere flaskehalse og ineffektivitet og arbejde på strategier for at forbedre den samlede præstation. Denne optimering kan føre til reducerede omkostninger og forbedret kundeservice.

Resiliens i forsyningskæden er afgørende, og SimPy er et værdifuldt værktøj til risikostyring. Ved at modellere forskellige risikoscenarier kan ledere vurdere sårbarhederne i deres forsyningskæder og udvikle beredskabsplaner for at afbøde potentielle forstyrrelser. Dette er essentielt i nutidens globaliserede og ofte uforudsigelige forsyningskædelandskab.

Ressourceallokering er et andet område, hvor SimPy beviser sit værd. Det kan simulere, hvordan ressourcer såsom arbejdskraft, maskiner og lagerplads allokeres i forskellige scenarier. Denne indsigt hjælper ledere med at træffe informerede beslutninger om ressourceplanlægning, hvilket sikrer, at ressourcer bruges effektivt og effektivt.

Omkostningsreduktion er en væsentlig fordel ved at bruge SimPy. Ved at identificere ineffektivitet og optimere processer kan ledere potentielt reducere omkostninger forbundet med lager, transport og andre driftsaspekter. Denne omkostningsreduktion påvirker en virksomheds bundlinje direkte.

Modeltilføjelser til visualisering af SimPy parkeringspladsmodel

I mit tidligere SimPy- parkeringsmodeleksempel har jeg allerede koden til parkeringspladsens basismodel. Du kan finde kodningseksemplet her: SimPy parkeringspladssimuleringsmodelleringseksempel

I basislinjemodellen var der ingen visualisering. Bilens ankomster og afgange på og fra parkeringspladsen blev simpelthen printet ind i konsollen. Nu vil vi implementere en visualisering af SimPy-simuleringsresultater.

For at kunne visualisere simuleringsresultater skal vi indsamle relevante simuleringsdata, og vi skal overvåge relevante værdier gennem simuleringen. Efter at have kørt simuleringen visualiseres de indsamlede data med matplotlib .pyplot.

Der er flere måder at overvåge værdier på i en SimPy- simuleringsmodel , men den nemmeste måde (for SimPy-begyndere) til at komme i gang med at overvåge mængden af ​​besatte og tilgængelige parkeringspladser er at implementere en tilpasset SimPy-overvågningsproces:

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)

Jeg tilføjede en metode til ParkingLot-klassen til implementering af en tilpasset overvågningsproces. Denne proces kontrollerer simuleringstiden, antallet af tilgængelige spots og antallet af tilgængelige spots og skriver disse værdier ind i et numpy ndarray . Du kan se fra ovenstående eksempel, at ParkingLot-klassen har nogle yderligere attributter og variabler: .data_timeseries (: numpy .ndarray), .spots_occupied (: int) og .spots_available (: int). Sådan ser klassens header og konstruktør ud nu:

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)

Til .simdata-attributten skrev jeg en lille lille klasse, Simdata. Jeg vil skrive flere metoder og attributter ind i denne klasse i fremtidige tutorials, så jeg ville introducere det på dette tidspunkt.

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)

Antallet af besatte og ledige pladser, nu variabler for ParkingLot-klassen, opdateres under hele ankomstprocessen til bilen:

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)

Dette letter indsamling af resultater under simulering. Jeg kan nu plotte resultater efter simuleringskørslen er afsluttet.

Visualisering af besatte og tilgængelige slots ved hjælp af SimPy-genererede resultater

Det sidste trin er enkelt: Jeg bruger matplotlib .pyplot til at oprette en linjeplads, der viser mængden af ​​besatte og tilgængelige parkeringspladser på parkeringspladsen gennem simuleringstiden.

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()

Du kan se, at jeg tilføjede en anden SimPy-proces, da jeg satte simuleringsmodellen op før dens udførelse. Dette er overvågningsprocessen. Den indsamler simuleringsresultater ved hvert simuleringstrin og gemmer disse værdier i et numpy ndarray .

Sådan ser resultaterne ud.

Parkeringspladsen i dette scenarie er underudnyttet. 2 parkeringspladser ville have været nok til dette specifikke bilankomstscenarie.

Afsluttende bemærkninger og relateret indhold

I denne tutorial viste jeg, hvordan du kan overvåge relevante SimPy-modelværdier gennem simuleringstiden, og hvordan du kan implementere visualisering af SimPy-simuleringsresultater ved hjælp af matplotlib .pyplot i Python.

Her er nogle relaterede artikler, som du også kunne være interesseret i:

• Link : Parkeringssimulator med simre i R
• Link : Pramtransport SimPy simulering
• Link : Jobshop SimPy Python-simulering
• Link : LinnartSF/DesViz

Linnart Felkl

Industriingeniør som gerne beskæftiger sig med optimering, simulation og matematisk modellering i R, SQL, VBA og Python