Fast Food Operation

Extend has a built-in example model of a hamburger joint. We'll explore this first. You needn't understand every aspect of this model, but try to think about how this expands your repertoire of modeling techniques.

Exploring the Model

• Open Extend 6/Examples/Operations Research/Fast Food Operations.mox.
• It's a hierarchical model. Open the various parts to explore. Note that option+click will open a hierarchical block in a way that shows additional information.
• Notice the use of the Timer block in the "Ordering" h-block. Where does the sensor input come from?
• There is an "unbatch" block in the "Ordering" h-block. Read the documentation on this. Look at where the information is flowing. Can you see what the block is doing?
• In the kitchen, there is a "Resource" block. Read its documentation. Make some educated guesses about how it works.
• Similarly, read about the "Activity, Service" block and the "Activity, Multiple" blocks in the kitchen.
• Switch to the "WaitingArea" block and look at the "Get Attribute" block; it's somewhat mysterious. What is being done with the attribute? Try adding a "Plotter Discrete Event" and plotting the number of customers in the queue after the "Get Attribute" block. Notice that the queue length doesn't increase and decrease by just one customer each time. It increases by as much as 3, which is the maximum number of hamburgers.

  The "Get Attribute" block in the kitchen is doing the same odd thing. Why does this make sense?

• Read about the "Activity, Multiple" block in the kitchen and figure out what that's doing. Read about the checkbox for "simulate multitasking," and think about Winton's CPU model.
• Look at the "Batch" block at the top level. What is this doing?

This is a pretty cool model, and pretty complicated. Some of you may decide to build something this complex for your project, but it's not required. I'm just looking for you to build something interesting and challenging.

Running the Restaurant

When we run the Fast Food Operation model, we get several kinds of data, including the wait time for each customer, the length of the line, and the number of burgers.

What is the time scale of the model?

Data Collection and Analysis

I don't think we'll have time for the following, so just read over this and imagine doing it.

Let's suppose we're only interested in the average wait time.

• Modify the model to compute the mean wait time.
• Set up the model to compute the mean of the mean wait times over several runs, say 30.
• Compute a 95 percent confidence interval on the mean waiting time for customers.

Now, here's some data you could take to your boss!

Suppose, though, that your boss knows some statistics and says, "Gee, I'd really rather have an estimate of the median wait time."

Now what?

1. Run the simulation once.
2. Extract the wait-time data from the plotter, copy it to Excel, and compute the median.
3. Is the median the same as the mean? If so, this might be a symmetrical distribution, in which case you can tell your boss to use the original point estimate.
4. Try this several times. Because this is so tedious, we won't collect a lot of median data.

Think about how you would compute a confidence interval on a median. There are a couple of issues:

• How do you combine a collection of medians into an overall point estimate. Do you take their mean or their median?
• If you take their mean, you could use the same procedure for finding a confidence interval as you do for any other mean.
• If you take their median, you have to use a bootstrap procedure.
• Try this for just one of the median runs, resampling from the median data of one run.

Quick Blocks

• Open the QuickBlocks library.
• Open a new model and select some interesting looking blocks, such as
  • Attribute-based Delay
  • Multiple Select Outputs
  • Select Shortest Queue
  • others

These are all hierarchical blocks, illustrating how things can be packaged into useful building blocks. This also reinforces the Computer Science "big idea" of abstraction.

You're welcome to use any of these blocks.

Assembly-Rework

Open the Examples/Operations Research/Assembly Rework.mox model.

The Assembly-Rework model is an example of a simple two phase manufacturing process: an assembly phase where parts from stock are assembled by a laborer; and a machining phase where the assembled unit goes through a machining process that finishes it. The machined part is then inspected and either shipped or sent back to be reworked by the machines. The purpose of the model is to find bottlenecks in the process.

The particulars of this model are:

