General Description

This model represents a Pizza by the slice restaurant. The general process flow is as follows:
1. Group of customers enter the restaurant
2. Individual customer places an order
3. Customer pays for order
4. Employee places slices in the oven to reheat
5. Customer waits for Pizza to come out of the oven
6. Once reheating is complete the customer waits for the rest of the group (or joins waiting group)
7. Group sits down at table (or waits for an available table)
8. Group eats pizza
9. Throws away trash at the trash can
10. Leave restaurant
*When the Trash Cans have 15 or more Dirty Trays, an employee will collect them and bring them back
to the counter.
Detailed Description
Creating Unique Individuals in Groups
Groups enter the restaurant, each group consists of 1 to 4 customers, and each customer will order 1 to
3 pieces of pizza. Upon entering the restaurant (Before Exiting the Source) we assign
CustomerEntity.GroupSize, CustomerEntity.GroupNumber, CustomerEntity.EatingTime, and
CustomerEntity.Picture. Then, in the Output@Source Node we create a process that creates the rest of
the group via a Create step set to Create Copies. We then re-assign a Picture so they are not the same
throughout the group. This process allows the group to have the same values for the GroupSize,
GroupNumber, and EatingTime which all come into play later in the model. Then, at various points in
the model we assign State values for the number of pieces of pizza and if the customer is considered a
parent. By Creating Copies before assigning these States, we allow some parts of the entities to be the
same, and others to differ.

Creating the Pickup Counter Object
After the Pizza has been taken out of the oven, the pieces go onto a Tray according to the State
TrayEntity.OrderSize that is based off the state CustomerEntity.Ordersize (which is assigned when the
customer enters the Path leading to the Cash Register). Then the customer carries the Tray (that is
carrying the Pizza) to the Table. This can be done using 2 Combiner Objects, or in this model we made
one simple object that combines all three Entities.
There are three Entities that are going to enter this object with two separate Batch Logic Elements that
are to be used to join the Entities together - first the Pizza gets batched to the Tray, then the Tray gets
batched to the Customer. The PickUpCounter Object uses Station Elements to do the batching, each
Station is designed to do a portion of the batching.
There are 3 Input Nodes: one for Tray, Pizza, and Customer. Each one of these nodes corresponds to an
InputBuffer where the object waits for the corresponding Parent/Member for its batch logic. After the
Tray and Pizza are combined, the pair is transferred to an intermediate station where it attempts to
Batch the Pizza/Tray as a Member with the Customer. After everything is batched together, the
Customer is transferred to the OrderFulfilled node.

Creating the Trash Can Object
The Trash Can is Similar to the Counter except it was created using Standard Library Objects instead of
processes. The trash can consists of 2 separators, the first one separates the customer from the Tray
and Pizza, and the second separates the tray and pizza with the pizza going into a Sink to destroy it.
Then, we defined an external view with one input node and 2 output nodes: one for the customer that
leads to the Exit, and one for the tray which (in the model) is set to RideOnTransporter = True so that
the worker can come pick up the waiting trays.

Creating the Table Objects
After the group is together (leaves the WaitForGroup Combiner), the group is routed to an available
table. After routing to the table, the group is Unbatched so that they can each sit in their own seat at
the table. One difficulty is that if the group is smaller than 4 members, there is still remaining capacity
at the table and some groups could be routed to the table even though it is technically occupied. This
requires some add-on processes to a standard Server Object. To avoid having to create add-on
processes at each table, we created a new table object.
This object consists of two stations, SplitStation and EatingStation. When the SplitStation is entered, we
Unbatch the group and transfer the Parents and Members to the EatingStation. After the transfer we
assigned the SplitStation.CurrentCapacity to 0 this means that the table is no longer considered
available and no customers can be routed to this table, even if there is available capacity.
Then, after Delaying for EatingTime, we assign the Capacity of the SplitStation back to its original value,
signifying that the table is available for new customers.