RackPick


RackPick removes agent from a cell in the specified pallet rack, or RackSystem and moves it to the specified destination location. This is optionally done with the help of moving resources, and, also optionally, a delay may be associated with picking the agent. The delay may depend on the cell coordinates, e.g. on the level. You need to specify the pallet rack, or RackSystem where the agent is stored.

If resources are used to move the agent, RackPick seizes them, brings to the agent cell location, executes (an optional) delay, attaches resources to the agent, moves the agent to the destination, and then releases the resources. Alternatively you can seize and release resources outside the RackPick object, or not use them at all.

You can choose whether the agent (possibly, with the attached resources) moves smoothly all the way from the cell to the aisle and then along the aisle, or jumps from the cell to the aisle and then moves just along the aisle. The latter case may be useful when animating automated storages.

RackPick exposes a number of extension points to insert your custom actions at different stages of the process.

Parameters

Pallet rack / Rack system [dynamic]
Pallet rack, or storage zone (defined by block RackSystem), from where the agent should be extracted.
Local variable: agent - the agent
Destination is
Defines how the destination node is defined: 
Network node - agent moves to the specified network node.
Attractor
- agent moves to the specified attractor.
Seized resource unit - agent moves to the current location of the seized resource (specified below in the Resource field).
Agent/unit - the agent moves to the location of the specified agent.
(x,y,z) - the agent moves to the point with the specified coordinates.
Node + (x,y,z) - the agent moves to the specified node with the specified offset.
Get value: destinationType
Default value: Network node (RackPick.DEST_NODE)
Valid values: RackPick.DEST_NODE
           RackPick.DEST_ATTRACTOR
           RackPick.DEST_RESOURCE
           RackPick.DEST_AGENT
           RackPick.DEST_XYZ
           RackPick.DEST_NODE_XYZ
Node [dynamic]
[Visible if Destination is Network node or Node + (x, y, z)] The name of the network node (a rectangle) where the agent will move.
Value type: Node
Local variable: agent - the agent
Attractor [dynamic]
[Visible if Destination is Attractor] The name of the attractor where the agent will move.
Value type: Attractor
Local variable: agent - the agent
Resource [dynamic]
[Visible if Destination is Seized resource unit] The name of the resource pool of the unit to whose location the agent will move. If several units of the same pool are seized, the first in the list will be chosen.
Value type: ResourcePool
Local variable: agent - the agent
Agent [dynamic]
[Visible if Destination is Agent/unit] The agent to move to (it may be e.g. a particular resource unit of some other agent).
Value type: Agent
Local variable: agent - the agent
X, Y, Z [dynamic]
[Visible if Destination is (x, y, z) or Node + (x, y, z)]
Value type: double
Local variable: agent - the agent
Use delay
If the checkbox is selected (true), the delay is executed before it is actually removed from the cell (if resources are used, the delay starts when the resources arrive).
Syntax:
 boolean useDelay
Default value: false
Delay time [dynamic]
[Visible if Use delay is selected] Expression evaluated to obtain the delay time for the agent. 
Value type:  double
Local variables: agent - the agent.
             PalletRackAccess storage - the storage or storage zone where the agent is put
             int row - the row of the cell
             int position - the position of the cell
             int level -  the level of the cell
Take agent from
Defines whether the agent (possibly, with the attached resources) moves smoothly all the way from its current position to the cell, or moves just to the position in front of cell and then jumps to the cell. Choose between: Cell (with elevation), Cell base level, Aisle.
Get value: movementDestination
Default value: Cell (with elevation) (RackPick.DEST_CELL_LEVEL)
Valid values: RackPick.DEST_CELL_LEVEL
           RackPick.DEST_CELL_BASE
           RackPick.DEST_AISLE
Drop time per level [dynamic]
[Visible if Take agent from is defined as Cell (with elevation)]
Value type: double
Default value: 10 seconds
Local variable: agent - the agent
Resources
Use resources to move
If the checkbox is selected (true), the specified moving resources are used to move the agent.
Get value: boolean useResources
Default value: false
Resource sets (alternatives) [dynamic] 
[Visible if Use resources to move is selected] Here you define set(s) of the required resources (ResourcePool objects). You can define several alternative resource sets (add new list by clicking the Add list button). The resource set is chosen based on the availability of units. 
Local variable: agent - the agent
Seize policy
[Visible if Use resources to move is selected] Here you can define the policy of seize:
Seize whole set at once - agent waits until some set becomes fully available, and at that time it seizes all units.
Seize units one by one - agent tries seizing units of any alternative set, once units become available.
Get value: seizePolicy
Default value:  Seize whole set at once (RackPick.SEIZE_WHOLE_SET)
Move at the speed of resource
[Visible if Use resources to move is selected] If selected (true), the agent moves with the speed of the moving resource specified below in the parameter Moving resource.
Syntax: boolean moveWithSpeedOfResourceUnit
Default value: false
Moving resource [dynamic]
[Visible if Move at the speed of resource is selected] Here you specify the name of the ResourcePool block that defines the set of moving resources. The agent will move with the speed of this moving resource.
Value type: ResourcePool
Local variable: agent - the agent
Task priority [dynamic]
[Visible if Use resources to move is selected] The priority of the task for the incoming agent (the larger the higher).
Value type: double
Default value: 0
Local variable: agent - the agent
Task may preempt [dynamic]
[Visible if Use resources to move is selected] If selected, task may preempt the currently performed task (if allowed in the task properties & the task priority is lower).
Value type: boolean
Default value: true
Local variable: agent - the agent
Task preemption policy [dynamic]
[Visible if Use resources to move is selected]
Here you can choose what is done when some other task incomes for the resource unit(s) currently busy with the RackPick operations.
No preemption - the current task continues executing.
Wait for original resource - the task is interrupted and waits for the same resource unit to finish it.
Terminate serving - the task is interrupted and never continued.
Seize any resource - the task is interrupted and tries to seize any resource of the specified type.
Continue without resource - the task is finished without resources assistance.
Default value: No preemption 
Local variable: agent - the agent
Auto suspend/resume agents
[Visible if Task preemption policy is to Wait for original resource or to Seize any resource] This parameter defines whether the agent whose task is suspended should be automatically suspended in its current flowchart block and automatically resumed at the time there are available resources.
Syntax: boolean suspendResumeEntities
Default value: true
Enter for terminated agents [dynamic]
[Visible if Task preemption policy is to Terminate serving] Enter block for agents which lose all units obtained in this Seize block because of Terminate serving preemption policy, when one of units in the resource set (defined in this Seize) gets grabbed by another task with higher priority.
Local variables: agent - the agent
                          Agent unit - the unit which has originated termination
