# Lagerplanung in BricsCAD -> Lager-JSON (GOH-Buehnenlager)

Schema und Schnittstelle der Lagerplanung. Code: `Lisp/LagerInsert.lsp`,
`Lisp/LagerPruefung.lsp`. Daten: `data/json/lager.json`,
`cfg/stahlbau/regelwerk/*.json`, `cfg/layer.cfg` Abschnitt `[lager]`, Dialoge `dcl/lager.dcl`.

## Ziel und Datenfluss

Das RFQ-Programm (eigenes Repo) erzeugt das Ausschreibungsdokument. Die Makros
liefern ihm die technischen Daten des Lagers aus der Zeichnung, als EINE
JSON-Datei. Mapping auf das RFQ-Schema, Abgleich mit Handwerten und Darstellung
sind Sache des RFQ-Projekts.

```
BricsCAD (LISP)                                         RFQ-Repo
LG_GESCHOSS / LG_BEREICH / LG_REIHE / LG_GANG
        --LAGER_EXPORT-->  DXFM_RESULTS/<dwg>_lager.json  -->  Dokument
        ^ Regelprofil cfg/stahlbau/regelwerk/<Land>.json (LagerPruefung.lsp, noch nicht im Export)
```

Grundsatz: jede fachliche Regel und jeder Kennwert wird genau einmal
implementiert, in LISP (`LagerInsert.lsp` Abschnitt EXPORT, Regeln in
`LagerPruefung.lsp`). Es gibt keinen Python-Schritt mehr (die fruehere
Overlay-YAML `lib/lager_yaml_export.py` und `LAGER_HAND_YAML` sind entfernt).

## JSON-Schnittstelle (`format` = `ssg-lager`, `version` = 2)

Einheiten mm, mm2, Grad; Koordinaten WCS, Nord = +Y. Werte stehen
selbstbeschreibend drin (`"belag_art": "spanplatte"`, keine Index-Codes).
Nicht-ASCII-Zeichen in Texten werden als `\uXXXX` geschrieben.

**Regel fuer fehlende Werte:** `null` heisst ausschliesslich "fehlt, muesste
eingegeben werden" (offener Punkt, z.B. `kennwerte.lichte_hoehe_mm` des obersten
Geschosses ohne Vorgabe). Was nicht zutrifft, wird WEGGELASSEN: Belag,
Gitterrost, Gitterkorb und `ohne_absturzsicherung_mm2` auf Hallenboden,
`gitterkorb` an Reihen ohne Korb, `bereich`/`bereich_handle`/`ausrichtung` an frei
gesetzten Reihen und Gaengen, `lichte_hoehe_vorgabe_mm` ohne Vorgabe.

```
{
  "format": "ssg-lager", "version": 2, "zeichnung", "erzeugt", "land",
  "einheiten": {"laenge": "mm", "flaeche": "mm2", "winkel": "grad"},
  "koordinaten": "WCS, Nord = +Y",
  "lager":     { geschosse, bereiche, grundriss_max{laenge_mm, breite_mm},
                 summe_alle_geschosse{reihen, regallaenge_mm, regalgrundflaeche_mm2,
                   regalrohrlaenge_mm, haengeebenen[], gaenge{}, belagsflaeche_mm2,
                   gitterrostflaeche_mm2, gitterkorb{}, ohne_absturzsicherung_mm2} },
  "geschosse": [ { nr, bezeichnung, id, handle, layer, hoehe_belag_mm, konstr_hoehe_mm,
                   lichte_hoehe_vorgabe_mm (nur wenn eingegeben), belag_art, personen, brandgefaehrdung,
                   kontur{handle, z, punkte[[x,y]...], flaeche_mm2, umfang_mm, bbox},
                   kennwerte{...}, herkunft{<kennwert>: {formel, quelle}} } ],
  "bereiche":  [ { nr, id, handle, layer, geschoss, gangbreite_mm, regaltiefe_mm,
                   reihen_je_gang, trolleyschienen_je_gang, quergang_abstand_mm, quergang_breite_mm,
                   richtung_grad, haengeebenen[], belag, unter_reihe, gitterkorb_hoehe_mm,
                   randgang_mm{n,o,s,w}, restbreite_mm, anzahl_reihen, anzahl_gaenge, kontur{} } ],
  "reihen":    [ { id, handle, layer, geschoss, bereich, bereich_handle, quelle, laenge_mm,
                   tiefe_mm, haengeebenen[{schienenhoehe_mm, warenlaenge_mm, freiraum_unter_mm}],
                   start, ende, mitte, winkel_grad, ecken[4], flaeche_mm2, unter_reihe,
                   gitterkorb{hoehe_mm, bodenflaeche_mm2, offen_laengs_mm, offen_stirn_mm,
                              seitenflaeche_mm2} (nur bei Gitterkorb) } ],
  "gaenge":    [ { id, handle, layer, geschoss, bereich, bereich_handle, quelle, laenge_mm,
                   breite_mm, art, belag, start, ende, mitte, winkel_grad, ecken[4], flaeche_mm2,
                   ausrichtung ("laengs"/"quer" zur Reihenrichtung des Bereichs) } ],
  "warnungen": [ ... ]
}
```

