[CHANGE] Lager-Export nur noch als JSON mit Kennwerten, Gitterkorb unter Regalreihen
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Simon HenschandClaude Opus 5.5 committed
1 parent
3c729ea604
commit
d2729140ff
22 files changed
+1068
-1089
No files matched your search
+50
-11
@@ -5,16 +5,15 @@
|
||||
;; - zwei Geschosse auf derselben 2D-Kontur (EG Hallenboden, OG 3100 mm)
|
||||
;; - einen Lagerbereich 10000 x 6000 im OG mit Auto-Fuellung
|
||||
;; und prueft Bloecke, Attribute, Layer, Neuberechnung (keine Verdopplung),
|
||||
;; den Neuaufbau einer geaenderten Reihe, die Rohdaten von LAGER_EXPORT und
|
||||
;; die Zaehlung von LG_REGALE.
|
||||
;; den Neuaufbau einer geaenderten Reihe, die JSON-Daten von LAGER_EXPORT
|
||||
;; (inkl. Kennwerte und Gitterkorb) und die Zaehlung von LG_REGALE.
|
||||
;;
|
||||
;; Aufruf in BricsCAD:
|
||||
;; (load (strcat (getenv "DXFMAKRO") "/tests/test_lager.lsp"))
|
||||
;; TEST_LAGER
|
||||
;;
|
||||
;; Speichert tests/output/lager_results.json (Konvention test_run_all)
|
||||
;; und tests/output/lager_tests_lager_raw.json (Eingabe fuer
|
||||
;; lib/lager_yaml_export.py).
|
||||
;; und tests/output/lager_tests_lager.json (Beispiel der Export-Datei).
|
||||
;; ============================================================
|
||||
|
||||
(setq *tlg-pass* 0 *tlg-fail* 0 *tlg-fails* '())
|
||||
@@ -80,7 +79,11 @@
|
||||
(mapcar '(lambda (ed) (cons (cdr (assoc 2 ed)) T))
|
||||
(vl-remove-if-not '(lambda (ed) (= (cdr (assoc 0 ed)) "ATTDEF")) (lg-blockdef-objekte bname))))
|
||||
|
||||
(defun lager:tests ( / k0 k1 g0 g1 kb bereich reihen gaenge r0 neu raw daten pfad f
|
||||
;; Geschoss-Objekt Nr. nr aus den geparsten Export-Daten.
|
||||
(defun tlg-export-geschoss (daten nr)
|
||||
(vl-some '(lambda (g) (if (= (ssg-json-get g "nr") nr) g)) (ssg-json-get daten "geschosse")))
|
||||
|
||||
(defun lager:tests ( / k0 k1 g0 g1 kb bereich reihen gaenge r0 neu raw daten pfad f eg0 eg1 kr
|
||||
kb2 b2 kinder mg mg2 hg alt eb
|
||||
r1 gg1 n-alt g2 r2 gg2 ids b2k n-kinder bb rg rk zl
|
||||
b3 rh3 mg3 ge3 ag3 n3 mr3 alt3)
|
||||
@@ -159,23 +162,36 @@
|
||||
(tlg-eq "reihenzahl gleich" 8 (length (lg-alle-bloecke "LG_REIHE_*")))
|
||||
(tlg-eq "geaenderte reihe bleibt kind" T (if (member neu (lg-bereich-kinder bereich)) T nil))
|
||||
|
||||
;; --- Rohdaten fuer LAGER_EXPORT ---
|
||||
;; --- JSON-Daten von LAGER_EXPORT ---
|
||||
(setq raw (lg-export-json))
|
||||
(setq daten (ssg-json-parse raw))
|
||||
(tlg-eq "export format" '("ssg-lager" 2) (list (ssg-json-get daten "format") (ssg-json-get daten "version")))
|
||||
(tlg-eq "export geschosse" 2 (length (ssg-json-get daten "geschosse")))
|
||||
(tlg-eq "export bereiche" 1 (length (ssg-json-get daten "bereiche")))
|
||||
(tlg-eq "export reihen" 8 (length (ssg-json-get daten "reihen")))
|
||||
(tlg-eq "export land" "DE" (ssg-json-get daten "land"))
|
||||
(tlg-eq "export konturflaeche" 6.0e7
|
||||
(ssg-json-get (car (vl-remove-if-not '(lambda (g) (= (ssg-json-get g "nr") 1))
|
||||
(ssg-json-get daten "geschosse")))
|
||||
"kontur_flaeche_mm2"))
|
||||
(setq eg1 (tlg-export-geschoss daten 1) eg0 (tlg-export-geschoss daten 0))
|
||||
(tlg-eq "export konturflaeche" 6.0e7 (ssg-json-get (ssg-json-get eg1 "kontur") "flaeche_mm2"))
|
||||
(tlg-eq "export konturpunkte" 4 (length (ssg-json-get (ssg-json-get eg1 "kontur") "punkte")))
|
||||
(tlg-eq "export haengeebenen"
|
||||
'((("schienenhoehe_mm" . 2300) ("warenlaenge_mm" . 1200))
|
||||
(("schienenhoehe_mm" . 1100) ("warenlaenge_mm" . 1100)))
|
||||
(ssg-json-get (vl-some '(lambda (r) (if (= (ssg-json-get r "laenge_mm") 4000) r))
|
||||
(ssg-json-get daten "reihen"))
|
||||
"haengeebenen"))
|
||||
(tlg-eq "export ecken" 4 (length (ssg-json-get (car (ssg-json-get daten "reihen")) "ecken")))
|
||||
(tlg-eq "export ende" T (if (ssg-json-get (car (ssg-json-get daten "reihen")) "ende") T))
|
||||
;; Kennwerte: Regallaenge = Summe der Reihen, lichte Hoehe EG = 3100 - 150 - 0
|
||||
(tlg-eq "export regallaenge G1" (tlg-summe-attr (tlg-gs "LG_REIHE_*" 1) "LAENGE")
|
||||
(ssg-json-get (ssg-json-get eg1 "kennwerte") "regallaenge_mm"))
|
||||
(tlg-eq "export haengeebenen G1" 2 (length (ssg-json-get (ssg-json-get eg1 "kennwerte") "haengeebenen")))
|
||||
(tlg-eq "export lichte G0" 2950 (ssg-json-get (ssg-json-get eg0 "kennwerte") "lichte_hoehe_mm"))
|
||||
(tlg-eq "export G0 keine buehne" nil (ssg-json-get (ssg-json-get eg0 "kennwerte") "buehne"))
|
||||
(tlg-eq "export G1 herkunft" T (if (ssg-json-get (ssg-json-get eg1 "herkunft") "gitterrostflaeche_mm2") T))
|
||||
(tlg-eq "export G1 unter gitterrost" T
|
||||
(vl-every '(lambda (r) (= (ssg-json-get r "unter_reihe") "gitterrost")) (ssg-json-get daten "reihen")))
|
||||
(tlg-eq "export lager regallaenge" (ssg-json-get (ssg-json-get eg1 "kennwerte") "regallaenge_mm")
|
||||
(ssg-json-get (ssg-json-get daten "lager") "regallaenge_mm"))
|
||||
|
||||
;; --- Randgaenge Nord + Sued, Schraffur je Belag ---
|
||||
(setq kb2 (tlg-rechteck 20000.0 0.0 30000.0 6000.0))
|
||||
@@ -243,7 +259,29 @@
|
||||
(length (vl-remove-if-not '(lambda (g) (= (ssg-json-get g "quelle") "manuell"))
|
||||
(ssg-json-get daten "gaenge"))))
|
||||
|
||||
(setq pfad (strcat (getenv "DXFMAKRO") "/tests/output/lager_tests_lager_raw.json"))
|
||||
;; --- Gitterkorb unter den Reihen des ersten Bereichs (G1) ---
|
||||
(lg-attribute-setzen bereich (list (cons "UNTER_REIHE" "gitterkorb") (cons "GITTERKORB_HOEHE_mm" "500")))
|
||||
(setq raw (lg-export-json) daten (ssg-json-parse raw))
|
||||
(setq kr (vl-remove-if-not '(lambda (r) (= (ssg-json-get r "unter_reihe") "gitterkorb"))
|
||||
(ssg-json-get daten "reihen")))
|
||||
(tlg-eq "gitterkorb: reihen" (length (vl-remove-if-not '(lambda (k) (wcmatch (cdr (assoc 2 (entget k))) "LG_REIHE_*"))
|
||||
(lg-bereich-kinder bereich)))
|
||||
(length kr))
|
||||
(tlg-eq "gitterkorb: seitenflaeche > 0" T
|
||||
(vl-every '(lambda (r) (> (ssg-json-get (ssg-json-get r "gitterkorb") "seitenflaeche_mm2") 0)) kr))
|
||||
;; Ruecken an Ruecken: es sind nicht alle Laengsseiten offen
|
||||
(tlg-eq "gitterkorb: anliegende kanten zu" T
|
||||
(< (apply '+ (mapcar '(lambda (r) (ssg-json-get (ssg-json-get r "gitterkorb") "offen_laengs_mm")) kr))
|
||||
(* 2.0 (apply '+ (mapcar '(lambda (r) (ssg-json-get r "laenge_mm")) kr)))))
|
||||
(setq eg1 (tlg-export-geschoss daten 1))
|
||||
(tlg-eq "gitterkorb: kennwerte G1" (length kr)
|
||||
(ssg-json-get (ssg-json-get (ssg-json-get eg1 "kennwerte") "gitterkorb") "reihen"))
|
||||
(tlg-eq "gitterkorb: bereich" "gitterkorb"
|
||||
(ssg-json-get (vl-some '(lambda (b) (if (= (ssg-json-get b "nr") (atoi (tlg-attr bereich "NR"))) b))
|
||||
(ssg-json-get daten "bereiche"))
|
||||
"unter_reihe"))
|
||||
|
||||
(setq pfad (strcat (getenv "DXFMAKRO") "/tests/output/lager_tests_lager.json"))
|
||||
(if (setq f (open pfad "w")) (progn (princ raw f) (close f)))
|
||||
|
||||
;; --- Geschoss kopieren: G1 (3100, Spanplatte) -> G2, G3 mit Gitterrost ---
|
||||
@@ -296,6 +334,7 @@
|
||||
(tlg-eq "kopie: hallenboden bleibt" 1 (length (tlg-nur gg2 "LG_GANG_2000_1500_HALLENBODEN")))
|
||||
(tlg-eq "kopie: bereich belag" T
|
||||
(vl-every '(lambda (b) (= (tlg-attr b "BELAG") "gitterrost")) (tlg-gs "LG_BEREICH" 2)))
|
||||
(tlg-eq "kopie: unter_reihe gitterkorb" 1 (tlg-anzahl-attr (tlg-gs "LG_BEREICH" 2) "UNTER_REIHE" "gitterkorb"))
|
||||
;; Neufuellen einer Kopie laesst die Quelle in Ruhe, manueller Gang bleibt
|
||||
(setq b2k (vl-some '(lambda (b) (if (= (tlg-attr b "RANDGANG_N_mm") "1000") b)) (tlg-gs "LG_BEREICH" 2)))
|
||||
(setq n-kinder (length (lg-bereich-kinder b2k)))
|
||||
|
||||
@@ -1,206 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
test_lager_yaml.py - lib/lager_yaml_export.py (Lagerplanung -> RFQ-Overlay-YAML).
|
||||
|
||||
Laeuft ohne BricsCAD: die Rohdaten sind von Hand nachgestellt, im Format von
|
||||
LAGER_EXPORT (Lisp/LagerInsert.lsp, lg-export-json). Geprueft wird:
|
||||
|
||||
1. levels: Belagshoehen, lichte Hoehe aus dem Geschoss darueber,
|
||||
Haengeebenen (Summe aller Reihen je Schienenhoehe/Warenlaenge),
|
||||
Belag/Gitterrost nur auf Buehnen.
|
||||
2. layout: Bereichsparameter, Ganganzahl/-laenge, Huelle.
|
||||
3. Provenienz: jeder Overlay-Wert hat einen Herkunfts-Eintrag.
|
||||
4. Abgleich gegen cfg/example_goh_storage.yaml: Abweichungen -> Konflikte,
|
||||
null/fehlend -> gefuellt.
|
||||
5. CLI schreibt YAML (wieder einlesbar) und Nachweis-HTML.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
import pytest
|
||||
import yaml
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "lib"))
|
||||
import lager_yaml_export as lye # noqa: E402
|
||||
|
||||
BEISPIEL_YAML = os.path.join(os.path.dirname(os.path.abspath(__file__)),
|
||||
"..", "cfg", "example_goh_storage.yaml")
|
||||
|
||||
EBENEN_EG = [{"schienenhoehe_mm": 2300, "warenlaenge_mm": 1200},
|
||||
{"schienenhoehe_mm": 1100, "warenlaenge_mm": 1100}]
|
||||
EBENEN_OG = [{"schienenhoehe_mm": 2800, "warenlaenge_mm": 1200},
|
||||
{"schienenhoehe_mm": 1400, "warenlaenge_mm": 1200}]
|
||||
|
||||
|
||||
def _reihe(gs, laenge, ebenen, tiefe=700):
|
||||
return {"geschoss": gs, "laenge_mm": laenge, "tiefe_mm": tiefe, "haengeebenen": ebenen,
|
||||
"schienen": 1, "quelle": "auto", "bereich": 1}
|
||||
|
||||
|
||||
def _gang(gs, laenge, breite=1000, art="gang", belag="spanplatte"):
|
||||
return {"geschoss": gs, "laenge_mm": laenge, "breite_mm": breite, "art": art,
|
||||
"belag": belag, "bereich": 1}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def raw():
|
||||
"""Zwei Geschosse: Hallenboden (EG) + Buehne auf 3100 mm, je ein 2-Reihen-Modul."""
|
||||
return {
|
||||
"version": 1, "zeichnung": "test.dwg", "erzeugt": "20261021120000", "einheit": "mm",
|
||||
"land": "DE",
|
||||
"belag_yaml": {"spanplatte": "chipboard", "gitterrost": "grating", "hallenboden": ""},
|
||||
"reihen_als_gitterrost": True,
|
||||
"geschosse": [
|
||||
# bewusst nicht nach Hoehe sortiert - der Export sortiert selbst
|
||||
{"nr": 1, "bezeichnung": "Level 1", "hoehe_belag_mm": 3100, "konstr_hoehe_mm": 150,
|
||||
"lichte_hoehe_mm": None, "belag_art": "spanplatte", "personen": 20,
|
||||
"kontur_flaeche_mm2": 60e6, "kontur_bbox": [0, 0, 10000, 6000]},
|
||||
{"nr": 0, "bezeichnung": "ground floor", "hoehe_belag_mm": 0, "konstr_hoehe_mm": 0,
|
||||
"lichte_hoehe_mm": None, "belag_art": "hallenboden", "personen": 20,
|
||||
"kontur_flaeche_mm2": 60e6, "kontur_bbox": [0, 0, 10000, 6000]},
|
||||
],
|
||||
"bereiche": [
|
||||
{"nr": 1, "geschoss": 0, "gangbreite_mm": 1000, "regaltiefe_mm": 700,
|
||||
"reihen_je_gang": 2, "schienen_je_gang": 1},
|
||||
{"nr": 2, "geschoss": 1, "gangbreite_mm": 1000, "regaltiefe_mm": 700,
|
||||
"reihen_je_gang": 2, "schienen_je_gang": 1},
|
||||
],
|
||||
"reihen": [_reihe(0, 10000, EBENEN_EG), _reihe(0, 10000, EBENEN_EG),
|
||||
_reihe(1, 10000, EBENEN_OG), _reihe(1, 10000, EBENEN_OG)],
|
||||
"gaenge": [_gang(0, 10000), _gang(1, 10000),
|
||||
_gang(1, 700, breite=1200, art="quergang"),
|
||||
_gang(1, 500, breite=1200, art="quergang", belag="gitterrost")],
|
||||
"warnungen": ["Testwarnung"],
|
||||
}
|
||||
|
||||
|
||||
def test_levels_sortiert_und_hoehen(raw):
|
||||
overlay, _ = lye.aggregiere(raw)
|
||||
lv = overlay["levels"]
|
||||
assert [l["floor_elevation_m"] for l in lv] == [0.0, 3.1]
|
||||
assert lv[0]["remark"] == "ground floor"
|
||||
# lichte Hoehe EG = 3100 - 150 (Konstruktion darueber) - 0
|
||||
assert lv[0]["clear_height_m"] == pytest.approx(2.95)
|
||||
# oberstes Geschoss ohne LICHTE_HOEHE_mm -> nicht berechenbar
|
||||
assert "clear_height_m" not in lv[1]
|
||||
|
||||
|
||||
def test_haengeebenen_summe(raw):
|
||||
overlay, _ = lye.aggregiere(raw)
|
||||
eg, og = overlay["levels"]
|
||||
assert eg["hanging_levels"] == [
|
||||
{"rail_height_m": 2.3, "rack_length_m": 20.0, "goods_length_m": 1.2},
|
||||
{"rail_height_m": 1.1, "rack_length_m": 20.0, "goods_length_m": 1.1},
|
||||
]
|
||||
# 2 Reihen a 10 m, oberste Schiene zuerst
|
||||
assert [h["rack_length_m"] for h in og["hanging_levels"]] == [20.0, 20.0]
|
||||
assert og["hanging_levels"][0]["rail_height_m"] == 2.8
|
||||
|
||||
|
||||
def test_belag_nur_auf_buehne(raw):
|
||||
overlay, _ = lye.aggregiere(raw)
|
||||
eg, og = overlay["levels"]
|
||||
assert "walkway" not in eg and "grating" not in eg
|
||||
# Belag: Hauptgang 10 m2 + Quergang Spanplatte 0,84 m2
|
||||
assert og["walkway"]["area_m2"] == pytest.approx(10.8)
|
||||
assert og["walkway"]["spec"] == "chipboard"
|
||||
# Gitterrost: Quergang 0,6 m2 + Reihen 2 x 7 m2
|
||||
assert og["grating"] == pytest.approx(14.6)
|
||||
|
||||
|
||||
def test_belag_ohne_gaenge_aus_kontur(raw):
|
||||
raw["gaenge"] = []
|
||||
overlay, s = lye.aggregiere(raw)
|
||||
og = overlay["levels"][1]
|
||||
# 60 m2 Kontur - 2 x 7 m2 Reihen
|
||||
assert og["walkway"]["area_m2"] == pytest.approx(46.0)
|
||||
assert "Konturflaeche" in s.provenance["levels[1].walkway.area_m2"]["formel"]
|
||||
|
||||
|
||||
def test_layout(raw):
|
||||
overlay, _ = lye.aggregiere(raw)
|
||||
lay = overlay["layout"]
|
||||
assert lay["aisle_width_m"] == 1.0
|
||||
assert lay["rack_rows_per_aisle"] == 2
|
||||
assert lay["rack_depth_m"] == 0.7
|
||||
assert lay["trolley_rails_per_aisle"] == 1
|
||||
assert lay["aisles"] == 1 # Quergaenge zaehlen nicht
|
||||
assert lay["aisle_length_m"] == 10.0
|
||||
assert lay["block_length_m"] == 10.0
|
||||
assert lay["block_width_m"] == 6.0
|
||||
|
||||
|
||||
def test_randgang_im_belag_nicht_in_aisles(raw):
|
||||
# Randgang 10 m x 1 m (Spanplatte) im OG: Belag waechst, aisles bleibt
|
||||
raw["gaenge"].append(_gang(1, 10000, art="randgang"))
|
||||
overlay, s = lye.aggregiere(raw)
|
||||
og = overlay["levels"][1]
|
||||
assert og["walkway"]["area_m2"] == pytest.approx(20.8)
|
||||
assert overlay["layout"]["aisles"] == 1
|
||||
assert overlay["layout"]["aisle_length_m"] == 10.0
|
||||
assert "Randgaenge G1: 10.0 m" in s.provenance["layout.aisles"]["formel"]
|
||||
|
||||
|
||||
def test_unterschiedliche_bereiche_warnen(raw):
|
||||
raw["bereiche"][1]["gangbreite_mm"] = 1200
|
||||
raw["bereiche"].append(dict(raw["bereiche"][1]))
|
||||
overlay, s = lye.aggregiere(raw)
|
||||
assert overlay["layout"]["aisle_width_m"] == 1.2
|
||||
assert any("aisle_width_m" in w for w in s.warnungen)
|
||||
|
||||
|
||||
def test_provenienz_vollstaendig(raw):
|
||||
ausgabe, _ = lye.baue_ausgabe(raw)
|
||||
# hanging_levels: Provenienz je rack_length_m; Schienenhoehe/Warenlaenge
|
||||
# sind der Gruppenschluessel derselben Zeile und stehen in deren Formel.
|
||||
fehlend = [p for p, _ in lye._blaetter(ausgabe)
|
||||
if p not in ausgabe["_provenance"]
|
||||
and not (".hanging_levels[" in p and not p.endswith(".rack_length_m"))]
|
||||
assert fehlend == []
|
||||
assert ausgabe["_warnings"][0] == "Testwarnung"
|
||||
|
||||
|
||||
def test_abgleich_mit_beispiel_yaml(raw):
|
||||
with open(BEISPIEL_YAML, encoding="utf-8") as f:
|
||||
hand = yaml.safe_load(f)
|
||||
konflikte, fuellt = lye.abgleich(lye.aggregiere(raw)[0], hand)
|
||||
pfade = {k["pfad"]: k for k in konflikte}
|
||||
# Hand 4 Ebenen, Zeichnung 2
|
||||
assert "levels" in pfade
|
||||
# Hand 1,0 m Gangbreite = Zeichnung -> kein Konflikt
|
||||
assert "layout.aisle_width_m" not in pfade
|
||||
# Hand 4286 m2, Zeichnung 10,8 m2
|
||||
assert pfade["levels[1].walkway.area_m2"]["hand"] == 4286
|
||||
assert pfade["levels[1].walkway.area_m2"]["abweichung_prozent"] < -99
|
||||
# Hand null -> Zeichnung fuellt
|
||||
gef = {f["pfad"] for f in fuellt}
|
||||
assert "layout.block_length_m" in gef
|
||||
assert "levels[1].grating" in gef
|
||||
|
||||
|
||||
def test_hole_pfad():
|
||||
obj = {"levels": [{"a": 1}, {"walkway": {"area_m2": 5}}]}
|
||||
assert lye._hole(obj, "levels[1].walkway.area_m2") == (True, 5)
|
||||
assert lye._hole(obj, "levels[2].walkway") == (False, None)
|
||||
assert lye._hole(obj, "layout.x") == (False, None)
|
||||
|
||||
|
||||
def test_cli(raw, tmp_path):
|
||||
rp = tmp_path / "x_lager_raw.json"
|
||||
rp.write_text(json.dumps(raw), encoding="cp1252")
|
||||
yp = tmp_path / "x_drawing.yaml"
|
||||
hp = tmp_path / "x_nachweis.html"
|
||||
rc = lye.main([str(rp), str(yp), "--hand", BEISPIEL_YAML, "--nachweis", str(hp)])
|
||||
assert rc == 0
|
||||
daten = yaml.safe_load(yp.read_text(encoding="utf-8"))
|
||||
assert daten["levels"][1]["floor_elevation_m"] == 3.1
|
||||
assert daten["_conflicts"]
|
||||
assert "levels[0].floor_elevation_m" in daten["_provenance"]
|
||||
assert "Lager-Nachweis" in hp.read_text(encoding="utf-8")
|
||||
|
||||
|
||||
def test_cli_fehlende_datei(tmp_path):
|
||||
assert lye.main([str(tmp_path / "fehlt.json"), str(tmp_path / "o.yaml")]) == 2
|
||||
+121
-3
@@ -3409,9 +3409,127 @@
|
||||
(tu-eq "lg-json-wert/rund" "1000" (lg-json-wert 1000.0))
|
||||
(tu-eq "lg-json-wert/str" "\"a\\\"b\"" (lg-json-wert "a\"b"))
|
||||
(tu-eq "lg-json-wert/roh" "[1]" (lg-json-wert (list 'ROH "[1]")))
|
||||
(tu-eq "lg-json-wert/false" "false" (lg-json-wert 'FALSE))
|
||||
(tu-eq "lg-json-wert/umlaut" "\"G\\u00e4\"" (lg-json-wert (strcat "G" (chr 228))))
|
||||
(tu-eq "lg-json-obj" "{\"a\": 1, \"b\": \"x\"}" (lg-json-obj '(("a" . 1) ("b" . "x"))))
|
||||
(tu-eq "lg-json-ebenen" "[{\"schienenhoehe_mm\": 2300, \"warenlaenge_mm\": 1200}]"
|
||||
(cadr (lg-json-ebenen "2300/1200")))
|
||||
(tu-eq "lg-json-wert/obj-arr" "{\"p\": [1, 2.5], \"o\": {\"x\": null}}"
|
||||
(lg-json-wert (list 'OBJ (cons "p" (list 'ARR 1 2.5)) (cons "o" (list 'OBJ (cons "x" nil))))))
|
||||
(tu-eq "lg-json-wert/leer" "[]" (lg-json-wert (list 'ARR)))
|
||||
(tu-eq "lg-j-ebenen" "[{\"schienenhoehe_mm\": 2300, \"warenlaenge_mm\": 1200}]"
|
||||
(lg-json-wert (lg-j-ebenen "2300/1200")))
|
||||
;; kleine Container einzeilig, grosse je Eintrag eine Zeile
|
||||
(tu-eq "lg-json-text/klein" "{\"a\": 1}" (lg-json-text (list 'OBJ (cons "a" 1)) ""))
|
||||
(setq _gross (cons 'OBJ (mapcar '(lambda (i) (cons (itoa i) i)) '(1 2 3 4 5 6 7 8 9 10 11 12 13))))
|
||||
(tu-eq "lg-json-text/gross-zeilen" 15
|
||||
(length (ssg-sepliste-split-feld (lg-json-text _gross "") "\n")))
|
||||
(tu-eq "lg-json-text/punkte-einzeilig" 1
|
||||
(length (ssg-sepliste-split-feld
|
||||
(lg-json-text (lg-j-pkte '((0 0) (1 0) (1 1) (0 1) (0 2) (2 2) (2 0))) "") "\n")))
|
||||
(tu-eq "lg-j-setzen/neu" 2 (lg-j (lg-j-setzen (list 'OBJ (cons "a" 1)) "b" 2) "b"))
|
||||
(tu-eq "lg-j-setzen/ersetzen" '(OBJ ("a" . 3)) (lg-j-setzen (list 'OBJ (cons "a" 1)) "a" 3))
|
||||
|
||||
;; --- Kennwerte (Export) ---
|
||||
(tu-eq "lg-buehne-p" '(T nil nil nil)
|
||||
(mapcar 'lg-buehne-p '("spanplatte" "hallenboden" "" nil)))
|
||||
(tu-eq "lg-unter-reihe-wert" '("gitterkorb" "gitterrost" "keine" "keine" "gitterrost")
|
||||
(list (lg-unter-reihe-wert "gitterkorb" "gitterrost" T)
|
||||
(lg-unter-reihe-wert "" "gitterrost" T)
|
||||
(lg-unter-reihe-wert "keine" "gitterrost" T)
|
||||
(lg-unter-reihe-wert "gitterkorb" "gitterrost" nil)
|
||||
(lg-unter-reihe-wert "quatsch" "unbekannt" T)))
|
||||
(setq _r1 (list 'OBJ (cons "laenge_mm" 4000.0) (cons "tiefe_mm" 700.0) (cons "schienen" 1)
|
||||
(cons "haengeebenen" (lg-j-ebenen "2300/1200;1100/1100"))
|
||||
(cons "unter_reihe" "gitterrost"))
|
||||
_r2 (list 'OBJ (cons "laenge_mm" 2000.0) (cons "tiefe_mm" 700.0) (cons "schienen" 2)
|
||||
(cons "haengeebenen" (lg-j-ebenen "2300/1200"))
|
||||
(cons "unter_reihe" "gitterrost")))
|
||||
(tu-eqf "lg-haengeebenen-summen"
|
||||
'(ARR (OBJ ("schienenhoehe_mm" . 2300.0) ("warenlaenge_mm" . 1200.0) ("reihen" . 2) ("regallaenge_mm" . 6000.0))
|
||||
(OBJ ("schienenhoehe_mm" . 1100.0) ("warenlaenge_mm" . 1100.0) ("reihen" . 1) ("regallaenge_mm" . 4000.0)))
|
||||
(lg-haengeebenen-summen (list _r1 _r2)))
|
||||
(setq _ga (list (list 'OBJ (cons "art" "gang") (cons "belag" "spanplatte") (cons "laenge_mm" 10000.0) (cons "breite_mm" 1000.0))
|
||||
(list 'OBJ (cons "art" "randgang") (cons "belag" "gitterrost") (cons "laenge_mm" 5000.0) (cons "breite_mm" 800.0))
|
||||
(list 'OBJ (cons "art" "gang") (cons "belag" "spanplatte") (cons "laenge_mm" 2000.0) (cons "breite_mm" 1000.0))))
|
||||
(tu-eqf "lg-gaenge-je-art"
|
||||
'(OBJ ("gang" OBJ ("anzahl" . 2) ("laenge_mm" . 12000.0) ("flaeche_mm2" . 1.2e7))
|
||||
("quergang" OBJ ("anzahl" . 0) ("laenge_mm" . 0.0) ("flaeche_mm2" . 0.0))
|
||||
("randgang" OBJ ("anzahl" . 1) ("laenge_mm" . 5000.0) ("flaeche_mm2" . 4.0e6)))
|
||||
(lg-gaenge-je-art _ga))
|
||||
;; Geschoss 1 (Spanplatte, 3100) unter Geschoss 2 (6100, Konstr. 250)
|
||||
(setq _g1 (list 'OBJ (cons "nr" 1) (cons "hoehe_belag_mm" 3100.0) (cons "konstr_hoehe_mm" 250.0)
|
||||
(cons "lichte_hoehe_mm" nil) (cons "belag_art" "spanplatte")
|
||||
(cons "kontur" (list 'OBJ (cons "flaeche_mm2" 6.0e7))))
|
||||
_g2 (list 'OBJ (cons "nr" 2) (cons "hoehe_belag_mm" 6100.0) (cons "konstr_hoehe_mm" 250.0)
|
||||
(cons "lichte_hoehe_mm" nil) (cons "belag_art" "spanplatte")))
|
||||
(setq _kw (car (lg-kennwerte-geschoss _g1 _g2 (list _r1 _r2) _ga 1)))
|
||||
(tu-eqf "lg-kennwerte/lichte-berechnet" 2750.0 (lg-j _kw "lichte_hoehe_mm"))
|
||||
(tu-eqf "lg-kennwerte/regallaenge" 6000.0 (lg-j _kw "regallaenge_mm"))
|
||||
(tu-eqf "lg-kennwerte/grundflaeche" 4.2e6 (lg-j _kw "regalgrundflaeche_mm2"))
|
||||
(tu-eqf "lg-kennwerte/schienen" 8000.0 (lg-j _kw "schienenlaenge_mm"))
|
||||
(tu-eqf "lg-kennwerte/belag-gaenge" 1.2e7 (lg-j _kw "belagsflaeche_mm2"))
|
||||
;; Gitterrost = Randgang gitterrost 4e6 + Reihen 4.2e6
|
||||
(tu-eqf "lg-kennwerte/gitterrost" 8.2e6 (lg-j _kw "gitterrostflaeche_mm2"))
|
||||
(tu-eq "lg-kennwerte/buehne" T (lg-j _kw "buehne"))
|
||||
(tu-eq "lg-kennwerte/herkunft" T
|
||||
(if (lg-j (cadr (lg-kennwerte-geschoss _g1 _g2 (list _r1 _r2) _ga 1)) "belagsflaeche_mm2") T))
|
||||
;; ohne Gaenge: Konturflaeche - Reihengrundflaeche; oberstes ohne Vorgabe -> nil
|
||||
(setq _kw (car (lg-kennwerte-geschoss _g1 nil (list _r1 _r2) nil 1)))
|
||||
(tu-eqf "lg-kennwerte/belag-kontur" (- 6.0e7 4.2e6) (lg-j _kw "belagsflaeche_mm2"))
|
||||
(tu-nil "lg-kennwerte/lichte-oben" (lg-j _kw "lichte_hoehe_mm"))
|
||||
(tu-eqf "lg-kennwerte/lichte-vorgabe" 2800.0
|
||||
(lg-j (car (lg-kennwerte-geschoss (lg-j-setzen _g1 "lichte_hoehe_mm" 2800.0) _g2 nil nil 0))
|
||||
"lichte_hoehe_mm"))
|
||||
;; Hallenboden: keine Buehne, keine Flaechen
|
||||
(setq _kw (car (lg-kennwerte-geschoss (lg-j-setzen _g1 "belag_art" "hallenboden") _g2 (list _r1) _ga 1)))
|
||||
(tu-eq "lg-kennwerte/hallenboden" 'FALSE (lg-j _kw "buehne"))
|
||||
(tu-nil "lg-kennwerte/hallenboden-belag" (lg-j _kw "belagsflaeche_mm2"))
|
||||
(tu-nil "lg-kennwerte/hallenboden-gitter" (lg-j _kw "gitterrostflaeche_mm2"))
|
||||
|
||||
;; --- Gitterkorb: offene Kanten ---
|
||||
;; Einzelreihe 4000 x 700: alles offen
|
||||
(setq _e1 '((0.0 -350.0) (4000.0 -350.0) (4000.0 350.0) (0.0 350.0))
|
||||
_e2 '((0.0 350.0) (4000.0 350.0) (4000.0 1050.0) (0.0 1050.0))
|
||||
_e3 '((2000.0 1050.0) (6000.0 1050.0) (6000.0 1750.0) (2000.0 1750.0)))
|
||||
(tu-eqf "lg-offene-kanten/einzeln" '((8000.0 1400.0)) (lg-reihen-offene-kanten (list _e1) 1.0))
|
||||
;; Ruecken an Ruecken: je eine Laengsseite zu
|
||||
(tu-eqf "lg-offene-kanten/ruecken" '((4000.0 1400.0) (4000.0 1400.0))
|
||||
(lg-reihen-offene-kanten (list _e1 _e2) 1.0))
|
||||
;; Teilueberlappung: _e3 liegt nur auf 2000 mm an _e2 an (_e2 unten ganz an _e1)
|
||||
(tu-eqf "lg-offene-kanten/teilweise" '((2000.0 1400.0) (6000.0 1400.0))
|
||||
(cdr (lg-reihen-offene-kanten (list _e1 _e2 _e3) 1.0)))
|
||||
;; Abstand > Toleranz: nicht anliegend
|
||||
(tu-eqf "lg-offene-kanten/abstand" '((8000.0 1400.0) (8000.0 1400.0))
|
||||
(lg-reihen-offene-kanten
|
||||
(list _e1 '((0.0 360.0) (4000.0 360.0) (4000.0 1060.0) (0.0 1060.0))) 1.0))
|
||||
;; Gitterkorb vervollstaendigen: Boden, offene Kanten, Seitenflaeche
|
||||
(setq _rk (lg-reihen-gitterkorb-berechnen
|
||||
(list (list 'OBJ (cons "laenge_mm" 4000.0) (cons "tiefe_mm" 700.0)
|
||||
(cons "ecken" (lg-j-pkte _e1))
|
||||
(cons "gitterkorb" (list 'OBJ (cons "hoehe_mm" 500.0))))
|
||||
(list 'OBJ (cons "laenge_mm" 4000.0) (cons "tiefe_mm" 700.0)
|
||||
(cons "ecken" (lg-j-pkte _e2)) (cons "gitterkorb" nil)))
|
||||
1.0))
|
||||
(setq _gk (lg-j (car _rk) "gitterkorb"))
|
||||
(tu-eqf "lg-gitterkorb/boden" 2.8e6 (lg-j _gk "bodenflaeche_mm2"))
|
||||
(tu-eqf "lg-gitterkorb/laengs" 4000.0 (lg-j _gk "offen_laengs_mm"))
|
||||
(tu-eqf "lg-gitterkorb/seite" (* 500.0 5400.0) (lg-j _gk "seitenflaeche_mm2"))
|
||||
(tu-nil "lg-gitterkorb/ohne" (lg-j (cadr _rk) "gitterkorb"))
|
||||
;; Kennwerte summieren den Korb, Grundflaeche zaehlt dann nicht als Gitterrost
|
||||
(setq _kw (car (lg-kennwerte-geschoss _g1 _g2
|
||||
(list (lg-j-setzen (car _rk) "unter_reihe" "gitterkorb")) nil 1)))
|
||||
(tu-eqf "lg-kennwerte/korb-seite" (* 500.0 5400.0) (lg-j (lg-j _kw "gitterkorb") "seitenflaeche_mm2"))
|
||||
(tu-eq "lg-kennwerte/korb-reihen" 1 (lg-j (lg-j _kw "gitterkorb") "reihen"))
|
||||
(tu-eqf "lg-kennwerte/korb-kein-gitterrost" 0.0 (lg-j _kw "gitterrostflaeche_mm2"))
|
||||
;; Lager-Summen ueber zwei Geschosse
|
||||
(setq _kl (lg-kennwerte-lager
|
||||
(list (lg-j-setzen (lg-j-setzen _g1 "kennwerte" (car (lg-kennwerte-geschoss _g1 _g2 (list _r1) nil 1)))
|
||||
"kontur" (list 'OBJ (cons "bbox" (list 'ARR 0.0 0.0 10000.0 6000.0))))
|
||||
(lg-j-setzen (lg-j-setzen _g2 "kennwerte" (car (lg-kennwerte-geschoss _g2 nil (list _r2) nil 1)))
|
||||
"kontur" (list 'OBJ (cons "bbox" (list 'ARR 0.0 0.0 12000.0 5000.0)))))
|
||||
(list _r1 _r2) nil 2))
|
||||
(tu-eqf "lg-kennwerte-lager/regal" 6000.0 (lg-j _kl "regallaenge_mm"))
|
||||
(tu-eqf "lg-kennwerte-lager/huelle" '(12000.0 6000.0)
|
||||
(list (lg-j (lg-j _kl "huelle") "laenge_mm") (lg-j (lg-j _kl "huelle") "breite_mm")))
|
||||
|
||||
;; --- Regelprofil-Aufloesung ---
|
||||
(tu-eq "lg-bedingung/leer" 'ja (lg-bedingung-pruefen nil nil))
|
||||
@@ -3472,7 +3590,7 @@
|
||||
(car (lg-regel-aufloesen (lg-regel-finden _prof "gelaender.hoehe_min")
|
||||
'(("absturzhoehe" . 3100)))))
|
||||
(tu-nil "lg-profil/sk-ungepflegt" (ssg-json-get _prof "gepflegt")))
|
||||
(tu-record nil "lg-profil/dateien" "cfg/regelwerk/SK.json nicht gefunden (DXFM_CFG?)"))
|
||||
(tu-record nil "lg-profil/dateien" "cfg/stahlbau/regelwerk/SK.json nicht gefunden (DXFM_CFG?)"))
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
Reference in new issue
Block a user