grocery checkout simulation system css n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Grocery Checkout Simulation System (CSS) PowerPoint Presentation
Download Presentation
Grocery Checkout Simulation System (CSS)

Loading in 2 Seconds...

play fullscreen
1 / 15

Grocery Checkout Simulation System (CSS) - PowerPoint PPT Presentation


  • 131 Views
  • Uploaded on

Grocery Checkout Simulation System (CSS). Aisle Width. 9 . Aisle n. 2 . 1 . 0 . Sales Register. Grocery Store Simulation. Aisle 2. Aisle 1. Starting Point. Aisle Delta. Exit. Shopper & Cart. Bagger & Shopper Exit. Cart Pool. Checkout Queue. Bagging Bin. Conveyor. bagger.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Grocery Checkout Simulation System (CSS)' - trula


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
grocery store simulation

Aisle Width

9

Aisle n

2

1

0

Sales

Register

Grocery Store Simulation

Aisle 2

Aisle 1

Starting

Point

Aisle Delta

Exit

Shopper & Cart

Bagger

& Shopper

Exit

Cart Pool

Checkout

Queue

Bagging

Bin

Conveyor

bagger

clerk

Entry

Shopper

Enters

Bagger Returns

Cart

Checkout

Subsystem

GSS Architecture

checkout station model
Checkout Station Model

9:When the payment transaction has been completed and all bagshave been loaded in thecart, the shopper leavesthe store with the baggedgroceries.

6: The shopper pays for the groceriesand is given a sales receipt.

2: Shopper places plasticdivider on conveyor afterlast grocery item.

5: When all items have been processed by the clerk, the shopperis presented with the total amountof the purchase.

1: Shopper unloads groceryitems, if there is room on conveyor.

Cart

Cart

Shopper

Scales

&

Scanner

Bagging

Bin

Conveyor

Bagger

3: Conveyor has a fixedcapacity in numbers of items and transports themat a constant rate to theclerk’s station.

Clerk

Sales

Terminal

7: When the cart has been unloaded, the shopper gives the cart to the bagger to be filled with bags of groceries.

4:Clerk removes grocery itemsfrom conveyor and enterstheir identity and price intothe sales system. Some itemsare identified and priced bybar codes. Other items mustby manually identified and weighed.

8:The bagger loads grocerybags with items that havebeen priced by the clerk.Bags are held in the bin until the cart becomes available from the shopper.

GSS Architecture

conveyor model
Conveyor Model

slot N

slot 1

Shopper

Clerk

N = Conveyor capacity in Slots.

RULES:

(1) A slot is the space that can be occupied by a single item.

(2) The shopper always deposits the next item at slot 1, when it is empty.(3) The clerk always removes an item from slot N, when it is full.

(4) If slot N is empty and at least one other slot is filled, the conveyor rotates one slot to the right. The amount of time necessary for the conveyor to rotate one slot position is a model parameter and is specified as a multiple of the simulation time granule.

GSS Architecture

state transition models

Start

Stop

Activity

Stop

State Transition Models

[C] Event/Action

[C] Event/Action

  • [C]an [optional] boolean precondition that must be true before the Event can trigger a transition; no precondition implies the transition will occur unconditionally whenever the Event occurs in the system.
  • Event:a signal or messagereceived that triggers a change in state.
  • Action:computation performed and/or message(s) sent in response to an event.
  • Activity: a state of processing that will continue until the next event; an activity could be a state of idleness.

GSS Architecture

shopper model

Start

Shopper Model

Unloading

DividerSent

[1] /DepositItem

[~1] ItemAccepted/DepositItem

Messages Sent

DepositItem => Conveyor

ReceiveCart => Bagger

AcceptCash => Clerk

AcceptCredit => Clerk

[1] ItemAccepted

/DepositItem

ItemAccepted/ReceiveCart

WaitACK

Messages Received

ItemAccepted <= Conveyor

CartAccepted <= Bagger

AcceptTotal <= Clerk

AcceptChange <= Clerk

AcceptReceipt <= Clerk

AcceptCart <= Bagger

Transition Conditions:

[1] More items in Cart

[2] Wallet >= Sales Total