`geschosse` ist nach Belagshoehe sortiert (von unten nach oben). `start`/`ende`/
`mitte` sind 3D (Z der Einfuegung), `ecken` sind die vier Ecken des Grundrisses
(2D), Kante 1-2 und 3-4 laengs, 2-3 und 4-1 an den Stirnseiten.
`kennwerte` je Geschoss: `lichte_hoehe_mm` (wirksamer Wert: Vorgabe oder
berechnet), `buehne` (true/false), `huelle` (Grundriss dieses Geschosses),
`bereiche`, `reihen`, `regallaenge_mm`, `regalgrundflaeche_mm2`,
`regalrohrlaenge_mm`, `haengeebenen` (je Schienenhoehe/Warenlaenge: `reihen`,
`regallaenge_mm`), `gaenge` (je Art gang/quergang/randgang: `anzahl`,
`laenge_mm`, `flaeche_mm2`, `anzahl_quer`, `nach_breite[]`),
`belagsflaeche_mm2`, `gitterrostflaeche_mm2`, `gitterkorb` (Summen),
`ohne_absturzsicherung_mm2`. Formeln: Abschnitt "Kennwerte <- Zeichnung".
Alles unter `lager.summe_alle_geschosse` ist ueber ALLE Geschosse summiert.
Trolley-Schienen werden noch nicht berechnet (`trolleyschienen_je_gang` ist nur
die Eingabe am Bereich).

`warnungen` enthaelt neben fehlenden Daten Plausibilitaetshinweise je Geschoss
(`lg-plausibilitaet`; Grenzwerte aus dem Regelprofil, `lg-plausibilitaet-grenzen`):
Buehne ohne Konstruktionshoehe, Reihen ohne Absturzsicherung auf einer Buehne,
lichte Hoehe unter `lichte_hoehe.verkehrsweg_min`, Gaenge schmaler als
`gang.breite_nebengang_min`, `art` gang quer zur Reihenrichtung, Gang direkt
neben einem Randgang, kein Freiraum unter der Ware, oberste Schiene nicht unter
der lichten Hoehe. Sie aendern keine Werte.

Erzeugt von `LAGER_EXPORT` (Menue Lager -> Export Lager-JSON), Beispiel:
`tests/output/lager_tests_lager.json` nach `TEST_LAGER`.

## Bloecke und Attribute

Alle Bloecke tragen `ID`, `GESCHOSS`, `LAYER`. Masse in mm, Winkel in Grad,
Werte selbstbeschreibend (keine Index-Codes). Verknuepfungen als XDATA
(App `SSG_LG`, Paare `1000 schluessel` + `1005 handle`/`1000 text`).

