Storage

Storage in graphical editor

Storage at model runtime in 3D animation

Storage is a space markup element that you can use to graphically define a warehouse space where agents (material items) are stored on racks.

One storage element can contain multiple racks. At the moment we support the following rack placement:

• Stand-alone — all racks face in the same direction and each aisle can provide access to a single rack.

  

• Back-to-back — the racks are organized in pairs back-to-back. This way each aisle provides access to two racks.

  

Each rack is composed of cells. A single cell can host a single agent (material item). Inside the rack, cells are organized in specific groups that are used to define how the rack is filled. Let’s take a closer look:

	Slot — a single horizontal row of cells that defines the depth of a rack. By default, each rack in the Storage has one cell per slot.
	Bay — multiple slots stacked vertically on top of each other. The width of a rack depends on the number of bays. By default, each rack in the Storage has five bays.
	Shelf — multiple slots arranged horizontally at the same height. The height of a rack depends on the number of shelves. By default, each rack in the Storage has one shelf.

Currently, the Storage element supports the racks of the following types:

• Selective — The rack is filled bay by bay. In each bay, the slot on the bottom is filled completely starting with the deepest cell position, then the slot above it is filled in the same manner. The process repeats until the bay is filled from the bottom shelf all the way to the top shelf. This type supports LIFO flow: the last stored item will be the first item to retrieve.
• Drive-in — The deepest cell positions in all available slots on the bottom are filled first. Then the cells directly above them, and so on, until all cells in the deepest positions are filled in the rack. Next, the process repeats for the cells that are now considered to be in the deepest positions. This rack type supports LIFO flow: the last stored item will be the first item to retrieve.
• FIFO flow — The first agent stored in the slot will be the first agent retrieved from the slot. The agent is placed on the designated “loading” side and then is moved in the direction of the “retrieval” side. This is achieved either by the rack’s construction (for instance, with built-in rollers) or simply gravity, with the shelves angled at the specified degree.
  This storage type can be used to model carton flow racks, pallet flow racks, and gravity racks.
• LIFO flow — The last agent stored in the slot will be the first agent retrieved from the slot.
  In such storages, only one side of the rack allows for storage and retrieval of material items. Upon the arrival of a new agent to be stored on a shelf, agents already present on this shelf are pushed to its back. This is achieved either by the rack’s construction (for instance, with a push-back mechanism) or simply gravity, with the shelves angled at the specified degree.
  This storage type can be used to model carton flow racks, pallet flow racks, and gravity racks.

Storages can serve as obstacles in the way of pedestrians and transporters moving in free space navigation mode.

There are two approaches to creating a rack storage: either based on the dimensions of the storage units (racks and bays) or based on the explicitly defined number of racks and bays.

To draw a rack storage based on dimensions

1. Drag the Storage element from the Space Markup palette into the graphical editor.
2. Specify the dimensions of the storage units according to your needs:
   • Set the Number of racks and the Number of bays to be calculated based on dimensions.
   • Specify the storage’s Rack depth, Aisle width, and Bay width.
   • Set the Number of cells per slot.
   • Define the Number of shelves and Shelf height.
3. After you have configured the dimensions, drag the handle in the bottom right corner of the Storage element and resize it to fit your demands. The number of racks and bays will automatically increase/decrease according to the size of the whole storage.

   

4. In the Appearance section of the properties, you can customize the look of your storage. You can also choose how the agents (material items) inside the storage are animated at runtime by setting the Occupied cells animation property. If you choose the color indication (fast) option, the cells with material items will be simply colored at runtime. Use this option if you model extensive storage areas and need to improve model performance. If you don't have any issues with performance, you can use the agent animation option: this way you will see the actual animation of the material items inside the rack storage.
5. Define the width of the Access zone in the Position and size section of the storage properties. The access zone is the area located in front of the first rack in the storage. All network paths that go through the access zone can be used by transporters or resources to approach the rack.

6. After you have finished drawing the storage, click Create storage network to draw network paths inside the storage aisles if you need those.

   Make sure that you have indeed finished drawing the storage because once you draw the network, it will not adjust automatically to any further changes in the storage dimensions. You would have to delete the network altogether and create one from scratch.