AcceptTotal/Save Total

CartAccepted

CartACK

PayACK

[2]AcceptTotal/AcceptCash

[2]CartAccepted

/AcceptCash

[~2]AcceptTotal

/AcceptCredit

WaitChange

[~2]CartAccepted

/AcceptCredit

Done

AcceptCart

AcceptChange

WaitCart

WaitReceipt

AcceptReceipt

GSS Architecture

clerk model

Start

Clerk Model

Ring-upItems

DividerReceived

[1] /RequestItem

[~1] ReceiveItem/AcceptTotal

/LastItemInBin

[1] ReceiveItem

/RequestItem

AcceptCredit/(update receipt)

[2]AcceptCash/(update receipt)

AcceptChange

Produce

Receipt

Make

Change

Transition Conditions:

[1] Grocery item received

[2] Cash Received > Sales Total

/CartRelease

/AcceptReceipt

Messages Sent

RequestItem => Conveyor

LastItemInBin => Bagger

CartRelease => Bagger

AcceptTotal => Shopper

AcceptChange => Shopper

AcceptReceipt => Shopper

Messages Received

ReceiveItem <= Conveyor

AcceptCash <= Shopper

AcceptCredit <= Shopper

Done

GSS Architecture

bagger model

Start

[2]

Bagger Model

CheckBin/CheckBin

/CheckBin

(open bag)

Bagging

Items

W/o Cart

BaggingItems

With Cart

AcceptCart

Transition Conditions:

[1] More items in Bin

[2] No Items, but More Bags

LastItemInBin/CheckBin

CheckBin/CheckBin

Last Itemwith Cart

[1] CheckBin/CheckBin

Messages Sent

CheckBin => Bagger

AcceptCart => Shopper

[1] CheckBin

/ReleaseCart

[~1] CheckBin

[1] CheckBin/CheckBin

Messages Received

CheckBin <= Bagger

LastItemInBin <= Clerk

ReleaseCart <= Clerk

Bagging

Items with

Release

Fill Cart

W/o Release

[2]

[2] ReleaseCart

[~2]

[~1] CheckBin

Fill CartwithRelease

WaitforRelease

[~2] / AcceptCart

ReleaseCart

/AcceptCart

Done

GSS Architecture

simulation requirements
Simulation Requirements
  • The Checkout Station Simulation (CSS) shall simulate the behavior of the following active agents in a realistic manner:
    • Shopper
    • Checkout clerk
    • Checkout bagger
    • Checkout conveyor

The fidelity and realism of the models defining these agents shall be determined by the granularity of simulation time, the set of events that characterize their interaction, and by input parameters that control the response of each agent engaged in given interaction event. (See later modeling requirements.) The interaction events modeled shall be sufficient to realistically support the interaction scenarios and activities (1 – 9) described on the slide entitled: “Checkout Station Model.”

  • The CSS shall operate in a faster-than-realtime mode, that is, it shall compute and handle events in simulation time independent of real time.
  • The CSS shall provide the following input capabilities:
    • An ascii file for specifying the grocery items in the shopper’s cart at runtime.
    • An ascii file for specifying model parameters for each active agent in the simulation at runtime.

GSS Architecture

simulation requirements1
Simulation Requirements
  • The CSS shall provide the following output capabilities:
    • An ASCII simulation log file shall capture the following system output:
      • Runtime date and time
      • A display of the intial state of the following objects after all input operations have been completed: cart, shopper, clerk, bagger, conveyor.
      • The simulation time and description of each simulated event ordered by simulation time. Events that occur simultaneously in simulation time shall be ordered by the cause-effect relation whenever it applies.
      • A display of the final state of the following objects after similation is complete, or whenever these objects are destroyed, whichever occurs first in real time: shopping receipt, cart, each bag in the cart, the shopper.
    • Messages to the user terminal:
      • “INITIALIZATION COMPLETE”
      • “SIMULATION ENDS”
    • Error messages shall be written to the standard system output device.

GSS Architecture