| Block | Geometrie | Attribute | XDATA |
|---|---|---|---|
| `LG_GESCHOSS` | Kopfsymbol unten links an der Belagskontur | `NR`, `BEZEICHNUNG`, `HOEHE_BELAG_mm`, `KONSTR_HOEHE_mm`, `LICHTE_HOEHE_mm` (leer = berechnet), `BELAG_ART` (`spanplatte`/`gitterrost`/`hallenboden`), `PERSONEN`, `BRANDGEFAEHRDUNG` | `kontur` -> Polylinie; Kontur: `besitzer`, `rolle` |
| `LG_BEREICH` | Symbol mit Pfeil in Reihenrichtung | `NR`, `GANGBREITE_mm`, `REGALTIEFE_mm`, `REIHEN_JE_GANG` (1/2), `SCHIENEN_JE_GANG` (Trolley-Schienen, noch nicht ausgewertet), `QUERGANG_ABSTAND_mm` (0 = keine), `QUERGANG_BREITE_mm`, `RICHTUNG`, `HAENGEEBENEN`, `BELAG`, `RANDGANG_N_mm`/`_O_`/`_S_`/`_W_` (0 = keiner), `UNTER_REIHE` (`gitterrost`/`gitterkorb`/`keine`, Absturzsicherung unter den Reihen, nur auf Buehnen), `GITTERKORB_HOEHE_mm`, `RESTBREITE_mm` (Ergebnis) | `kontur` -> Polylinie |
| `LG_REIHE_<L>_<T>` | Rechteck L x T um die Schienenlinie, Einfuegepunkt = Reihenanfang | `LAENGE`, `TIEFE_mm`, `HAENGEEBENEN` (je Ebene ein Regalrohr), `BEREICH`, `QUELLE` (`auto`/`auto_geaendert`/`manuell`) | `bereich` -> LG_BEREICH (nur Auto-Fuellung) |
| `LG_GANG_<L>_<B>_<BELAG>` | Rechteck L x B um die Gangachse + Schraffur je Belag (`lager.json belag_schraffur`, Layer 0/VONBLOCK; `hallenboden` ohne) | `LAENGE`, `BREITE_mm`, `ART` (`gang`/`quergang`/`randgang`), `BELAG`, `BEREICH`, `QUELLE` (`auto`/`auto_geaendert`/`manuell`) | `bereich` (Auto-Fuellung und manuelle Gaenge im Bereich) |

`HAENGEEBENEN` = `Schienenhoehe/Warenlaenge;...` ueber Belag, oberste zuerst,
z.B. `2300/1200;1100/1100`. Die Definitionen `LG_REIHE_*`/`LG_GANG_*` werden je
Geometrie wiederverwendet; die Werte stehen in den Attributen der Referenz.

### Geschosse und Layer

Layer je Geschoss: Basis aus `cfg/layer.cfg [lager]` + `_G<nr>`
(`LG_Reihe_G2`). `LG_GESCHOSS_AKTIV` friert die Layer der uebrigen Geschosse,
weil die 2D-Grundrisse uebereinander liegen. Neue Objekte bekommen das aktive
Geschoss; ohne aktives Geschoss entscheidet die Kontur, in der sie liegen. In
2D (alle Konturen auf Z = 0) ist eine Lage in mehreren Konturen nicht
eindeutig -> Rueckfrage bzw. Export-Warnung; in 3D entscheidet Z.

Jede Kontur gehoert genau einem Block. Wird eine schon vergebene Kontur
gewaehlt (z.B. dieselbe Halle fuer mehrere Geschosse), wird sie kopiert.

Der parametrische BricsCAD-Block `goh_rack` (frueher als Bestand mitgezaehlt)
wird nicht mehr unterstuetzt: Regale gibt es nur noch als `LG_REIHE_*`.

### Geschoss kopieren (`LG_GESCHOSS_KOPIEREN`)

Obergeschosse gleichen meist dem Geschoss darunter. Dialog `lg_geschoss_kopie`:

- Quelle: Vorgabe ist das oberste Geschoss. Damit wird ein weiteres Geschoss
  nachtraeglich angehaengt, z.B. G3 -> G4.
- Anzahl.
- Geschosshoehe je Kopie: Vorgabe ist der Abstand zum Geschoss darunter, sonst
  lichte Hoehe + Konstruktion.
- Belag.
- Versatz X/Y je Kopie: 0 = deckungsgleich. In einer 3D-Zeichnung (Konturen auf
  Belagshoehe) wandert die Kopie zusaetzlich in Z.

Ein BricsCAD-KOPIEREN taugt nicht. Die XDATA-Verweise `kontur`/`besitzer`/`bereich`
zeigten dann weiter auf die Originale, und GESCHOSS, Layer und IDs blieben die alten.
Stattdessen entsteht jedes Objekt ueber die normalen Einfuegefunktionen neu:

- Geschoss und Bereiche mit kopierter Kontur; die Bereiche ohne Fuellung
  (`lg-bereich-block-anlegen`).
- Reihen und Gaenge 1:1 aus der Quelle (`lg-linie-einfuegen`). Es wird nicht neu
  gefuellt, damit Handaenderungen (`auto_geaendert`, manuelle Reihen/Gaenge) erhalten
  bleiben.
- Ist im Dialog ein Belag gewaehlt, bekommen ALLE Gaenge und Bereiche des neuen
  Geschosses ihn, inklusive Schraffur - auch von Hand gesetzte Rand- und
  Sondergaenge (`lg-kopie-belag`).

### Auto-Fuellung (`lg-fuellung-berechnen`)

Die Kontur wird in ein lokales System gedreht (Reihen entlang +X, `RICHTUNG`;
Vorgabe = Richtung der laengsten Konturkante). Quer dazu wird ab Unterkante ein
Modul nach dem anderen gelegt, nur volle Module:

- 2 Reihen je Gang: `Reihe | Gang | Reihe`, benachbarte Module Ruecken an Ruecken
- 1 Reihe je Gang: `Reihe | Gang`

Ein Streifen ist dort belegbar, wo Unter-, Mittel- und Oberkante in der Kontur
liegen (konkave Konturen werden korrekt beschnitten). Quergaenge: Luecken der
Breite `QUERGANG_BREITE_mm` nach je `QUERGANG_ABSTAND_mm`, ueber alle Reihen
ausgerichtet; keine Luecke am Reihenende, wenn dahinter kein Mindeststueck mehr
passt. Hauptgaenge laufen durch. Der Rest quer zu den Reihen steht in
`RESTBREITE_mm`.

**Bereich bearbeiten: aktualisieren statt ueberschreiben.** Was eingezeichnet ist,
bleibt stehen. Geaenderte Werte ohne Geometrie werden auf ALLE vorhandenen Kinder
uebertragen (`lg-bereich-attribute-uebertragen`): `BELAG` -> jeder Gang wird mit dem
neuen Belag an derselben Stelle neu aufgebaut, `HAENGEEBENEN` -> Attribut jeder
Reihe. Nur wenn sich ein Geometrie-Wert aendert (`lg-bereich-geometrie-geaendert-p`:
Gangbreite, Regaltiefe, Reihen je Gang, Quergaenge, Richtung, Randgang-Breiten),
fragt der Befehl "Bereich neu berechnen?" (Vorgabe Ja; ohne Aenderung Vorgabe
Nein - so laesst sich ein Bereich auch bewusst neu berechnen).

Die Neuberechnung (`lg-bereich-fuellen`) ersetzt nur die automatisch erzeugten
Kinder (`QUELLE=auto`). Sperre sind ALLE von Hand eingefuegten (`manuell`) und
geaenderten (`auto_geaendert`) Reihen und Gaenge des Geschosses
(`lg-von-hand-auf-geschoss`) - auch solche eines anderen Bereichs oder nur
teilweise in der Kontur. Sie werden aus Reihen, Haupt-, Quer- UND Randgaengen
ausgeschnitten (`lg-randgang-stuecke`): ein manueller Gang ersetzt den Randgang
dort, wo er liegt, statt von ihm ueberlagert zu werden. Von Hand geloeschte
automatische Objekte entstehen bei der Neuberechnung neu.

**Randgaenge** (`RANDGANG_N/O/S/W_mm`, Nord = +Y Welt): jede Konturkante bekommt
den Randgang ihrer Himmelsrichtung (Aussennormale, auf N/O/S/W eingerastet,
45 Grad zaehlt zu N/S) als Rechteck von der Kante nach innen - auch bei L-Form
entlang der echten Kanten (dort bekommt z.B. auch die Stufenkante den
Nord-Randgang; Ausnahmen per `LG_GANG`). Ecken: N/S-Randgaenge besitzen sie;
an konvexen Ecken wird der O/W-Randgang gekuerzt, an einspringenden Ecken der
N/S-Randgang verlaengert (sonst bliebe ein freies Quadrat). Randgaenge an der
Unter-/Oberkante der Huelle verschieben den Modulstapel, an der linken/rechten
den Bezug der Quergaenge; Stufenkanten mitten im Stapel kappen nur die
betroffenen Reihen. Nicht rechtwinklige Ecken sind eine Naeherung.

**Sperrflaechen**: Randgaenge sowie von Hand eingefuegte und geaenderte Reihen und
Gaenge werden aus Reihen, Haupt- und Quergaengen ausgeschnitten - exakt ueber den
Band-Clip des Streifens (`ssg-poly-band-x`), Reststuecke unter der
Mindestlaenge fallen weg. Eine von Hand eingefuegte Reihe (`LG_REIHE`) oder ein
Gang (`LG_GANG`), dessen Mitte in einem Bereich liegt, wird mit ihm verknuepft.

**Von Hand Gesetztes loest KEINE Neuberechnung aus.** Beim Einfuegen und
Bearbeiten (`LG_REIHE`, `LG_GANG`, `LG_EDIT` einer Reihe/eines Gangs) schneidet das
Objekt nur seine Flaeche aus den ueberdeckten Objekten heraus
(`lg-sperre-anwenden`, Kern `lg-linie-zuschnitt`); die Reste behalten ihre Attribute.
Geschnitten wird nur, was rangniedriger ist (`lg-quelle-rang`: `auto` <
`auto_geaendert` < `manuell`) - ein manuelles Objekt schneidet aus automatischen und
geaenderten, ein geaendertes nur aus automatischen, manuelle untereinander nie. Alles
andere bleibt, wie der Anwender es hinterlassen hat: von Hand geloeschte Objekte
kommen nicht zurueck. Wird ein manueller Gang verkleinert oder geloescht, bleibt die
Luecke bis zur naechsten ausdruecklichen Neuberechnung (Doppelklick auf den
Bereich, OK).

`LG_GANG` zeichnet einen Gang entweder als Linie (Gangmitte, Breite aus dem
Dialog) oder ueber die Option `Rechteck` als Flaeche. Beim Rechteck
ergeben sich Lage und Breite aus der Flaeche, man muss sie also vorher nicht
kennen: die laengere Seite ist die Gangrichtung, die kuerzere die Breite (auf
ganze mm). Die Rundung verschiebt nur die Laengsseite gegenueber der ersten
gezeichneten Ecke - die Kante, an der man ansetzt (z.B. buendig an einer
Regalreihe), bleibt exakt liegen, sonst wuerde der Gang die Reihe um Bruchteile
eines mm ueberdecken und sie beim Zuschnitt entfernen; ebenso beginnt der Gang an
der Querseite der ersten Ecke (`lg-gang-aus-ecken`). Gezeichnet wird mit dem echten BricsCAD-Befehl RECHTECK
(`lg-rechteck-zeichnen`) - mit allen seinen Optionen (Abmessungen, Flaeche,
Drehung, Objektfang); ein gedrehtes Rechteck ergibt einen schraeg liegenden Gang.
Die gezeichnete Polylinie wird ausgewertet (`lg-rechteck-ecken-aus-poly`) und
wieder geloescht; mit Fase oder Rundung gezeichnete Flaechen werden abgelehnt.
Nach jedem Rechteck startet RECHTECK erneut, Enter ohne Rechteck beendet. Im Block
entsteht derselbe `LG_GANG_*` wie bei der Linie.

**Schraffur**: steckt in der Gang-Blockdefinition (Belag im Blocknamen), Muster
aus `lager.json belag_schraffur` - `spanplatte` ANSI31, `gitterrost` GRID,
`hallenboden` keine. Unbekannter Belag/Muster -> Meldung, Gang ohne Schraffur.
Reihen bleiben unschraffiert. Altbestand: fehlen einer vorhandenen
Blockdefinition ATTDEFs des Schemas, definiert `lg-blockdef` sie neu und
uebertraegt sie per `_.ATTSYNC` auf die Referenzen.

## Darstellung in der Zeichnung

- **Absturzsicherung unter den Reihen** (nur Buehnen): je Reihe eine
  Schraffur nach `UNTER_REIHE` - `gitterrost` und `gitterkorb` mit eigenem
  Muster und eigener Farbe (`lager.json darstellung.unter_reihe`). Der
  Gitterkorb bekommt zusaetzlich seine seitliche Abgrenzung als dicke Linie
  (`rand.farbe`, `rand.breite_mm`), und zwar NUR an den offenen Kanten: wo eine
  andere Reihe anliegt (z.B. Ruecken an Ruecken), wird keine Abgrenzung
  gezeichnet (`lg-sicherung-geometrie`, gleiche Regel wie `offen_laengs_mm`).
