Skip to content
CodeMDD.io | Coding Tutorials

Understanding Environment Diagrams in Python

[

Environment Diagram Python: Building a Discrete-Event Simulation Model for an Aircraft Assembly Line

In this Python tutorial, we will learn how to build a discrete-event simulation model using the SimPy package to optimize the assembly line of an aircraft manufacturer. We will create an environment and allocate resources to simulate the assembly process step by step. Let’s get started!

Step 1: Identify the Components and Slots

First, we need to identify the main components of the aircraft assembly line and the number of slots available for each component. In our case, the components are:

  • Fuselage (1 slot)
  • Wings (2 slots)
  • Empennage (tail end) (2 slots)
  • Power Plant (engine and propeller) (3 slots)
  • Landing Gear (3 slots)

Step 2: Set Up the Discrete-Event Model

To begin, we will set up our discrete-event model using the SimPy package.

import simpy


# Create the SimPy environment
env = simpy.Environment()


# Define the resources (slots) for each component
step_1_fuselage = simpy.Resource(env, capacity=1)
step_2_wings = simpy.Resource(env, capacity=2)
step_3_empennage = simpy.Resource(env, capacity=2)
step_4_power_plant = simpy.Resource(env, capacity=3)
step_5_landing_gear = simpy.Resource(env, capacity=3)


# Define the process durations (in hours)
process_durations = {
    'step_1_fuselage': 20,
    'step_2_wings': 8,
    'step_3_empennage': 10,
    'step_4_power_plant': 8,
    'step_5_landing_gear': 8
}

Here, we have created the SimPy environment env and allocated resources for each component using the simpy.Resource class. We have also defined the process durations for each component.

Step 3: Create the Assembly Simulation Model

Next, we will create the assembly simulation model by defining the processes and their interactions.

def assemble_aircraft(env):
    while True:
        # Step 1: Fuselage Assembly
        with step_1_fuselage.request() as req:
            yield req
            yield env.timeout(process_durations['step_1_fuselage'])


        # Step 2: Wings Assembly
        with step_2_wings.request() as req:
            yield req
            yield env.timeout(process_durations['step_2_wings'])


        # Step 3: Empennage Assembly
        with step_3_empennage.request() as req:
            yield req
            yield env.timeout(process_durations['step_3_empennage'])


        # Step 4: Power Plant Assembly
        with step_4_power_plant.request() as req:
            yield req
            yield env.timeout(process_durations['step_4_power_plant'])


        # Step 5: Landing Gear Assembly
        with step_5_landing_gear.request() as req:
            yield req
            yield env.timeout(process_durations['step_5_landing_gear'])

In this code snippet, we have defined a assemble_aircraft function that represents the assembly process. Using the yield keyword, we request the required resources and wait for them to become available before proceeding to the next step. We also simulate the process durations using env.timeout.

Step 4: Run the Simulation Model and Analyze Results

Finally, we will run the simulation model and analyze the results to optimize the assembly line.

# Run the simulation model
env.process(assemble_aircraft(env))
env.run(until=100)


# Analyze the results
average_waiting_time = {
    'step_1_fuselage': step_1_fuselage.waiting_time / step_1_fuselage.count,
    'step_2_wings': step_2_wings.waiting_time / step_2_wings.count,
    'step_3_empennage': step_3_empennage.waiting_time / step_3_empennage.count,
    'step_4_power_plant': step_4_power_plant.waiting_time / step_4_power_plant.count,
    'step_5_landing_gear': step_5_landing_gear.waiting_time / step_5_landing_gear.count
}


print("Average Waiting Time:")
for step, time in average_waiting_time.items():
    print(f"{step}: {time} hours")

Here, we run the simulation model for a specified duration (until=100), representing 100 hours of assembly time. After the simulation, we calculate the average waiting time for each step by dividing the total waiting time by the number of completed processes. We then print the results to analyze the efficiency of the assembly line.

Conclusion

In this Python tutorial, we have learned how to build a discrete-event simulation model for an aircraft assembly line using the SimPy package. By creating an environment, allocating resources, and defining processes, we were able to simulate the assembly process and analyze the average waiting time for each step. This information can help us optimize the assembly line and improve overall efficiency.