simulation requirements2
Simulation Requirements
  • Modeling Requirements
    • Simulation time granularity = 1 second (all event times must be integers)
    • Shopper:
      • Unload time per item ( simulation time)
      • Unload time for divider ( simulation time)
      • Amount of cash (units of cents )
      • Payment delay for cash ( simulation time )
      • Payment delay for credit ( simulation time )

NOTE: if cash is insufficient to pay for groceries, and the pay by cash option is exercised, then pay by credit must override the payment option.

NOTE: assume that pay by-credit always succeeds when used – insufficient funds will not be modeled for credit payment.

NOTE: Parameter #6 applies when shopper and bagger interact to exchange cart possession.

    • Checkout Clerk:
      • Ring-up delay for bar coded items ( simulation time)
      • Processing delay for divider ( simulation time )
      • Ring-up delay for weighed items (simulation time )
      • Payment delay for change ( simulation time )
      • Payment delay for credit (simulation time)
      • Processing delay for receipt (simulation time)

NOTE: assume all other delays are zero (0). For example, parameters #1 and #2 include time to drop item in bagging bin.

GSS Architecture

simulation requirements3
Simulation Requirements
  • Model Requirements (continued)
    • Checkout Conveyor:
      • Transport rate ( simulation time per slot )
      • Maximum capacity ( number of slots )
    • Checkout Bagger:
      • Open new bag delay ( simulation time )
      • Item-to-bag delay ( simulation time )
      • Bag-to-cart delay ( simulation time )
      • Bin polling delay ( simulation time )
    • Grocery Bags:
      • Maximum capacity ( number of items )
    • Grocery Cart:
      • Maximum capacity ( number of items )
      • Maximum capacity ( number of bags )
    • Grocery Items:

There are two kinds of items: bar-coded and weighed. All grocery items have a name that uniquely distinguishes them from other items. The price of weighed items is computed from the weight of the item in pounds and the price per pound given in cents.

GSS Architecture

simulation requirements4
Simulation Requirements

Assumptions and Constraints

  • The software design may assume the existence of an infinite supply of empty grocery bags, and cash when making change.
  • Simulation ends when the shopper re-acquires the grocery cart with bagged groceries; this shall be the last event of the simulation.

GSS Architecture

css models
CSS Models

See Notes

This class represents the Simulated World. It implements the CSS simulation interfaceand contains methods for creating and initializing the CSS object and running it. It alsocontains methods for post simulation review and analysis.

CSS

Shopper

Clerk

Conveyor

Bagger

This layer of the design contains all and only the classes that define the behavior of active agents in thesimulated world. In the CSS, this layer contains classes for the Shopper, the Clerk, the Conveyor, and theBagger. All agent classes must communicate by sending messages to one another, that is, by creating andposting an Event that defines the future time at which the interaction event will occur, the identity of therecipient agent, and a Message object that identifies the specific event and provides the necessary data to service the event. Each of these classes must be derived subclasses of Agent.

Cart

Ckout

Receipt

Bag

Bin

Money

This layer contains all the passive classes of the simulated world. Active agents may direct calls on passive objects. Passive objects make direct calls to each other, if necessary. Passive objects may be passed from one active agent to another as part of a Message.

Message

MoneyMsg

CkoutMsg

CartMsg

ReceiptMsg

Players

This layer contains all the derived subclasses of Message. These classes are used to pass data for servicinginteraction events between active agents. Only recipient agent classes know the content or use instancesof these classes. Methods of a recipient agent designed to service interaction events for that agent willoptionally take parameters which are instances of one of these classes.

GSS Architecture

simulation dynamics

E: Event

Emgr:EventMgr

M: Message

Recvr: Agent

Simulation Dynamics

CSS.Run(): continued

If there are Events thathave not been processed,Run() gets the next event from the EventMgr anddispatches it to the Recipient agent.

CSS.Simulate()

(Continued)

CSS

getNext()

(E:Event)

getRecvr()

Recip

Dispatch( Recvr, getMsg(E) )

Repeat until thereare no more Eventsto dispatch. This ends the simulation Run().

getMsg()

M:Message

getId()

The Recipient agentcomputes Messagesto other agents forfuture interactionEvents – these areposted to the EventMgr

Mid

Method[Mid](M)

*Post( Event )

See Notes

GSS Architecture