- Die Objekte liegen lose auf `LG_Sicherung_G<n>` (XDATA `rolle=sicherung`,
  wird mit dem Geschoss gefroren) und werden bei jedem Neuaufbau des Geschosses
  komplett ersetzt - automatisch nach Bereich fuellen/bearbeiten (Doppelklick),
  Reihe/Gang bearbeiten, `LG_REIHE`/`LG_GANG`, Geschoss bearbeiten/kopieren.
- **Farben**: `darstellung.reihe.farbe` (Regalreihen), `belag_schraffur.<belag>.farbe`
  (Gangschraffur); ACI-Nummer oder `"r,g,b"`, `null` = VONLAYER/VONBLOCK.
- **`LG_DARSTELLUNG`** (Menue Lager -> Darstellung aktualisieren): liest
  `lager.json` neu, passt alle vorhandenen `LG_REIHE_*`/`LG_GANG_*`-Definitionen
  an und zeichnet die Sicherung aller Geschosse neu - noetig nach Loeschen von
  Hand oder nach Aenderungen in `lager.json`.

## Kennwerte <- Zeichnung

Reine Kerne in `LagerInsert.lsp` (getestet in `tu-tests-lager`). Jeder
Geschoss-Kennwert steht mit Formel und Quelle unter `herkunft`.

| Kennwert | Quelle / Formel |
|---|---|
| `lichte_hoehe_mm` | `LICHTE_HOEHE_mm`, sonst Belag darueber - Konstruktionshoehe darueber - eigener Belag; oberstes Geschoss nur mit Vorgabe (sonst `null` + Warnung) |
| `buehne` | `BELAG_ART` gesetzt und nicht `hallenboden`. Ohne Buehne: kein Belag, kein Gitterrost, kein Gitterkorb |
| `regallaenge_mm`, `regalgrundflaeche_mm2`, `regalrohrlaenge_mm` | Summe `LAENGE`, `LAENGE x TIEFE_mm`, `LAENGE x Anzahl Haengeebenen` der Reihen des Geschosses |
| `ohne_absturzsicherung_mm2` | Buehne: Summe `LAENGE x TIEFE_mm` der Reihen mit `UNTER_REIHE = keine` |
| `haengeebenen[].freiraum_unter_mm` (Reihe/Bereich) | Schienenhoehe - Warenlaenge - naechsttiefere Schienenhoehe (unterste: Belag); <= 0 = Ware stoesst an (`lg-ebenen-freiraum`) |
| `gaenge[].ausrichtung` | Gangwinkel gegen `RICHTUNG` des Bereichs, Abweichung < 45 Grad = laengs (`lg-ausrichtung`) |
| `haengeebenen[]` | je (Schienenhoehe, Warenlaenge): Anzahl Reihen und Summe `LAENGE`, nach Schienenhoehe absteigend (`lg-haengeebenen-summen`) |
| `gaenge` | je `ART` (gang/quergang/randgang, auch manuelle): Anzahl, Summe `LAENGE`, Summe `LAENGE x BREITE_mm` (`lg-gaenge-je-art`) |
| `belagsflaeche_mm2` | Summe `LAENGE x BREITE_mm` der Gaenge mit Belag != gitterrost; ohne Gangflaechen: Konturflaeche - Reihengrundflaeche |
| `gitterrostflaeche_mm2` | Gaenge mit Belag gitterrost + Grundflaeche der Reihen mit `UNTER_REIHE = gitterrost` |
| `gitterkorb` (je Reihe und Summe) | Reihen mit `UNTER_REIHE = gitterkorb`: Boden = `LAENGE x TIEFE_mm`; Seiten = offene Kantenlaenge x `GITTERKORB_HOEHE_mm`, getrennt nach Laengs- und Stirnseiten. Offen ist eine Kante, soweit keine Kante einer ANDEREN Reihe desselben Geschosses kollinear darauf liegt (Abstand < 1 mm, z.B. Ruecken an Ruecken; `lg-reihen-offene-kanten`) |
| `kennwerte.huelle` | achsparallele Huelle der Geschosskontur, `laenge_mm` = laengere Seite |
| `lager.grundriss_max` | groesste Laenge/Breite der Geschoss-Huellen (die Geschosse koennen im Plan nebeneinander liegen - eine gemeinsame Huelle waere kein Gebaeudemass) |
| `lager.summe_alle_geschosse` | Summen der Geschoss-Kennwerte; `haengeebenen`/`gaenge` ueber alle zugeordneten Reihen/Gaenge |

