Integration from Module Schemas to Full Model: Difference between revisions

From Open Source Ecology
Jump to navigation Jump to search
Tag: Replaced
Line 20: Line 20:


No manual CAD edits. Every output must be regenerable from schemas.
No manual CAD edits. Every output must be regenerable from schemas.
== 0. Inputs and Conventions (Lock These In) ==
=== 0.1 Coordinate and Reference Convention ===
* Each module has a local coordinate frame (CSYS) and published ports/faces.
* The assembly has a world CSYS and places modules via topology constraints.
* Every placed object is referenced by:
  * module_id
  * host reference (stud_id / bay_id / distance-along-wall s)
  * level (z) reference (finish floor, top plate, etc.)
=== 0.2 Module Interface Contract (Minimum) ===
Each module generator must publish:
* Ports: left_end, right_end, top, bottom
* Faces: interior, exterior, centerline
* Stud map: stud centerlines + IDs (queryable by distance along wall)
* No-go zones: openings, headers, shear zones, MEP prohibited zones
* Feature lanes: permissible regions for blocking + services
== 1. Generate Base Modules (Module Compilers) ==
This stage produces clean, reusable modules with metadata. No building-level logic.
=== 1.1 Wall Modules ===
* Inputs: width (nominal 4'), height (8–10'+), thickness, stud spacing, sheathing side(s)
* Outputs:
  * Framing geometry (studs/plates)
  * Sheathing geometry
  * Tags: studs, plates, sheathing, cavity volumes
  * Ports/faces + stud map + lanes
=== 1.2 Door Modules ===
* Inputs: rough opening width/height, door type, header rule, king/jack rules
* Outputs:
  * Framing + header + cripples + tags
  * Door opening volume (clearance/RO solid)
  * Ports/faces + stud map
=== 1.3 Window Modules ===
* Inputs: rough opening width/height, sill height, header rule
* Outputs:
  * Framing + header + sill + cripples + tags
  * Window opening volume (RO solid)
  * Ports/faces + stud map
== 2. Generate House Assembly (Assembly Compiler) ==
Assembly schema contains ONLY:
* module instances (id, type, parameters, orientation)
* connections (what connects to what)
The assembly compiler:
# Picks a root module and places it at origin.
# Walks the adjacency graph and places all modules by port alignment.
# Emits connection events (L-corner / T-intersection / splice).
# Outputs the full placed assembly + adjacency graph.
=== 2.1 Assembly Schema (Topology Truth) ===
* modules[]:
  * module_id, module_type, params, orientation, level
* connections[]:
  * A.port → B.port (and connection type if explicit)
== 3. Post-Compiler Passes (Feature Injection + Routing) ==
Each pass is deterministic and idempotent:
* Re-running a pass must not duplicate features.
* Each pass outputs "feature objects" + materialized CAD + BOM deltas.
== Pass Order (Recommended MVP → Full Build) ==
== 4. Pass A — Interior Blocking (Framing & Drywall Backing) ==
Purpose: Ensure fastening surfaces and required blocking exist based on assembly joints and finish requirements.
=== 4.1 A1: Corner Blocking (L-Corners) ===
Input facts:
* Connection events of type L-corner
Actions:
* Add ladder blocking / corner backing per OSE standard
* Tag as blocking; add to BOM
=== 4.2 A2: T-Wall Drywall Backing (Partitions into Walls) ===
Input facts:
* Connection events of type T-intersection
Actions:
* Add backing members to host wall at partition line
* Maintain no-go zones (openings, headers, shear zones)
=== 4.3 A3: Drywall Seam Backing (Optional) ===
Input facts:
* Drywall layout rule set (sheet size, seam strategy)
Actions:
* Compute seam lines; add backing where seams fall off-stud
== 5. Pass B — Rough Plumbing + Water Lines ==
Purpose: Place plumbing fixtures and route drain/vent/water within allowed zones.
=== 5.1 B1: Fixture Placement (Schema-Driven) ===
Place fixtures as feature objects with anchor references:
* Showers
* Toilets
* Bath cabinets/vanities
* Kitchen island cabinet
* Kitchen cabinets (runs)
Fixtures are placed relative to rooms/walls and reference planes.
=== 5.2 B2: Rough Drain/Waste/Vent (DWV) Routing ===
Actions:
* Create DWV route graph:
  * fixture drains → main stack(s) → building drain
  * vent paths → roof/termination
* Emit:
  * pipe segments with diameters
  * slopes
  * penetrations (top/bottom plates, floors)
  * hanger points (optional)
* Validate:
  * slope feasibility
  * collision checks
  * no-go zones
=== 5.3 B3: Rough Water Lines (Hot/Cold) ===
Actions:
* Route hot/cold from water heater/manifold to fixtures
* Emit:
  * pipe segments
  * penetrations
  * insulation requirements (optional)
== 6. Pass C — Bath Vent Fans + Ducts (Bath + Kitchen + Washer) ==
Purpose: Place fans/hoods and route ducts to exterior terminations.
=== 6.1 C1: Device Placement ===
* Bath vent fans (per bathroom)
* Kitchen hood (or recirc decision explicitly)
* Washer vent (dryer vent if applicable)
=== 6.2 C2: Duct Routing ===
Actions:
* Route ducts through predefined duct lanes (top plate, soffit zone, service cavity)
* Emit:
  * duct sizes
  * elbows/lengths
  * penetrations (walls/roof)
  * termination caps locations
