Esacode

Docs / Blocks / Simulation

Fleet-size sweep

How many robots does the warehouse need? Hundreds of fleet-size × order-rate scenarios with inbound and outbound flow, real speeds, times, batteries and incidents, simulated at once as one batch on the CPU, an NVIDIA GPU or Tenstorrent cards.

Runs on a worker (Python) Simulation Version 1.0 Code you can open and adapt

How it works

Simulates every combination of Fleet sizes, Order rates and Seeds in the warehouse of the Warehouse fleet block (same hall, robots, times, batteries and incidents; Layout changes it as there), for the same simulated hours (after a warm-up), all at once: the robots of all scenarios are one batch of tensors. Fleet sizes and order rates are lists (10,20,30) or ranges (10-60/10 = from 10 to 60 by 10).

Incidents are the same in every scenario (all scenarios share the routes): a spill closes the same aisle cell in all of them, and a robot stopped by a fault blocks the way of those behind it until it is repaired.

Accelerator: CPU plans routes with SciPy and steps with PyTorch; NVIDIA GPU runs everything on the GPU; Tenstorrent plans the routes on the cards with TT-NN (Tensix tile matmuls) and runs the scenarios' steps on the cards too when PyTorch/XLA for Tenstorrent (tt-xla) is installed, else on the CPU beside them; the computer with the cards needs TT-NN in the worker's Python (pip install ttnn). auto uses Tenstorrent cards when the worker has them, else an NVIDIA GPU, else the CPU.

Every scenario has inbound flow too: deliveries arrive as many as its orders take out and robots store them, from shelves Shelves full at the start.

For each fleet size and order rate, averaged over the seeds: orders and lines per hour delivered, packages stored per hour, reaction and putaway times, deliveries waiting, shelves full, share of the demand served, average and 95th-percentile order time, robots busy, time spent waiting, time spent charging, orders left waiting, and robot cost per order (Robot cost per hour).

Live telemetry (channel sweep) carries the results as they form, for the Fleet sweep view; the results are also in fleet_sweep.csv, throughput_by_fleet.csv (for a Chart) and sweep_summary.json (the cheapest fleet that keeps up with each order rate, and the speed of the worker).

Outputs

OutputGivesWhat it is
Results
results
Table
csv
fleet_sweep.csv: one row per fleet size and order rate (orders, stored, order and putaway times, robots busy, cost per order…)
For a chart
chart
Table
csv
throughput_by_fleet.csv: orders per hour by fleet size, one column per order rate
Summary
summary
Metrics
json
Best fleet per order rate, scenarios, time and speed on this worker
Live telemetry
telemetry
Live telemetryWhat the block sends while it runs, for views such as Chart or 3D view.

Settings

SettingDefaultWhat it does
Fleet sizes
fleets
20-60/10 Robots: a list (10,20,30) or a range (10-60/10)
Order rates (orders per hour)
rates
200,300,400,500 Each order has 1 to 3 lines; deliveries arrive as many as the orders take out
Seeds per combination
seeds
3 Each with other random orders; the results are averaged
From 1 to 20
Simulated hours
hours
2
From 0.1 to 24
Warm-up (simulated minutes, not counted)
warmup_min
10
From 0 to 120
Robot cost per hour ($)
robot_cost_h
2.5 Lease, energy and upkeep of one robot for an hour of work
From 0 to 100
Accelerator
accelerator
auto auto: Tenstorrent cards, else an NVIDIA GPU, else the CPU of the worker that runs it
One of: auto, CPU, NVIDIA GPU, Tenstorrent
Layout
layout
empty Changes to the layout in the same hall, as key=value: blocks=3 (rack blocks from front to back), stations=6, stations_at=both (south and north walls), inbound=2, inbound_at=south (receiving on the pack-out wall), levels=4, slotting=random (popular packages anywhere). Empty: the hall below as it is
Rack pairs
rack_pairs
20
From 4 to 30
Rack blocks
rack_blocks
5
From 1 to 8
Rack length (m)
rack_len
8
From 4 to 16
Pack-out stations
stations
8
From 1 to 20
Receiving stations
inbound
4 Where deliveries come in on a conveyor and robots load them (north wall unless the Layout says inbound_at=south)
From 0 to 20
Shelf levels
levels
3 Levels of each rack; each level holds one package per metre on each side
From 1 to 4
Shelves full at the start (%)
fill
70 The run starts from this stock, A packages near the pack-out stations, so it begins in a steady state
From 0 to 98
Seconds to pick an item
pick_s
10
From 1 to 120
Seconds to unload at the station
station_s
15
From 1 to 120
Seconds to load a delivery
load_s
6 At the receiving station, per package; storing one on a shelf takes as long as a pick
From 1 to 120
Robot speed (m/s)
robot_speed
1.2
From 0.3 to 2
Hours on a charge
battery_h
8
From 0.5 to 24
Minutes to charge from empty
charge_min
60
From 5 to 600
Go to charge below (%)
charge_below
25
From 5 to 80
Incidents per hour
incidents_h
2 Spills or dropped items that close an aisle, and robot faults; 0 for none
From 0 to 60
Robot faults (% of incidents)
fault_share
40
From 0 to 100
Minutes until someone comes
response_min
3
From 0 to 120
Minutes to clean up a spill
clear_min
4
From 0.1 to 240
Minutes to repair a robot
repair_min
8
From 0.1 to 480
Random seed
seed
1

Where it runs

On one of your computers with the EsaSim worker: Any worker, NVIDIA GPU, Tenstorrent. The worker installs the Python packages it needs when they are missing: torch[cuda]</code>, <code>scipy.

In its code, settings are ctx.params["key"], inputs ctx.inputs["id"] and outputs ctx.output("id", "name.ext"); see Custom blocks.

More in Simulation