| import { |
| baseline, |
| defaults, |
| climates, |
| configure, |
| validateDesign, |
| simulateDay, |
| summarize, |
| formatHour, |
| MODEL_VERSION, |
| ROOM, |
| } from "./model.mjs"; |
|
|
| export const STUDY_LIMIT = 32768; |
| export const IDS = ["A", "B"]; |
| const exact = (value, fields, label) => { |
| if ( |
| !value || |
| typeof value !== "object" || |
| Array.isArray(value) || |
| Object.keys(value).length !== fields.length || |
| fields.some((key) => !Object.hasOwn(value, key)) |
| ) |
| throw new Error(label + " has missing or unknown fields."); |
| return value; |
| }; |
| const name = (value) => { |
| if (typeof value !== "string" || !value.trim() || value.trim().length > 60) |
| throw new Error("Give each alternative a name of 1–60 characters."); |
| for (const c of value) { |
| const n = c.codePointAt(0); |
| if ( |
| n < 32 || |
| n === 127 || |
| n === 133 || |
| n === 0x2028 || |
| n === 0x2029 || |
| (n >= 0xd800 && n <= 0xdfff) |
| ) |
| throw new Error("Names must be single-line text with valid Unicode."); |
| } |
| return value.trim(); |
| }; |
| export function newStudy() { |
| return validateStudy({ |
| schema: "threshold-study/v1", |
| model: MODEL_VERSION, |
| climate: "humid", |
| hour: 16, |
| lens: "heat", |
| active: "B", |
| alternatives: { |
| A: { name: "Example starting point", design: { ...baseline } }, |
| B: { name: "My alternative", design: { ...defaults } }, |
| }, |
| }); |
| } |
| export function validateStudy(input) { |
| const s = exact( |
| input, |
| ["schema", "model", "climate", "hour", "lens", "active", "alternatives"], |
| "Study", |
| ); |
| if (s.schema !== "threshold-study/v1" || s.model !== MODEL_VERSION) |
| throw new Error("Unsupported THRESHOLD study or model version."); |
| if (!IDS.includes(s.active)) throw new Error("Choose alternative A or B."); |
| exact(s.alternatives, IDS, "Alternatives"); |
| const alternatives = Object.fromEntries( |
| IDS.map((id) => { |
| const option = exact(s.alternatives[id], ["name", "design"], "Alternative " + id); |
| return [id, { name: name(option.name), design: validateDesign(option.design) }]; |
| }), |
| ); |
| |
| |
| const view = configure( |
| { design: { ...defaults }, climate: "humid", hour: 16, lens: "heat" }, |
| { climate: s.climate, hour: s.hour, lens: s.lens, ...alternatives[s.active].design }, |
| ); |
| return { |
| schema: s.schema, |
| model: MODEL_VERSION, |
| climate: view.climate, |
| hour: view.hour, |
| lens: view.lens, |
| active: s.active, |
| alternatives, |
| }; |
| } |
| export function saveStudy(input) { |
| return JSON.stringify(validateStudy(input), null, 2) + "\n"; |
| } |
| export function parseStudy(text) { |
| if (new TextEncoder().encode(text).byteLength > STUDY_LIMIT) |
| throw new Error("Choose a THRESHOLD study JSON file of 32 KiB or smaller."); |
| return validateStudy(JSON.parse(text)); |
| } |
| export const optionLabel = (study, id) => `${id} · ${study.alternatives[id].name}`; |
| export const MECHANISMS = { |
| orientation: |
| "Orientation changes modeled facade solar exposure and the wind-facing factor, not just the direction of the drawing.", |
| glazing: |
| "Glazing changes window solar gain and envelope conductance. It is not a daylight-quality calculation.", |
| shade: |
| "Overhang depth changes direct-beam shading; diffuse and ground-reflected radiation remain unshaded. Daylight quality is not modeled.", |
| mass: "Storage changes effective heat capacity, not insulation. A lower peak need not mean more occupied time inside the study band.", |
| ventilation: |
| "The effective opening sets potential wind/stack flow, but actual ACH depends on temperature and controller timing. A larger opening need not increase occupied mean ventilation.", |
| }; |
| export function evaluateStudy( |
| input, |
| calculate = (climate, design) => { |
| const simulation = simulateDay(climates[climate], design); |
| return { simulation, summary: summarize(simulation) }; |
| }, |
| ) { |
| const s = validateStudy(input); |
| const values = Object.fromEntries( |
| IDS.map((id) => [id, calculate(s.climate, s.alternatives[id].design)]), |
| ); |
| const a = values.A.summary, |
| b = values.B.summary; |
| const changes = Object.keys(defaults) |
| .filter((key) => s.alternatives.A.design[key] !== s.alternatives.B.design[key]) |
| .map((key) => ({ |
| key, |
| from: s.alternatives.A.design[key], |
| to: s.alternatives.B.design[key], |
| mechanism: MECHANISMS[key], |
| })); |
| return { |
| study: s, |
| ...values, |
| changes, |
| settled: a.converged && b.converged, |
| delta: { |
| peakC: b.peak.temperature - a.peak.temperature, |
| bandHours: b.bandHours - a.bandHours, |
| solarKWh: b.solarKWh - a.solarKWh, |
| meanACH: b.meanACH - a.meanACH, |
| purgeHours: b.purgeHours - a.purgeHours, |
| }, |
| }; |
| } |
| export const signed = (value, digits = 2) => { |
| const n = Math.abs(value) < 0.5 * 10 ** -digits ? 0 : value; |
| return (n > 0 ? "+" : "") + n.toFixed(digits); |
| }; |
| export function peakInterval(value) { |
| const half = value.simulation.minutes / 120; |
| return `${formatHour(value.summary.peak.hour - half)}–${formatHour(value.summary.peak.hour + half)}`; |
| } |
| export function comparisonSentence(result) { |
| if (!result.settled) |
| return "Unsettled comparison: at least one alternative did not reach a repeating day. Do not read the displayed differences as a settled design comparison."; |
| const d = result.delta; |
| return `B minus A: daily peak ${signed(d.peakC)}°C; occupied study-band time ${signed(d.bandHours)} h; window solar gain ${signed(d.solarKWh)} kWh; occupied mean ventilation ${signed(d.meanACH)} ACH. These are separate trade-offs, not an overall quality score. The two peaks can occur at different times.`; |
| } |
| export function studyBrief(input) { |
| const r = evaluateStudy(input), |
| s = r.study, |
| quote = (value) => JSON.stringify(value); |
| const lines = [ |
| "THRESHOLD | TWO-ALTERNATIVE STUDY BRIEF", |
| `Model: ${MODEL_VERSION}. Shared synthetic day: ${climates[s.climate].name}.`, |
| "Teaching model only. No measured site weather, human comfort prediction, energy certificate or construction advice.", |
| "", |
| comparisonSentence(r), |
| "", |
| "ALTERNATIVES", |
| ]; |
| for (const id of IDS) { |
| const v = r[id], |
| a = s.alternatives[id], |
| m = v.summary; |
| lines.push( |
| `${id}: ${quote(a.name)}`, |
| `Settings: ${JSON.stringify(a.design)}`, |
| `Repeating day ${m.converged ? "settled" : "UNSETTLED"} after ${m.warmupDays} cycles.`, |
| `Daily maximum ${v.simulation.minutes}-minute step-average model temperature: ${m.peak.temperature.toFixed(2)}°C during ${peakInterval(v)} local solar time.`, |
| `Occupied time inside 22–28°C: ${m.bandHours.toFixed(2)} of ${m.occupiedHours} h; window solar gain ${m.solarKWh.toFixed(2)} kWh/day; occupied mean ventilation ${m.meanACH.toFixed(2)} ACH; purge active ${m.purgeHours.toFixed(2)} h/day.`, |
| ); |
| } |
| lines.push("", "WHAT CHANGED"); |
| if (!r.changes.length) |
| lines.push( |
| "The two designs have identical settings; names and viewing controls do not change the calculation.", |
| ); |
| for (const c of r.changes) lines.push(`${c.key}: ${c.from} → ${c.to}. ${c.mechanism}`); |
| lines.push( |
| r.changes.length > 1 |
| ? "Multiple settings changed together. Do not attribute their combined differences to a single lever. Copy one alternative to the other, then change one setting for a controlled model comparison." |
| : "Change one setting at a time to explore this model; it is not empirical causal evidence.", |
| "", |
| "SHARED ASSUMPTIONS", |
| `Room dimensions 6 × 6 × 3 m. Fixed parameters: ${JSON.stringify(ROOM)}`, |
| "One effective temperature for mixed air and thermally coupled fabric; adiabatic floor; one 18 m² window facade. Ten-minute exact constant-forcing steps repeat up to 60 days.", |
| "Internal gains 4 W/m² during [08:00,20:00), otherwise 1 W/m². Study band 22–28°C is illustrative, not a comfort standard.", |
| "Fixed solar declination +20°. Wind coefficient 0.25; stack discharge 0.6; stack height 1.5 m. Purge begins above 25°C indoors with outdoors 0.5°C cooler; full opening at 25.5°C and 1°C difference.", |
| "No HVAC, moisture/latent heat, indoor air velocity, air quality, radiant comfort, detailed daylight, adjacent buildings or energy bills are calculated. Use qualified review, real weather and validated tools for real design decisions.", |
| "", |
| "KEEP YOUR WORK", |
| "Save study JSON separately to reopen both alternatives and viewing settings. This text brief is not an editable backup. Nothing is autosaved.", |
| "Names are user-supplied. Review the file before sharing.", |
| "https://skailiner-threshold.static.hf.space/index.html", |
| ); |
| return lines.join("\n") + "\n"; |
| } |
|
|
| export class StudyWorkspace { |
| constructor(input = newStudy()) { |
| this.value = validateStudy(input); |
| this.names = { A: this.value.alternatives.A.name, B: this.value.alternatives.B.name }; |
| this.epoch = 0; |
| this.busy = false; |
| this.pending = null; |
| } |
| read() { |
| return structuredClone({ |
| study: this.value, |
| names: this.names, |
| epoch: this.epoch, |
| busy: this.busy, |
| pending: this.pending, |
| dirty: this.dirty(), |
| }); |
| } |
| dirty() { |
| return IDS.some((id) => this.names[id] !== this.value.alternatives[id].name); |
| } |
| unlocked() { |
| if (this.busy || this.pending) |
| throw new Error("Finish or cancel the open file/confirmation first."); |
| } |
| guard() { |
| this.unlocked(); |
| if (this.dirty()) throw new Error("Apply or discard the unfinished alternative names first."); |
| } |
| commit(input) { |
| const valid = validateStudy(input); |
| this.value = valid; |
| this.names = { A: valid.alternatives.A.name, B: valid.alternatives.B.name }; |
| this.busy = false; |
| this.pending = null; |
| this.epoch++; |
| } |
| editName(id, text) { |
| this.unlocked(); |
| if (!IDS.includes(id) || typeof text !== "string") throw new Error("Invalid name draft."); |
| this.names = { ...this.names, [id]: text }; |
| this.epoch++; |
| } |
| applyNames() { |
| this.unlocked(); |
| this.commit({ |
| ...this.value, |
| alternatives: Object.fromEntries( |
| IDS.map((id) => [id, { ...this.value.alternatives[id], name: this.names[id] }]), |
| ), |
| }); |
| } |
| discardNames() { |
| this.unlocked(); |
| this.names = { A: this.value.alternatives.A.name, B: this.value.alternatives.B.name }; |
| this.epoch++; |
| } |
| configure(input) { |
| this.guard(); |
| const s = this.value, |
| view = configure( |
| { design: s.alternatives[s.active].design, climate: s.climate, hour: s.hour, lens: s.lens }, |
| input, |
| ); |
| this.commit({ |
| ...s, |
| climate: view.climate, |
| hour: view.hour, |
| lens: view.lens, |
| alternatives: { |
| ...s.alternatives, |
| [s.active]: { ...s.alternatives[s.active], design: view.design }, |
| }, |
| }); |
| } |
| select(id) { |
| this.guard(); |
| if (!IDS.includes(id)) throw new Error("Choose A or B."); |
| this.commit({ ...this.value, active: id }); |
| } |
| request(input, label) { |
| this.guard(); |
| const candidate = validateStudy(input); |
| this.pending = { study: candidate, label }; |
| this.epoch++; |
| } |
| copy() { |
| this.guard(); |
| const from = this.value.active, |
| to = from === "A" ? "B" : "A"; |
| this.request( |
| { |
| ...this.value, |
| alternatives: { |
| ...this.value.alternatives, |
| [to]: { |
| ...this.value.alternatives[to], |
| design: { ...this.value.alternatives[from].design }, |
| }, |
| }, |
| }, |
| `Copy ${from} settings to ${to}`, |
| ); |
| } |
| confirm() { |
| if (!this.pending) throw new Error("No replacement is pending."); |
| this.commit(this.pending.study); |
| } |
| dismiss() { |
| if (!this.pending) throw new Error("No replacement is pending."); |
| this.pending = null; |
| this.epoch++; |
| } |
| beginFile() { |
| this.guard(); |
| this.busy = true; |
| return ++this.epoch; |
| } |
| stageFile(ticket, text) { |
| if (!this.busy || ticket !== this.epoch) |
| throw new Error("This file read is stale. Newer work is unchanged."); |
| const candidate = parseStudy(text); |
| this.busy = false; |
| this.pending = { study: candidate, label: "Open saved two-alternative study" }; |
| this.epoch++; |
| } |
| cancelFile(ticket) { |
| if (this.busy && ticket === this.epoch) { |
| this.busy = false; |
| this.epoch++; |
| } |
| } |
| save() { |
| this.guard(); |
| return saveStudy(this.value); |
| } |
| brief() { |
| this.guard(); |
| return studyBrief(this.value); |
| } |
| } |
|
|