* Validate:
  * max equivalent length constraints (as defined by OSE rules)
  * clearance zones
== 7. Pass D — Electrical Boxes ==
Purpose: Place all device boxes deterministically based on rules.
=== 7.1 D1: Room/Perimeter Inference (Minimum Viable) ===
* Infer exterior wall loops and interior partitions
* Identify room boundaries (coarse is OK for MVP)
=== 7.2 D2: Receptacle Placement ===
Actions:
* Along each interior wall run, place receptacles by spacing rule
* Avoid openings and no-go zones
* Attach each box to a host wall stud bay + height ref
=== 7.3 D3: Switch Placement ===
Actions:
* Place switches at doors per rule set
* Place 3-way/4-way only if explicitly specified
=== 7.4 D4: Special Loads ===
Actions:
* Add dedicated circuits/boxes for:
  * fridge
  * dishwasher
  * oven/range
  * microwave (if any)
  * washer
  * dryer
  * water heater(s)
* Place per appliance schema anchors
== 8. Pass E — Wiring + Drilling Plan ==
Purpose: Route wires and generate stud drilling/hole schedules.
Actions:
* Build wiring graph:
  * panel → devices → lights → fans → appliances
* Route in permissible zones:
  * top plate runs, service cavities, chase zones
* Emit:
  * cable runs and lengths
  * drill points per stud ID
  * nail plate requirements per rule set
* Validate:
  * prohibited zones
  * spacing/derating rules as defined by OSE canon
== 9. Pass F — Drywall System ==
Purpose: Generate drywall layout and penetrations.
=== 9.1 F1: Drywall Sheet Layout (Optional MVP+) ===
Actions:
* Compute sheet placement and seams per strategy
* Emit:
  * sheet count
  * cut list
  * seam map
* Inject backing (if Pass A3 enabled)
=== 9.2 F2: Drywall Penetrations (Derived) ===
Inputs:
* Plumbing penetrations
* Vent duct penetrations
* Electrical boxes
Actions:
* Generate drywall cutouts (with tolerances)
* Emit:
  * penetration schedule by wall module
  * cut templates (optional)
== 10. Pass G — Finish Fixtures, Devices, and Cabinets ==
Purpose: Place finish components and final electrical components.
=== 10.1 G1: Showers / Toilets / Bath Cabinets ===
Actions:
* Place fixture solids and clearances
* Emit:
  * anchor points
  * mounting heights
  * fastener/backing requirements
=== 10.2 G2: Kitchen Cabinets + Island ===
Actions:
* Place cabinet runs and island modules
* Inject required backing bands in walls (if not present)
* Emit:
  * cabinet BOM
  * layout drawings
=== 10.3 G3: Final Electrical (Devices + Covers + Lights) ===
Actions:
* Place:
  * receptacles/switches/covers
  * light fixtures (ceiling)
  * bath fan grilles
* Output:
  * device schedule
  * lighting plan
== 11. Pass H — Appliances ==
Purpose: Place appliances and confirm services align.
Appliances to place:
* Fridge
* Washer
* Dishwasher
* Dryer
* Oven/range
* Water heater(s)
Actions:
* Place appliance solids + clearances
* Validate:
  * electrical box locations
  * water hookups
  * drain hookups
  * vent hookups (dryer/hood if applicable)
== 12. Pass I — Flooring ==
Purpose: Generate flooring layout, cuts, and transitions.
Actions:
* Compute floor areas per room
* Emit:
  * flooring quantities
  * cut layout (optional)
  * transition strips + underlayment schedule
== 13. Outputs (Every Run) ==
Each full compile produces:
* 3D CAD assembly
* Per-module fabrication drawings (framing/sheathing)
* Feature schedules:
  * blocking schedule
  * electrical device schedule
  * plumbing schedule
  * duct schedule
  * drywall penetration schedule
  * cabinet/appliance placement schedule
* BOM (base + deltas by pass)
* QA checklist per pass (validation report)
== 14. Validation Rules (Fail Loudly) ==
The pipeline must fail when:
* A required feature cannot be placed without violating no-go zones
* A route cannot be found within permissible lanes
* Intersections are inconsistent with topology
* Regeneration produces non-identical topology-derived outputs
== 15. Minimum Viable Release (MVR) ==
MVR includes:
* Modules: wall, door, window
* Assembly: topology placement
* Pass A: interior blocking (L + T)
* Pass D: electrical box placement (basic)
* Pass E: basic wiring routes + drilling plan (basic)
* Output: CAD + BOM + schedules
Everything else is incremental passes.

Revision as of 06:30, 24 January 2026

About

This must be done not by gurus—by clerks following specs.

Why? Because of this - [1]. In short: The real risk is not skill level—it’s unconscious substitution. The danger is not incompetence. The danger is: “I know a better way to do this.”

Howto

The core simplification: Assembly is not geometry. Assembly is topology. Geometry already exists at the module level. Assembly is simply how modules are connected.

If you accept that, everything downstream becomes tractable.


Induction-Grade House Compiler Process (Modules → Assembly → Post-Compilers)

Canonical Principle

All downstream artifacts are generated from:

  1. Module Schemas (single-module truth)
  2. Assembly Schema (topology truth: what connects to what)
  3. Post-Compiler Passes (feature injection + routing + schedules)

No manual CAD edits. Every output must be regenerable from schemas.

Retrieved from "https://wiki.opensourceecology.org/index.php?title=Integration_from_Module_Schemas_to_Full_Model&oldid=319009"