`UNTER_REIHE` kommt aus dem verknuepften Bereich; Reihen ohne Bereich (und
Bereiche ohne Attribut, Altbestand) nehmen die Vorgabe `lager.json
bereich.unter_reihe`. `GITTERKORB_HOEHE_mm` ist vorerst ein Attribut am Bereich
und soll spaeter aus den Attributen berechnet werden.

Spaetere Phasen: Gelaender/Bordbrett, Oeffnungen, Treppen, Leitern, Zugaenge
(Phase 2), Schnitte (Phase 3), Fluchtwege (Phase 4/5), Regelwerk-Werte je
Geschoss im Export.

## Regelprofil

`cfg/stahlbau/regelwerk/<LAND>.json`, aufgeloest von `LagerPruefung.lsp`:

```json
{"id": "treppe.schrittmass_min", "art": "min", "einheit": "mm",
 "werte": [{"wert": 590, "quelle": "ASR A1.8", "abschnitt": "4.5", "fassung": "...", "verifiziert": false},
           {"wert": 600, "quelle": "EN ISO 14122-3", "abschnitt": "5", "fassung": "...", "verifiziert": false}]}
```

- `art`: `min` (strengster = groesster), `max` (strengster = kleinster), `wert`.
- `bedingung`: `<schluessel> <op> <wert>` (`=`, `<=`, `>=`, `<`, `>`) gegen einen
  Kontext (z.B. `brandgefaehrdung`, `absturzhoehe`, `personen`). Fehlt der
  Schluessel im Kontext, wird der Eintrag konservativ einbezogen.
- `tabelle` + `tabellen_schluessel`: Wert der ersten Zeile `[bis, wert]`, die den
  Kontextwert abdeckt (Fluchtwegbreite nach Personen).
- `erbt_von`: Laenderprofil erbt alle Regeln, eigene Records mit gleicher `id`
  ersetzen sie. `SK.json`/`PL.json` sind Gerueste (`gepflegt: false` -> Warnung).
- `LG_REGELN` zeigt alle Regeln mit Ergebnis und Protokoll (welche Quelle gewann).

**Alle Startwerte stehen auf `verifiziert: false`.** Wert, Abschnitt und
Fassung muessen gegen die Originaltexte (ASR A1.8, A2.1, A2.3, DGUV Regel
108-007, EN ISO 14122-3/-4) geprueft werden; besonders unsicher sind die
DGUV-Gangbreiten und die Abschnittsnummern.

## Stand

| Phase | Inhalt | Stand |
|---|---|---|
| 0 | Regelprofil + Resolver, Schema (dieses Dokument), Layer, Sprach-Keys, Menue, Laden | erledigt, Regelwerte unverifiziert |
| 1 | Geschoss, aktives Geschoss, Bereich + Auto-Fuellung, Einzelreihe, Edit, `LAGER_EXPORT` als Lager-JSON mit Kennwerten und Herkunft, Gitterkorb/Gitterrost unter den Reihen | erledigt (2D) |
| 1a | Regelwerk-Werte (aufgeloest je Geschoss) im Lager-JSON; Gitterkorb-Hoehe aus den Attributen berechnen | offen |
| 2 | Gelaender/Bordbrett aus Kontur, Kanten-Ausnahmen, Oeffnungen, Treppe (Auslegung nach Profil), Leiter | offen |
| 3 | Schema-Schnitt, 3D-Varianten | offen |
| 4 | `LAGER_PRUEFEN`, Fluchtweg (gezeichnet), Verstoss-Marker, Nachweis mit Regelpruefung | offen |
| 5 | automatische Fluchtweganalyse | offen |
| 6 | SK/PL-Profile, Kapazitaet, Kopplung Geruest, Stuecklisten-Klassen | offen |

## Tests

- `tests/test_unit.lsp`: `tu-tests-poly` (Polygon-Helfer in `ssg_core.lsp`),
  `tu-tests-lager` (Fuellung, Geschosszuordnung, JSON-Schreiber, Kennwerte,
  offene Kanten/Gitterkorb, Feldpruefung, Regelprofil).
- `tests/test_lager.lsp` (`TEST_LAGER`, `alltests.json`): Ablauf in einer
  Zeichnung inkl. Neuberechnung, Reihen-Edit, Export (Schema, Geometrie,
  Kennwerte, Gitterkorb), Geschoss-Kopie und `LG_REGALE`.