After release resources
[Visible if Use resources to move is selected] Defines whether resources should Return to home location (if they are not immediately seized by another agent) or Stay where they are after being released.
Syntax: boolean resourcesGoHome
Default value: Return to home location (true)
Return home [dynamic]
[Visible, if After release resources: Return to home location]
Here you select in what case resource units will return home after performing the "remove agent from storage cell" task.
There are three alternative options:
each time - resource unit will return in its home location each time this resource unit finishes the task and is released by the agent. 
if no other tasks - resource unit returns in its home location only if there are no other tasks currently waiting for this resource unit.
custom- if you select this option, you can define the priority and preemption policy for "return home" task using the parameters below. In this case the priority of the "return home" task will be compared with priorities of other incoming tasks, and the specified preemption policy will be used to select the next task for this particular resource unit. 
Local variables: agent - the agent
                          Agent unit - the unit 
'Wrap-up' priority [dynamic]
[Visible, if Return home: custom] Here you can set up the priority of the "return home" task for the resource unit. 
Value type: double
Local variables: agent - the agent
                          Agent unit - the unit 
'Wrap-up' preeemption policy [dynamic]
[Visible, if Return home: custom] Specifies the policy of the "return home" task for the resource unit. 
No preemption - "return home" task cannot be preempted
Terminate - "return home" task may be preempted and will be terminated
Local variables: agent - the agent
                          Agent unit - the unit 
Customize resource choice
[Visible if Use resources to move is selected] If the option is selected, you can choose a specific resource unit to perform the "remove agent from a pallet rack cell" operation (using the Resource choice condition below.) 
Syntax: boolean customizeResourceChoice
Default value: false
Resource choice condition [dynamic]
[Visible if Customize resource choice is selected] Here you can specify boolean expression that will be checked to find the specific resource unit that may perform the "remove agent from a pallet rack cell" operation. If none currently available resource units satisfy the specified condition (the condition returns false), RackPick will wait for the first resource unit that matches the condition.
Usually you define some field inside the agent type (say, worker), store there the reference to the resource unit when it starts working with this agent (agent.worker=unit), and then specify here the condition agent.worker==unit enabling only this particular unit to continue working with this particular agent.
Value type: boolean
Default value: true
Local variables: agent - the agent
                          Agent unit - the unit
                          ResourcePool pool - the resource pool
Actions
On enter [code]
Code executed when the agent enters this flowchart block.
Local variable: T agent - the agent.
On resources arrived [code]
[Visible if Use resources to move is selected] Code executed when the resources arrive to the agent current location.
Local variables: T agent - the agent.
             PalletRackAccess storage - the storage or storage zone where the agent is put
             int row - the row of the storage cell
             int position - the position of the storage cell
             int level -  the level of the storage cell
On delay starts [code]
[Visible if Use delay is selected] Code executed when the delay associated with removing the agent starts.
Local variables: agent - the agent.
             double delayTime - the delay time.
             PalletRackAccess storage - the storage or storage zone where the agent is put.
             int row - the row of the storage cell.
             int position - the position of the storage cell.
             int level - the level of the storage cell.
On delay ends [code]
[Visible if Use delay is selected] Code executed when the delay associated with removing the agent ends.
Local variable: agent - the agent.
On exit [code]
Code executed when the agent exits the object.
Local variable: T agent - the agent.
On task suspended [code]
[Visible if Task preemption policy is set to Wait for original resource or Seize any resource] Code executed when agent task is suspended because of Wait for original resource and Seize any resource preemption policy, when its unit gets grabbed by another task with higher priority. 
Local variables: agent - the agent
                          Agent unit - the unit
On task resumed [code]
[Visible if Task preemption policy is set to Wait for original resource or Seize any resource] Code executed when agent resumes processing after it has been suspended because of Seize any resource and Wait for original resource preemption policy.
Local variables: agent - the agent
                          Agent unit - the unit
On task terminated [code]
[Visible if Task preemption policy is set to Terminate serving] Code executed when agent loses all units obtained in this Seize block because of Terminate serving preemption policy, when one of units in the resource set (defined in this Seize) gets grabbed by another task with higher priority.
Local variables: agent - the agent
                          Agent unit - the unit which has originated termination.

Functions

int queueSize()Returns the size of the queue of agents waiting for the resource.

Ports

in
The input port.
out
The output port.