Facade layout

One job to synthesize.

tile_origin reproduces one tile of a tiled run. Pass it together with synthesize_facade_layout's site_origin; omit both for an untiled run.

Warnings

A tiled submission projects each tile's geometry around that tile's own reference point, so omitting tile_origin for a tiled job re-synthesizes in the site frame instead and drifts every frame by the tile row's cos(latitude) term.

Attributes:

One coplanar surface region, with its cells in canonical order.

Attributes:

One job's rebuilt layout.

Attributes:

A rebuilt or reloaded facade layout.

Create one with synthesize_facade_layout or FacadeLayout.from_bytes; do not call the constructor directly.

Attributes:

layout_key property

layout_key: str

Key that identifies this layout.

It covers the geometry, the synthesis parameters, the surfgrid version and the core version, so two layouts with the same key are the same layout. Store it with each result you may want to show again later.

surfgrid_version property

surfgrid_version: int

Surfgrid version the layout was built at.

core_version property

core_version: str

Version of the bundled geometry core that built the layout.

synth_params property

synth_params: Dict[str, Any]

Synthesis parameters the layout was built with.

to_bytes

to_bytes() -> bytes

Export this layout in a compact form.

The export leaves out the triangles of full cells and is zlib-compressed. Reload it with FacadeLayout.from_bytes. It is computed once and cached.

Returns:

from_bytes classmethod

from_bytes(
data: bytes, schedule: Optional["AreaSchedule"] = None
) -> "FacadeLayout"

Load a layout exported by FacadeLayout.to_bytes.

Parameters:

Returns:

Raises:

tile_origin_of(schedule: 'AreaSchedule', job_id: str) -> Tuple[float, float]

Return the (lon, lat) of a job's tile south-west corner.

This is the same computation run_area used to anchor that tile when it submitted it.

Parameters:

Returns:

Raises:

attach_values(
layout: "FacadeLayout", columns: Any, *, expected_layout_key: str
) -> Any

Verify a layout against a live or reloaded SurfaceColumns.

The check refuses a mismatch. It first compares layout.layout_key with expected_layout_key, which covers the geometry, the synthesis parameters, the surfgrid version and the core version, so a rebuild whose geometry drifted gets a different key. This catches even a change too small to move a frame's origin, axes or grid, such as a small hole inside a cell that is still present.

Two further checks guard against a columns mismatch the key alone cannot catch, such as the wrong surface entirely. They join by surface id, never by row, so the row order of columns does not have to match the job and frame order of layout. For every frame the layout names, this checks that:

1. columns has that surface;
2. its origin, axes and grid dimensions agree with the layout's, within float rounding;
3. its cell layout -- which grid cells actually have a sensor, in canonical row-major order -- matches exactly. columns.has_value is False for a grid cell with no sensor, one entry per cell in the order frame.cells uses, so presence is compared exactly.

Store layout_key with every result so you can pass it back here later.

Warnings

Never read expected_layout_key off layout itself: that checks nothing, because a layout always agrees with its own key.

Parameters:

Returns:

Raises:

synthesize_facade_layout(
buildings: Mapping[str, Mapping[str, Any]],
*,
analysis_surfaces: str,
surface_grid_size: float,
ground: Optional[Mapping[str, Mapping[str, Any]]] = None,
terrain_alignment: Optional[str] = None,
surface_offset: float = 0.1,
partial_cells: bool = True,
min_coverage: float = 0.05,
mesh_cleaning: str = "auto",
max_sensors_per_job: int = 262144,
emit_cell_tris: bool = False,
surfgrid_version: Optional[int] = None,
site_origin: Optional[Tuple[float, float]] = None,
jobs: Optional[Sequence[FacadeLayoutJobSpec]] = None,
schedule: Optional["AreaSchedule"] = None,
) -> FacadeLayout

Rebuild a facade or roof layout offline from the original inputs.

This only rebuilds the layout; call FacadeLayout.to_bytes on the result to export it.

Parameters:

Returns:

Raises: