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.
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
| Output | Gives | What it is |
|---|---|---|
Resultsresults | 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 chartchart | Table csv | throughput_by_fleet.csv: orders per hour by fleet size, one column per order rate |
Summarysummary | Metrics json | Best fleet per order rate, scenarios, time and speed on this worker |
Live telemetrytelemetry | Live telemetry | What the block sends while it runs, for views such as Chart or 3D view. |
Settings
| Setting | Default | What it does |
|---|---|---|
Fleet sizesfleets |
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 combinationseeds |
3 | Each with other random orders; the results are averaged From 1 to 20 |
Simulated hourshours |
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 |
Acceleratoraccelerator |
auto | auto: Tenstorrent cards, else an NVIDIA GPU, else the CPU of the worker that runs it One of: auto, CPU, NVIDIA GPU, Tenstorrent |
Layoutlayout |
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 pairsrack_pairs |
20 | From 4 to 30 |
Rack blocksrack_blocks |
5 | From 1 to 8 |
Rack length (m)rack_len |
8 | From 4 to 16 |
Pack-out stationsstations |
8 | From 1 to 20 |
Receiving stationsinbound |
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 levelslevels |
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 itempick_s |
10 | From 1 to 120 |
Seconds to unload at the stationstation_s |
15 | From 1 to 120 |
Seconds to load a deliveryload_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 chargebattery_h |
8 | From 0.5 to 24 |
Minutes to charge from emptycharge_min |
60 | From 5 to 600 |
Go to charge below (%)charge_below |
25 | From 5 to 80 |
Incidents per hourincidents_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 comesresponse_min |
3 | From 0 to 120 |
Minutes to clean up a spillclear_min |
4 | From 0.1 to 240 |
Minutes to repair a robotrepair_min |
8 | From 0.1 to 480 |
Random seedseed |
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.