• Orders arrive at the rate of about 3 per minute (interarrival time of 20 seconds)
• It takes 3 parts to make each assembly
• Parts are brought by conveyor from the stock room as required; the conveyor moves at 60 feet per minute, has 10 slots for parts, and is 10 feet long. (Units are metric if you choose that under "preferences.")
• There is 1 worker who takes 30 seconds to assemble the parts
• Two machines are available; they take 42 seconds to process each assembly
• 85% of the machined assemblies pass inspection and are shipped; the rest must be re-machined.

Exploring the Model

Explore the model and see if you can determine the role of each block.

• The Buffer block, which is something like a queue
• The Labor block, which is a finite pool of resources. Laborers leave this when they start a task and reenter it when they are done with the task.
• The Stock block, which is similar to the Labor block.
• The Conveyor belt, which does what it says. Not a very generic block!
• The Batch block, which uses the "delay kit" checkbox for the laborer, and the "preferred attibutes" checkbox for the stock parts.
• The Activity Multiple block, which in this model allows 6 parts to be simultaneously assembled in the required 30 seconds.
• The UnBatch block, which sends the worker back to the labor pool and sends the assembly on.
• The two Machine blocks, each of which is a lot like an "Activity, Delay"

Spend some time on the Plotter block. What does it tell us?

• The blue line is the number of finished parts. It is monotonically non-decreasing.
• The red line is L output of the Conveyor belt to the machines. It tells us the number of items in the buffer. "BMachines" is the backlog of items waiting for the machines.
• The green line is the L output of the Assembly Buffer of incoming orders. It tells us the number of items in the buffer. "BOrders" is the backlog of incoming, unfilled orders.

Where is the bottleneck in the system? How should we modify the model to alleviate the bottleneck and improve performance?

One possibility is to add another assembly person. Try that. What other things need to change?

Re-run the model. Now what happens?

Ferarri Agency

Please open Examples/Operations Research/Ferrari Agency.mox.

This attempts to determine how many salespeople to hire in a fancy auto showroom by looking at whether to have one salesperson or two. It also looks at how many customers "renege" (leave without getting service).

This has a new block, the "Queue, Renege" which is useful.

Also look at arrival rates and how the doors are closed.

Call Center

Open this from the "demo" window or from "Examples/Operations Research/call center.mox." This is horrifyingly complex, so don't try to understand everything, just learn what you can.

Click on the "about this model" button to learn more. Some of that info is repeated below:

In this call center, there are four types of call arriving at random intervals, and four types of agents who are able to answer calls. Each agent type is specialized for a particular call type. However, some agents are able to answer calls of a different type.

This model makes a lot of use of "throw" and "catch" blocks, to allow items to go someplace else without using lines or named connectors.

• Open the Call Type 1 hierarchical block. Explore it. Notice the Throw block
• Open the Trash hierarchical block and find the matching catch. In this model, Extend uses the label of the block to specify the catching block.
• Notice the equation for counting the lost calls.
• Open the "Queue call type 1" hierarchical block and explore it. Notice another throw. You can again find the matching catch in the Trash.
• I think you can use cloning to have readouts in the icon for a hierarchical block. This is very cool.
• The number of reneges is saved in a "global array." I don't know much about the details of these, but the idea is that any block can put information into it (by naming an aspect of it) or get information from it. See an example in "Examples / Tips / Modeling / Global Array Example.mox"
• Call times are lognormal: A random variable X is said to have a lognormal distribution if the random variable Y=log(X) has a normal distribution. In other words, if you take sample from a lognormal distribution, the logarithm of the sample numbers should be roughly normal. It is usually defined using a mean and variance, but the mean and variance are of the normal distribution, not the lognormal distribution. See the following model:

  lognormal.mox

• How are call types routed?
• How is the total queue length computed? Click on the big plus sign (a hierarchical block) in the lower right to find out.
• How many agents are there of each type? Where is that reflected in the model?
• Click on the "view results" button. This is pretty fancy, and we won't learn this, but it's pretty cool.

1. This work is licensed under a Creative Commons License
2. 
3. 
4. 
5.