Activity: A Manufacturing System with Rework

Process View Modeling Activities

Author

Manuel D. Rossetti, PhD P.E.

We build this model together: the instructor types the code, and you type along. Before each run, write down a prediction; then run and check it.

The situation. A small manufacturing system has three machines, each with its own queue. Parts arrive as a Poisson process at 6 per hour (stream 1). Each arriving part chooses a machine at random: machine 1 with probability 0.2, machine 2 with 0.3, and machine 3 with 0.5 (stream 2). Processing time on any machine is lognormal with a mean of 27 minutes and a standard deviation of 11 minutes (stream 3). After processing, a part is inspected, which takes no time; 3% need rework (stream 4). A part needing rework chooses a machine again with the same probabilities and is processed again with the same distribution. A reworked part never needs rework again.

Simulate 20 replications of 60 hours, in minutes, and complete this table, with averages and 95% half-widths to two decimal places:

Performance measure Average Half-width
Time in the system for parts
Probability that a part’s time in the system exceeds 225 minutes
Utilization of machine 1
Utilization of machine 2
Utilization of machine 3
Average number of parts waiting for machine 1
Average number of parts waiting for machine 2
Average number of parts waiting for machine 3

Setup. Get the starter file MfgSystemWithRework.kt from the code/ folder beside this activity, and put it in src/main/kotlin/student/activities. Run its main. It compiles and runs, with no parts yet.

1. Model it first

  1. Identify the entities, their attributes, the resources, and the activities.

  2. Draw the activity diagram.

  3. Write the part’s process as pseudo-code, using the steps a KSL process has: seize, delay, release, and decisions.

2. Predict

  1. Predict each machine’s utilization. Remember that 3% of the parts visit a machine twice. Which machine is the bottleneck?

  2. What will happen to the bottleneck machine’s queue over the 60 hours? Will the averages you report depend on the run length?

3. Code along

  1. TODO 1 and TODO 2. We construct the machines, and this time we create the parts with an EntityGenerator instead of an arrival event. Compare it with the arrival event of the airport activity: what does the generator do for us?

  2. TODO 3. We write a first version of the part’s process, V0: choose a machine number, then seize, delay, and release that machine, and do the same again for a part that needs rework. What tells the generator which process to start?

4. Four versions of one process

The instructor shows three more versions of the part’s process:

  • V1 uses use() in place of seize, delay, and release, inside a loop that repeats while the part fails inspection;
  • V2 chooses the machine itself, not its number, from an REmpiricalList, and uses it, with one more use for rework;
  • V3 combines the two: the random list inside the same loop.

Only one version can be the default process at a time.

  1. What does use() do, and what does it save?

  2. Before running any version, predict which versions give identical results to each other.

  3. Which versions follow the rule that a reworked part never needs rework again?

  4. Make each version the default in turn, run it, and check your predictions.

5. Results

  1. Use V2 to complete the table.

  2. Where is the bottleneck, and why? Do the results agree with your predictions?

  3. Suppose a part needing rework had a different processing-time distribution. How would the model change?