To draw a rack storage based on the number of racks and bays

1. Drag the Storage element from the Space Markup palette into the graphical editor.
2. Specify the Number of racks and the Number of bays according to your needs.
3. Set the Number of cells per slot.
4. Define the Number of shelves and Shelf height.
5. Drag the handle in the bottom right corner of the Storage element and resize it to fit your demands. The dimensions of bays and aisles will automatically change according to the size of the whole storage.

   

6. Adjust the rack depth if necessary.
7. Adjust the aisle width if necessary.
8. In the Appearance section of properties, you can customize the look of your storage. You can also choose how the agents (material items) inside the storage are animated at runtime by setting the Occupied cells animation property. If you choose the color indication (fast) option, the cells with material items will be simply colored at runtime. Use this option if you model extensive storage areas and need to improve model performance. If you don’t have any issues with performance, you can use the agent animation option: this way you will see the actual animation of the material items inside the rack storage.
9. Define the width of the Access zone in the Position and size section of the storage properties. The access zone is the area located in front of the first rack in the storage. All network paths that go through the access zone can be used by transporters or resources to approach the rack.

10. After you have finished drawing the storage, click Create storage network to draw network paths inside the storage aisles if you need those.

    Make sure that you have indeed finished drawing the rack storage because once you draw the network, it will not adjust automatically to any further changes in the storage dimensions. You would have to delete the network altogether and create one from scratch.

The coordinates of every cell in Storage can be described as a set of indices, where each index describes a specific rack, bay, shelf, and the cell's position in the slot. Let's use the getCell() function as an example.

Suppose, we have a Storage element named storage that consists of 4 racks, where each rack has 5 bays, 5 shelves, and 10-cell slots. We want to obtain the deepest cell from the highest shelf in the 3rd bay of the 4th rack. Since indices are calculated from 0, we have to call the storage.getCell(3, 2, 4, 9) function, where:

• 3 — the index of the 4th rack
• 2 — the index of the 3rd bay
• 4 — the index of the highest (the 5th out of 5) shelf
• 9 — the index of the deepest (the 10th out of 10) cell

Inside the warehouses, there may be some empty areas that interrupt the otherwise uniform flow of storage space. You can use specific functions and make whole groups of cells inaccessible for storage to model these areas.

In the API, such cells have the DISABLED state, which renders them unavailable for functions that retrieve the free cells, for example, getFreeCells().

In the FIFO flow and LIFO flow storages, disabled cells cannot be located inside the slot, but only on the aisle-adjacent positions.

There is an aisle in front of each rack in the storage. If you are using resources or transporters to move agents to and from the storage, they will move through aisles to get as close as possible to the cell where they can drop off or pick up the agent. After configuring the storage, you can create a storage network to be used by resources or transporters with path-guided navigation to move inside the storage. The paths of this network will go through the storage aisles.

In FIFO flow storages, there is the «loading» side aisle before the first rack of the storage, wherein the agents (material items) are placed on the rack, and the second is the «retrieval» side located after the last rack of the storage that the transporters or resources use to retrieve the agents (material items).

Besides, every storage has an access zone that is located in front of the first rack of the storage. In the back-to-back storage configuration, there are two access zones: in front of the first rack and in front of the last rack of the storage. Also, in FIFO flow storages, there are two access zones to each rack: one is used to store the material items, and the other one to retrieve them.

All network paths that go through the access zone and aisles can be used by path-guided transporters or resources to approach the rack. You can adjust the width of the access zone as you see fit.

Alternatively, if you are modeling at a higher level of abstraction and want to skip the detailed process of storage and retrieval, the agents (material items) can arrive at the storage on their own.

• In FIFO flow storages, the first agent stored in the slot will be the first agent retrieved from the slot. The item can be retrieved from the designated retrieval side only.
• In LIFO flow storages, the last agent stored in the slot will be the first agent retrieved from the slot. The designated retrieval side is the same as the loading side.
• In storages, the agent can be retrieved only from the cell adjacent to the aisle (on the retrieval side in the case of FIFO flow storages). Upon an attempt to retrieve an agent from other cells, an error occurs.
• At a single point in time, only one agent can interact with an operating (retrieval or loading) side of each individual bay of the storage.
  To handle this, each of these sides has its own internal queue. All agents that interact with the bay for storage or retrieval operations (via the flowchart blocks) are placed within this queue.
• The retrieval operation has a higher priority than the storage operation.
• The agents that are the closest to the retrieval side have the highest priority.
• The agents residing in the blocked cells are ignored during the calculation of the retrieving order.
• The retrieval of an agent may be delayed if some other agent in the storage blocks its movement, and the resource (for example, a transporter) is already on its way to pick up this other agent (thus removing the obstacle).
  If this is the case, a warning appears, and the queue is formed according to the points in time at which each individual agent becomes ready to be retrieved. For agents that require the resource (a transporter) to be retrieved, the point in model time the resource arrives at is taken into account. If the agent does not require a resource, its position in the queue is assigned with the consideration of the time each agent spent in the Retrieve block.

Since the graphical representation of storage is pretty complex, here are some quick scenarios on how you can adjust the storage in design time.

To adjust the aisle width

1. Drag the first square handle on the first rack of the storage to change the width of all aisles.

   

To adjust the rack depth

1. Drag the second square handle on the first rack of the storage to change the depth of all racks.

   

To adjust the access zone

1. Drag the diamond-shaped handle on the access zone border to adjust its width.

   

General

Name — The name of the rack storage. The name is used to identify and access the storage from code and library blocks.

Ignore — If selected, the storage is excluded from the model.

Visible on upper agent — If selected, the storage is also visible on the upper agent where this agent lives.

Lock — If selected, the shape of the storage is locked. Locked shapes do not react to mouse clicks — it is impossible to select them in the graphical editor until you unlock them. This may prove useful when you want to prevent editing this shape while drawing other shapes over it.

Visible — Here you specify whether the shape is visible on animation at model runtime, or not.

Is obstacle — If selected, this rack storage will be considered an obstacle for pedestrians and transporters moving in free space mode.

Rack type — The type of storage that defines how agents are stored inside the rack. The following options are available:

• Selective — The rack is filled bay by bay from the bottom shelf up. This type supports LIFO SKU flow. The seized resource or transporter waits in the aisle while the item is stored.
• Drive-in — The deepest positions in all available bays are filled first from the bottom shelf up. This type supports LIFO SKU flow. The seized transported or resource drives inside the bay to store the item.
• FIFO flow — The first agent stored in the slot will be the first agent retrieved from the slot. This storage has two aisles: one on the loading side, where the agent is placed, and the other — on the retrieval side, from where the agent is retrieved.
  The direction in which the agents are moving on the FIFO rack is shown graphically with arrows.
• LIFO flow — The last agent stored in the slot will be the first agent retrieved from the slot.
  In such storages, only one side of the rack allows for storage and retrieval of material items. Upon the arrival of a new agent to be stored on a shelf, agents already present on this shelf are pushed to its back.

Rack placement — Here you can choose how the racks are positioned inside the storage:

• Back-to-back — racks are organized in pairs and stand back-to-back
• Stand-alone — all racks face in the same direction

Rack placement cannot be modified for FIFO storages. They always use the Stand-alone placement.

Reverse loading direction — [Visible if Rack type: FIFO flow; for other rack types — if Rack placement: Stand-alone] Defines the loading direction inside the storage. If enabled, the placement of the racks is changed visually in the graphical editor and the loading order is reversed accordingly.
The state of this option affects the logical numeration of racks only (horizontal elements that constitute the storage), not bays (vertical elements).
In the FIFO flow rack storages, the current loading direction is shown graphically with arrows.

Selective storage with stand-alone rack placement: Regular and reverse loading

Rack depth — Here you can define the depth of a single rack.

Number of racks is — Here you can select how the number of racks in your storage is defined. It is either:

• defined explicitly — you specify the Number of racks in the corresponding property below
• calculated based on dimensions — you define the dimensions of the rack, aisle, and storage itself, and AnyLogic calculates the number of racks inside the storage accordingly

Aisle width — [Visible if Number of racks is: calculated based on dimensions] Here you can define the width of a single aisle.

Number of racks — [Visible if Number of racks is: defined explicitly] Here you can specify how many racks there are in a single rack storage.

Number of bays is — Here you can select how the number of bays in your storage is defined. It is either:

• calculated based on dimensions — you define the dimensions of the bay width and the dimensions of the storage itself, and AnyLogic calculates the number of bays inside the rack accordingly
• defined explicitly — you specify the Number of bays in the corresponding property below

Bay width — [Visible if Number of bays is: defined explicitly] Here you can define the width of a single bay. The value will be used to calculate the number of bays in the rack.

Number of bays — [Visible if Number of bays is: calculated based on dimensions] Here you can specify how many bays there are in a single rack.

Create storage network — Click this button to draw a network of paths and point nodes running through the aisles of the storage and along the storage perimeter. Path-guided transporters and agents can use these paths to approach the storage.

Rack

Number of shelves — The number of vertical shelves in the rack storage.

Cells per slot — The number of cells in the depth of each slot.

Shelf height — The height of a shelf.

Set speed inside slot — Select this option to specify the speed of the agent’s movement inside the slot. If the option is not selected, the agent moves at its own speed or (for Drive-in storages) with the speed of the seized resource.

Speed inside slot — [Visible if Set speed inside slot is selected] The speed of agent’s movement inside the slot.

Actions

For FIFO and LIFO flow storages:
If you need to track the agent’s movement within the rack, consider using the On agent retrieval action (all agents on a shelf are moved when a terminal agent is retrieved). In LIFO flow storages, the storage of a new agent (On agent storage) also triggers movement.
If you need to track when the agent is placed on a shelf but has not yet reached the designated position, use the Store block actions (for example, On release transporter or On storage start).

On agent storage — Code that will be executed when the agent (material item) is stored in the cell.
In the FIFO flow and LIFO flow storages, this action is triggered upon the agent’s placement in the free cell. When the agent moves through the rack (for example, upon extraction or placement of another agent), this action is not triggered.
Local variables:
T agent — agent (material item)
StorageCell cell — cell

On agent retrieval — Code that will be executed when the agent (material item) is retrieved from the cell by the Retrieve block or by calling the retrieve() function of storage.
Local variables:
T agent — agent (material item)
StorageCell cell — cell

Appearance

Shelves color — [Visible if Rack type: Selective, FIFO flow, or LIFO flow] Color of the shelves.

Shelves tilt, ° — [Visible if Rack type: FIFO flow or LIFO flow] The angle at which all shelves are located in the storage relative to the aisle (the retrieval side in the case of FIFO flow storages). Accepts values between 0 and 90.

Frame color — Color of the frame.

Occupied cells animation — Here you can choose how to display agents inside the storage during the model run.

• color indication (fast) — individual agent animation is hidden, and the cell is filled with the agent color or a blend of vertically stored agents' colors: this allows for a more informing view of multi-level racks and has much better performance for large-scale warehouses. You can set the agent’s color by calling agent.setColor() function.
• agent animation — individual agent animation is placed in the center of the cell

Draw upright posts in 3D — [Visible if Show in: 2D and 3D or 3D only option is selected] Deselect this option if you do not need to draw vertical elements of the frame in 3D. Only shelves will be drawn in this case.

Bays between posts — [Visible if Show in: 2D and 3D or 3D only option is selected] The number of bays between frame posts if the posts are drawn in 3D. It does not affect the 2D animation of the pallet rack.

Position and size

Level — a level where this rack storage is located.

X — X-coordinate of the rack storage (upper left corner).

Y — Y-coordinate of the rack storage (upper left corner).

Z — Z-coordinate of the rack storage. It's relative to the Z-coordinate of the level where this rack storage lives.

Rotation — Rotation angle of the rack storage in XY plane.

Storage length — [Visible if Number of racks: defined explicitly] The length of the storage rack.

Storage width — [Visible if Number of bays: defined explicitly] The width of the storage rack.

Access zone — The width of a zone adjacent to the rack storage where any network path passing through it can be used by transporters or agents to approach the rack for storage or retrieval.

Advanced

Show in — Here you can choose whether you want the storage rack shape to be displayed both In 2D and 3D animation, in 2D only, or in 3D only.

Show name — If selected, the name of the storage rack shape is displayed on the graphical diagram.

You can dynamically modify storage properties at model runtime using the following API.

General

Function	Description
Storage()	A constructor to create a new storage with default parameters. You can change the parameters programmatically before markup initialization. Any operations with cells must be done after markup initialization.
RackUnitAggregator getStorageSystem()	Returns the storage system this storage belongs to.
void setRackType(RackType type)	Sets the rack type. type — the rack type. Valid values: RACK_TYPE_DRIVE_IN (drive-in), RACK_TYPE_SELECTIVE (selective), RACK_TYPE_FIFO_FLOW (FIFO), RACK_TYPE_LIFO_FLOW (LIFO).
RackPlacement getRackPlacement()	Returns the rack placement of this storage. Valid values are: RACK_PLACEMENT_STAND_ALONE — stand-alone RACK_PLACEMENT_BACK_TO_BACK — back-to-back
void setRackPlacement(RackPlacement rackPlacement)	Sets the rack placement of this storage: either stand-alone or back-to-back. Rack placement cannot be applied to FIFO storages. rackPlacement — the rack placement: either RACK_PLACEMENT_STAND_ALONE or RACK_PLACEMENT_BACK_TO_BACK.
boolean isLoadingDirectionReversed()	Returns the loading direction of this storage. true if the loading direction is reverse, false otherwise.
void setReverseLoadingDirection(boolean reversed)	Sets the loading direction of this storage. reversed — set to true to reverse the loading direction, to false — to use the default loading direction.

Storage configuration

Function	Description
int getNumberOfRacks()	Returns the number of racks in this storage.
void setNumberOfRacks(int numberOfRacks)	Sets the number of racks in this storage. Cannot be called after markup initialization. numberOfRacks — new number of racks
int getNumberOfBays()	Returns the number of bays per rack.
void setNumberOfBays(int numberOfBays)	Sets the number of bays per rack. Cannot be called after markup initialization. numberOfBays — new number of bays
int getNumberOfCellsPerSlot()	Returns the number of cells per slot.
void setNumberOfCellsPerSlot(int numberOfCells)	Sets number of cells per slot. Cannot be called after markup initialization. numberOfCells — new number of cells
int getNumberOfShelves()	Returns the number of shelves per rack.
void setNumberOfShelves(int numberOfShelves)	Sets number of shelves per rack. May not be called after initialization of markup. numberOfShelves — new number of shelves
double getRackDepth(LengthUnits units)	Returns the rack depth in specified length units. units — a constant defining length units
void setRackDepth(double rackDepth, LengthUnits units)	Sets the rack depth in specified length units. Cannot be called after markup initialization. rackDepth — new rack depth units — a constant defining length units
double getShelfHeight(LengthUnits units)	Returns the height of a shelf in specified length units. units — a constant defining length units
void setShelfHeight(double shelfHeight, LengthUnits units)	Sets the height of a shelf in specified length units. Cannot be called after markup initialization. shelfHeight — new shelf height units — a constant defining length units
double getCellWidth(LengthUnits units)	Returns the cell width in specified length units. units — a constant defining length units
void setCellWidth(double cellWidth, LengthUnits units)	Sets the cell width in specified length units. Cannot be called after markup initialization. cellWidth — new cell width units — a constant defining length units
double getAisleWidth(LengthUnits units)	Returns the aisle width in specified length units. units — a constant defining length units
void setAisleWidth(double aisleWidth, LengthUnits units)	Sets the aisle width in specified length units. Cannot be called after markup initialization. aisleWidth — new aisle width units — a constant defining length units
double getAccessZone(LengthUnits units)	Returns the width of the access zone in specified length units. units — a constant defining length units
void setAccessZone(double zoneWidth, LengthUnits units)	Sets the width of the access zone in specified length units. Cannot be called after markup initialization. zoneWidth — new width of the access zone units — a constant defining length units

Cells

All functions listed here can be called only after markup initialization.

All functions returning the free cells do not account for deactivated cells.

Function	Description
StorageCell getCell(Agent agent)	Returns the cell that contains the specified agent. agent — an agent (material item)
StorageCell getCell(int rack, int bay, int shelf, int deepPosition)	Returns the specified cell. rack — index of rack bay — index of bay shelf — index of shelf deepPosition — index of cell
List<StorageCell> getCells()	Returns a list of cells ordered according to the storage type.
StorageCell getRandomFreeCell()	Returns the next cell available for reservation in a random slot from the storage. Doesn’t work with FIFO flow and LIFO flow storages.
List<StorageCell> freeCells(int rack)	Returns a list of all free cells in the specified rack, excluding deactivated cells. rack — index of rack
List<StorageCell> freeCells(int rack, int bay)	Returns a list of all free cells in the specified bay, excluding deactivated cells. rack — index of rack bay — index of bay
List<StorageCell> freeCells(int rack, int bay, int shelf)	Returns a list of all free cells in the specified shelf, excluding deactivated cells. rack — index of rack bay — index of bay shelf — index of shelf
int nFreeCells()	Returns the total number of free cells in the storage, excluding deactivated cells.
int nFreeCells(int rack)	Returns a total number of free cells in the specified rack, excluding deactivated cells. rack — index of rack
int nFreeCells(int rack, int bay)	Returns a total number of free cells in the specified bay, excluding deactivated cells. rack — index of rack bay — index of bay
int nFreeCells(int rack, int bay, int shelf)	Returns a total number of free cells in the specified shelf, excluding deactivated cells. rack — index of rack bay — index of bay shelf — index of shelf

Slot

All functions listed here can be called only after markup initialization.

Function	Description
StorageSlot getSlot(int rack, int bay, int shelf)	Returns the specified slot. rack — index of rack bay — index of bay shelf — index of shelf Slots have their own set of functions that you can use to get their location in the storage.

In-slot speed

All functions listed here can be called only after markup initialization.

Function	Description
boolean isSpecifiedInslotSpeed()	Returns true if specific in-slot speed was enabled and false otherwise.
void setSpecifiedInslotSpeed(boolean enabled)	Enables specific in-slot speed if the argument is true and disables if the argument is false. enabled — if true, specific in-slot speed will be enabled; if false — disabled.
double getInslotSpeed(SpeedUnits units)	Returns in-slot speed in specified speed units. units — a constant defining speed units
void setInslotSpeed(double speed, SpeedUnits units)	Sets in-slot speed in specified speed units. speed — new in-slot speed value units — a constant defining speed units

Agents

All functions listed here can be called only after markup initialization.

Function	Description
int size()	Returns the number of stored agents. In FIFO flow and LIFO flow storages, this function doesn’t consider the agents still moving through the shelf to their target cells right after being stored.
List<Agent> getAgents()	Returns a list of agents stored in the storage, ordered according to storage type. In FIFO flow and LIFO flow storages, this function doesn’t consider the agents still moving through the shelf to their target cells.
Agent getRandomAgent()	Returns a random agent stored in the storage. If the storage is empty, returns null.
boolean contains(Agent agent)	Returns true if the given agent is stored in the storage and false otherwise. In FIFO flow and LIFO flow storages, this function doesn’t consider the agents still moving through the shelf to their target cells.
Agent getAgentInCell(int rack, int bay, int shelf, int deepPosition)	Returns the agent stored in the given cell. rack — index of rack bay — index of bay shelf — index of shelf deepPosition — index of cell

Reservation

All functions listed here can be called only after markup initialization.

Function	Description
boolean hasSpace(int rack, int bay, int shelf)	Returns true if the given slot has cells available for reservation and false otherwise. Deactivated cells are treated as unavailable for reservation. rack — index of rack bay — index of bay shelf — index of shelf
boolean hasSpace()	Returns true if the storage has cells available for reservation and false otherwise. Deactivated cells are treated as unavailable for reservation.
int nReserved()	Returns the number of reserved (but not occupied) cells. In FIFO flow and LIFO flow storages, this function also considers the cells the moving agents are trying to reach and the cells the agents move through, upon the function call.
List<StorageCell> reservedCells(int rack, int bay, int shelf)	Returns a list of reserved cells located in the given slot. rack — index of rack bay — index of bay shelf — index of shelf
List<StorageCell> reservedCells(int rack, int bay)	Returns a list of reserved cells located in the given bay. rack — index of rack bay — index of bay
void setReservation(Agent agent, int rack, int bay, int shelf)	Reserves a cell for the given agent in the given slot. The actual cell where the agent will be placed is determined at the moment of placement. agent — agent (material item) rack — index of rack bay — index of bay shelf — index of shelf
void setReservation(Agent agent, int rack, int bay)	Reserves a cell for the given agent in the given bay. The actual cell where the agent will be placed is determined at the moment of placement. agent — agent (material item) rack — index of rack bay — index of bay
void cancelReservation(Agent agent)	Discards any reservations made for the given agent. agent — agent (material item)

Storing operation

All functions listed here can be called only after markup initialization.

In FIFO flow storages, these functions immediately place the agent in the free cell that is the closest to the retrieval side of the rack. If other agents are moving in the direction of this cell, the agent stored with this function takes the priority.

Function	Description
void store(Agent agent)	Stores the given agent in the storage. If there are no cells available for reservation, an error will occur. agent — agent (material item)
void store(Agent agent, int rack, int bay, int shelf)	Stores the given agent in the given slot. If there are no cells available for reservation, an error will occur. agent — agent (material item) rack — index of rack bay — index of bay shelf — index of shelf
void store(Agent agent, int rack, int bay)	Stores the given agent in the given bay. If there are no cells available for reservation, an error will occur. agent — agent (material item) rack — index of rack bay — index of bay
void store(Agent agent, int rack)	Stores the given agent in the given rack. If there are no cells available for reservation, an error will occur. agent — agent (material item) rack — index of rack

Retrieving operation

All functions listed here can be called only after markup initialization.

In FIFO flow and LIFO flow storages, the agent can be retrieved only from the cell adjacent to the aisle (on the retrieval side in the case of FIFO flow storages). Upon an attempt to retrieve an agent from other cells, an error occurs.

Function	Description
Agent retrieve(Agent agent)	Retrieves and returns the previously stored agent from the storage. agent — agent (material item)
Agent retrieve(int rack, int bay, int shelf)	Retrieves and returns the next available agent from the specified slot. rack — index of rack bay — index of bay shelf — index of shelf
Agent retrieve(int rack, int bay)	Retrieves and returns the next agent from the specified bay. rack — index of rack bay — index of bay
Agent retrieve(int rack)	Retrieves and returns the next agent from the specified rack. rack — index of rack

Storage as obstacle

Function	Description
boolean isObstacle()	Returns true if the racks of this storage are considered obstacles by pedestrians and transporters with free space navigation. Otherwise, returns false.
void setObstacle(boolean isObstacle)	Sets the racks of this storage as obstacles for pedestrians and transporters with free space navigation. isObstacle — specify true to turn the racks into obstacles; specify false otherwise.

Storage position

Function	Description
double getX()	Returns the X coordinate of this storage.
void setX(double x)	Sets the X coordinate of this storage. Cannot be called after markup initialization. x — new X-coordinate of the storage
double getY()	Returns the Y coordinate of this storage.
void setY(double y)	Sets the Y coordinate of this storage. Cannot be called after markup initialization. y — new Y-coordinate of the storage
double getZ()	Returns the Z coordinate of this storage.
void setZ(double z)	Sets the Z coordinate of this storage. Cannot be called after markup initialization. z — new Z-coordinate of the storage
double getRotation()	Returns the rotation of the storage in radians.
void setRotation(double rotation)	Sets the rotation of the storage. Cannot be called after markup initialization. rotation — new rotation value in radians

Storage appearance

Function	Description
Color getShelvesColor()	Returns the color of rack shelves.
void setShelvesColor(Color shelvesColor)	Sets the color of rack shelves. This function doesn’t work for rack storages with the drive-in rack type. shelvesColor — new color of the shelves
double getShelvesTiltAngle()	Works for FIFO flow and LIFO flow storages. Returns the tilt angle of shelves, in radians.
void setShelvesTiltAngle(double tiltAngle)	Works for FIFO flow and LIFO flow storages. Sets the tilt angle of shelves. tiltAngle — a new angle at which the storage shelves should be placed, in radians.
Color getFrameColor()	Returns the color of the rack frame.
void setFrameColor(Color frameColor)	Sets the color of the rack frame. frameColor — new color of the frame

Level

Function	Description
Level getLevel()	Returns the level, where this storage is located.

Statistics

Function	Description
int capacity()	Returns the maximum possible number of agents that can be stored in this storage. Deactivated cells are excluded from the result.
int nStored()	Returns the total number of stored agents. May be reset by calling resetStats() function.
int nRetrieved()	Returns the total number of retrieved agents. May be reset by calling resetStats() function.
double utilization()	Returns the storage’s utilization. Utilization is a double value in the [0, 1] range that is calculated as a ratio of occupied cells to capacity.
void resetStats()	Resets the statistics of the storage: the number of stored agents and the number of retrieved agents.

This section contains functions of the StorageSlot class. They can be called only after markup initialization.

Location in storage

Function	Description
Storage getStorage()	Returns the rack storage that this slot belongs to.
int getRack()	Returns the index of the rack that this slot belongs to.
int getShelf()	Returns the index of the shelf that this slot belongs to.
int getBay()	Returns the index of the bay that this slot belongs to.

This section contains functions of the StorageCell class. They can be called only after markup initialization.

Location in storage

Function	Description
Storage getStorage()	Returns the rack storage that this cell belongs to.
int getRack()	Returns the index of the rack that this cell belongs to.
int getShelf()	Returns the index of the shelf that this cell belongs to.
int getBay()	Returns the index of the bay that this cell belongs to.
int getDeepPosition()	Returns the index of this cell in the slot.
Agent getAgent()	Returns the agent that occupies this cell or null if the cell is not occupied. agent — agent (material item)

Storing and retrieving

Function	Description
boolean isAvailableToStore()	Returns true if the cell is both open for reservation and accessible, false otherwise.
boolean isAvailableToRetrieve()	Returns true if the cell is both accessible and contains an agent, false otherwise.
void store(Agent agent)	Stores the specified agent in this cell. The agent is stored in the cell immediately and without animation. The specified agent cannot have another cell reserved, and this cell must be available for reservations. agent — agent (material item)
Agent retrieve()	Removes and returns the agent that currently occupies this cell. The cell must not be empty. Should not be used in FIFO flow and LIFO flow storages. Consider using the retrieval functions of the Storage element itself instead.

Reservation

Function	Description
boolean isFree()	Returns true if the cell is both empty, not reserved by any agent, and not deactivated. Returns false otherwise.
void setReservation(Agent agent)	Reserves this cell for the specified agent. This cell must not be reserved by any other agent when this function is called, otherwise, an error message will be displayed. Should not be used with FIFO flow and LIFO flow storages. agent — agent (material item)
Agent cancelReservation()	Cancels reservation for the agent that reserved this cell and returns this agent. The cell must be explicitly reserved by any agent. Should not be used with FIFO flow and LIFO flow storages.

Cell deactivation

Function	Description
boolean isActive()	Returns true if the cell is not deactivated and operates normally, false otherwise.
void deactivate()	Deactivates the cell and disallows all operations with it. Agents (material items) can be transported through the areas where cells were deactivated. This function may be useful to model rack storage with irregularly placed empty spaces. Once deactivated, the cell cannot be activated again during runtime. In FIFO flow and LIFO flow storages, only the aisle-adjacent cells can be deactivated.

How can we improve this article?

Send