← Skills

SIP Partition Walls (ElixiFree API)

Native Read-only

Internal partition wall rules: SIP-100 stock, no corner splines, internal door sizes, external wall groove receivers.

/skills/sip_partition_walls.md

Estimated tokens
1193
Characters
4771
Source
Native

Markdown 

# SIP Partition Wall Skill — ElixiFree Builder API

Internal partition walls in a SIP building use **SIP-100 (122mm)** as the default stock.
They are thinner than external walls to maximise floor area and do **not** use corner
spline joints — they butt against external wall faces.

## Key rules

1. **Always use `stock="SIP-100"`** for partition walls — never SIP-150 or thicker.
2. **No `.corner_spline()`** — partition ends abut external wall inner faces, no spline protrusion.
3. **Do cut `.inner_groove()` into external walls** where the partition meets them.
4. **Door openings** follow the same rough opening rules as external walls: use `.opening(x, z, width, height)`.
5. **Orientation**: do NOT call `.orient("Y")` on a partition script, even for a front-to-back run. Pipeline scripts are expanded through `Wall.construct()`, which always builds span-along-local-X regardless of run direction; the partition's real-world yaw is derived from the building graph (`BuildingGraph.interior_wall_world_placement/2`) and applied by the assembly Placer's graph partition path (ratcheted by the `assembly.partition_orientation` validator). Calling `.orient("Y")` pre-rotates the shape a second time and double-rotates the wall against the Placer's own yaw.
6. **Span MUST come from the actual neighbours (`connects_to`), never from the raw building width/depth.**
   A partition's declared box must fit INSIDE the inner envelope `[PT, BUILDING_WIDTH-PT] x
   [PT, BUILDING_DEPTH-PT]`. `SipSpecNormalizer` derives/clamps this deterministically before
   component generation, but the spec author should still get it right: span = distance between
   the two inner faces (perimeter wall or other partition) the partition connects to.

   **Worked example** (9000x7000mm building, PT=142, inner envelope Y in [142,6858]): a
   north-south hallway partition running from a living/back partition at y=3942 to the north
   wall inner face (y=6858) has **span = 6858 - 3942 = 2916mm** — correct, because it is derived
   from the real neighbour distance. The observed field failure was the same partition declared
   with **span=7000** (the raw `BUILDING_DEPTH`) positioned at y=4042: its far end would land at
   y=11042, more than 4.2m outside the north wall inner face. Never size a partition to the
   building's outer dimension — derive it from what it actually connects to, or (if that cannot
   be derived) clamp it inside the inner envelope rather than stretching it.

## Partition wall — plain

```python
from elixifree.domains.sip import Wall

result = Wall(span=3000, height=2440, stock="SIP-100").build()
result.add_to_doc("Body")
```

## Partition wall — with internal door

```python
from elixifree.domains.sip import Wall

SPAN = 3000
DOOR_W = 800    # internal doors are narrower than external — typically 762–838mm
DOOR_H = 2040
DOOR_X = (SPAN - DOOR_W) / 2  # centred

result = (Wall(span=SPAN, height=2440, stock="SIP-100")
    .opening(x=DOOR_X, z=0, width=DOOR_W, height=DOOR_H)
    .build())
result.add_to_doc("Body")
```

## Partition wall — front-to-back run

A front-to-back partition (parallel to east/west walls) is still built in the
default local frame — do NOT call `.orient("Y")`. The Placer determines its
world yaw from the building graph (`BuildingGraph.interior_wall_world_placement/2`)
and applies the rotation.

```python
from elixifree.domains.sip import Wall

result = (Wall(span=4000, height=2440, stock="SIP-100")
    .build())          # default local frame — do NOT call .orient("Y")
result.add_to_doc("Body")
```

## External wall grooves to receive a partition

When a partition wall meets an external wall, add an `.inner_groove()` at that position:

```python
from elixifree.domains.sip import Wall, sip_constants

c = sip_constants("SIP-100")  # partition wall thickness = 122mm

# External south wall with grooves at 3000mm and 5000mm where partitions meet
result = (Wall(span=10000, height=2440, stock="SIP-100")
    .inner_groove(x=3000)   # left partition wall meet
    .inner_groove(x=5000)   # right partition wall meet
    .build())
result.add_to_doc("Body")
```

## Internal door sizes (guidance)

| Room type | Typical clear width |
|-----------|-------------------|
| Bedroom   | 762mm             |
| Bathroom  | 700mm             |
| Kitchen   | 838mm             |
| Hallway   | 838mm             |

Standard internal door height: **2040mm** (not 2100mm as for external doors).

## Rules

1. **Never use `.corner_spline()`** on partition walls.
2. **Always `stock="SIP-100"`** — never thicker.
3. **End every script with `result.add_to_doc("Body")`** — never write doc/recompute/Gui lines.
4. If the geometry cannot be expressed with the builder, use raw `Part` and add a comment:
   `# ElixiFree gap: <description>`
v0.0.985