| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #let version = json("/datasheet/version.json").version |
| #let dict = csv("/data-dictionary.csv", row-type: dictionary) |
| #let containers = csv("/containers.csv", row-type: dictionary) |
| #let listings = csv("/listings.csv", row-type: dictionary) |
|
|
| #let ink = rgb("#16191d") |
| #let accent = rgb("#245c8c") |
| #let soft = rgb("#f1f4f7") |
| #let rule = rgb("#c7cdd4") |
|
|
| #set document( |
| title: "Industrial Storage Container Dimensions — datasheet v" + version, |
| author: "Daniel Rosehill", |
| ) |
| #set page( |
| paper: "a4", |
| margin: (x: 19mm, top: 20mm, bottom: 18mm), |
| footer: context [ |
| #set text(8pt, fill: gray) |
| #grid( |
| columns: (1fr, auto, 1fr), |
| align: (left, center, right), |
| [danielrosehill/storage-container-dimensions], |
| [datasheet v#version], |
| [#counter(page).display("1 / 1", both: true)], |
| ) |
| ], |
| ) |
| #set text(font: "IBM Plex Sans", size: 9.5pt, fill: ink, |
| number-type: "lining", number-width: "tabular") |
| #set par(justify: false, leading: 0.62em) |
| #show heading: set text(fill: accent) |
| #show heading.where(level: 1): it => block(above: 1.5em, below: 0.75em)[ |
| #set text(14pt, weight: 600) |
| #it.body |
| #v(-0.45em) |
| #line(length: 100%, stroke: 0.6pt + rule) |
| ] |
| #show heading.where(level: 2): set text(10.5pt, weight: 600) |
| #show link: set text(fill: accent) |
| #show table.cell.where(y: 0): set text(weight: 600, size: 8pt) |
| #set table( |
| stroke: (x, y) => ( |
| bottom: if y == 0 { 0.7pt + rule } else { 0.3pt + rule.lighten(35%) }, |
| ), |
| fill: (x, y) => if y == 0 { soft }, |
| inset: (x: 5pt, y: 4pt), |
| ) |
|
|
| #let count(rows, pred) = rows.filter(pred).len() |
| #let uniq(rows, key) = { |
| let seen = () |
| for r in rows { if not seen.contains(r.at(key)) { seen.push(r.at(key)) } } |
| seen |
| } |
|
|
| |
|
|
| #block[ |
| #text(8.5pt, fill: gray, weight: 600, tracking: 0.08em)[DATASET DATASHEET] |
| #v(0.35em) |
| #text(21pt, weight: 600, fill: accent)[Industrial Storage \ Container Dimensions] |
| #v(0.5em) |
| #text(10.5pt, fill: gray)[ |
| Planning-grade volumetric reference for Euroboxes, attached-lid containers and |
| VDA 4500 KLTs — the plastic totes European and North American warehouses run on. |
| ] |
| ] |
|
|
| #v(0.8em) |
| #grid( |
| columns: (auto, 1fr), |
| gutter: 8pt, |
| row-gutter: 3pt, |
| text(fill: gray)[Version], [*#version*], |
| text(fill: gray)[Compiled], [#datetime.today().display("[day] [month repr:long] [year]")], |
| text(fill: gray)[Canonical], link("https://huggingface.co/datasets/danielrosehill/storage-container-dimensions")[huggingface.co/datasets/danielrosehill/storage-container-dimensions], |
| text(fill: gray)[Licence], [CC BY 4.0], |
| text(fill: gray)[Tables], [`containers.csv` — #containers.len() rows, #count(dict, r => r.table == "containers") columns · `listings.csv` — #listings.len() rows, #count(dict, r => r.table == "listings") columns], |
| ) |
|
|
| #v(0.7em) |
| #block(fill: soft, inset: 9pt, radius: 3pt, width: 100%)[ |
| *The one thing to take from this document.* The standards fix the *footprint*. They |
| do not fix internal dimensions, and they barely fix heights. Every internal |
| dimension and capacity here is a typical figure averaged across vendor catalogues, |
| good to roughly ±1 L on a 600 × 400 box — a planning number, not a specification. |
| Check the specific supplier's own figures before committing to a large order. |
| ] |
| |
| = What it is for |
| |
| The dataset stops at the unit: it describes the smallest standardised unit of |
| industrial storage and nothing above it. The calculations downstream are the |
| reader's, and in practice they are pallet load patterns, shelving and racking |
| layouts, consolidation and move planning, and ranking purchases on cost per |
| *usable* litre rather than on the nominal size printed on a listing. |
|
|
| #v(0.3em) |
| #table( |
| columns: (1fr, 1fr), |
| table.header[In scope][Out of scope], |
| [External and internal dimensions, both unit systems], [Pallet builds and load patterns], |
| [External volume and usable capacity], [Container loads, TEU utilisation, stowage], |
| [Nesting and stacking behaviour], [Shelving and racking layouts], |
| [Lid arrangement, standards conformance], [Live pricing, availability, lead times], |
| [What the trade calls each family, per geography], [Any one manufacturer's exact spec], |
| ) |
| |
| #v(0.3em) |
| The single deliberate exception is `eur1_pallet_per_layer`, the footprint count on a |
| 1200 × 800 deck. It is the last figure that is purely a property of the box; anything |
| past it depends on build height, pallet standard and container choice, which are |
| decisions rather than dimensions. |
| |
| = Composition |
| |
| == `containers.csv` — one typical row per nominal size |
| |
| #let fam(t) = containers.filter(r => r.type == t) |
| #let heights(rows) = { |
| let h = uniq(rows, "external_height_cm").map(x => float(x)).sorted() |
| str(calc.min(..h)) + "–" + str(calc.max(..h)) + " cm, " + str(h.len()) + " values" |
| } |
| #table( |
| columns: (auto, auto, 1fr, auto), |
| align: (left, right, left, left), |
| table.header[Family][Rows][Footprints (cm)][External heights], |
| ..(("euro_stacking_container", "Euro stacking container"), |
| ("attached_lid_container", "Attached-lid container"), |
| ("vda_klt_container", "VDA 4500 KLT")).map(((key, label)) => { |
| let rows = fam(key) |
| ( |
| [#label], [#rows.len()], |
| [#uniq(rows.map(r => (v: r.external_length_cm + " × " + r.external_width_cm)), "v").join(", ")], |
| [#heights(rows)], |
| ) |
| }).flatten(), |
| ) |
| |
| Rows are nominal sizes, not products. A row exists where a size is either sold by a |
| captured vendor or is a defensible interpolation within a family's grid; |
| `listings_observed` says which, and a `0` there means nobody in `listings.csv` was |
| selling it. |
|
|
| == `listings.csv` — the observations behind them |
|
|
| #table( |
| columns: (1fr, auto, auto, auto, auto, auto), |
| align: (left, left, right, right, right, left), |
| table.header[Vendor][Market][Listings][Publishes internals][Native unit][Captured], |
| ..uniq(listings, "vendor").sorted().map(v => { |
| let rows = listings.filter(r => r.vendor == v) |
| ( |
| [#v], [#rows.at(0).vendor_country], [#rows.len()], |
| [#count(rows, r => r.internal_length_cm != "")], |
| [#rows.at(0).native_unit], |
| [#uniq(rows, "captured_date").map(d => d.slice(0, 10)).join(", ")], |
| ) |
| }).flatten(), |
| ) |
|
|
| This table exists so the first one can be audited. Every typical capacity is a |
| judgement about a spread of real products; these are the products, with URLs and |
| capture dates, so a reader who disagrees with a figure can see what it was |
| generalised from. Prices are captured observations with a date on them — kept to make |
| a capacity auditable against what was really on sale, not a price feed, and they rot. |
|
|
| = How the numbers were derived |
|
|
| *Straight-walled boxes.* Internal dimensions follow a per-footprint rule averaged |
| across vendor catalogues — for 600 × 400, internally 550 × 355 mm with the height less |
| 15 mm — and capacity is computed from those. The rule sits deliberately at the |
| conservative end of the published range. |
|
|
| *Attached-lid containers.* The taper means no single internal L × W × H is right |
| wherever you measure it, and no captured vendor publishes one for a 600 × 400 or |
| 400 × 300 ALC. Capacity is the manufacturer's nominal figure, which is the only |
| honest number available; `internal_*` is empty and `internal_dims_basis` says |
| `not_published_tapered_walls`. |
| |
| *VDA KLTs.* Thicker-walled than consumer Euroboxes, so the straight-wall rule does not |
| transfer. Where a vendor publishes internals for the exact size they are used; |
| elsewhere capacity is derived from the one published pair (R-KLT 6429, 600 × 400 × 280 |
| external = 67.2 L, 48 L internal) and `capacity_basis` says so. |
| |
| *Both unit systems, on every row.* Dimensions in centimetres and inches, capacity in |
| litres and US gallons. On `listings.csv`, `native_unit` records which side is the |
| vendor's own figure and which is the conversion — the derived side is rounded, so a |
| US vendor's own 19.6 in read back from a 1 dp centimetre value becomes 19.61. |
| |
| = Known limitations |
| |
| / Internal dimensions are not standardised: Wall thickness, draft angle and rib design |
| are the manufacturer's choice. Across the four captured catalogues a |
| 60 × 40 × 32 cm Eurobox is quoted internally at anything from 60.4 to 66.4 L — an |
| 11 % range on a box all of them call 600 × 400 × 320. `vendor_capacity_low_l` and |
| `vendor_capacity_high_l` carry that range on every row rather than hiding it. |
|
|
| / Heights are convention, not standard: Of the #count(containers, r => r.type == "euro_stacking_container" and r.external_length_cm == "60.0" and r.external_width_cm == "40.0") distinct |
| 600 × 400 heights here, exactly one — 280 mm — is fixed by a standard (VDA 4500). |
| The rest are what manufacturers happen to make, and one-off variants exist. |
|
|
| / Inch-designed totes near-miss the module: US vendors design to inches and land close |
| to 600 × 400 without hitting it. Hudson Exchange's 24 × 15 in straight-wall tote is |
| 61.0 × 38.1 cm — one centimetre too long to put four on a Euro pallet, so the layer |
| pattern collapses from 4 to 2. Filter on the footprint in millimetres, never on a |
| product being called an industrial tote. |
| |
| / The 800 × 600 rows are the weakest: They are formula-derived, and the only vendor |
| publishing internals for that footprint implies 8–9 % more capacity than the rule |
| gives. Treat them as conservative. |
| |
| / Four vendors, three markets, one capture window: NL, GB, IL and US, captured July |
| 2026. This is not a census of the market, and Asian manufacturers are absent. |
| |
| = Provenance and reproducibility |
| |
| Vendor catalogues were captured from the storefronts' own JSON endpoints — Shopify |
| `/products.json` for the UK and US vendors, Lightspeed `?format=json` for the Dutch |
| one — and the trimmed captures are committed under `raw/`. The builders never touch |
| the network, so a rebuild reproduces the same tables from the same snapshots. |
|
|
| #v(0.3em) |
| #table( |
| columns: (auto, 1fr), |
| align: (left, left), |
| table.header[Step][Command], |
| [Listings from the snapshots], [`python3 build_listings.py`], |
| [Typical rows, dictionary, card], [`python3 build.py`], |
| [Printable dimensional reference], [`python3 scripts/build_reference_pdf.py`], |
| [This datasheet], [`./datasheet/build.sh`], |
| ) |
|
|
| #v(0.3em) |
| `build.py` renders the data dictionary four ways — `data-dictionary.csv`, |
| `docs/data-dictionary.md`, the dataset card's field table and the Hub's dtype |
| frontmatter — and fails if a builder emits a column the dictionary does not document. |
| The schema and its documentation cannot drift apart. |
|
|
| #pagebreak() |
|
|
| = Data dictionary |
|
|
| Version #version. Every column in both tables. Rendered from `data-dictionary.csv`, |
| which is itself generated from `dictionary.py`. |
|
|
| #set text(8.5pt) |
| |
| |
| #for (tbl, fname) in (("containers", "containers.csv"), ("listings", "listings.csv")) [ |
| == #raw(tbl) → #raw(fname) |
|
|
| #let cols = dict.filter(r => r.table == tbl) |
| #table( |
| columns: (auto, auto, auto, 1fr), |
| align: (left, left, left, left), |
| table.header[Column][Type][Unit][Description], |
| ..cols.map(c => ( |
| raw(c.column), [#c.dtype], [#if c.unit == "" { "—" } else { c.unit }], |
| |
| |
| eval(c.description.replace("**", "*"), mode: "markup"), |
| )).flatten(), |
| ) |
| ] |
|
|
