Files
road-compiler/.trellis/tasks/09-08-junction-reference-fidelity/research/preview-scope-experiment.cjs
T

82 lines
5.4 KiB
JavaScript

// Isolated experiment: invokes production pure functions; never writes active data.
// Run from repository root: node .trellis/tasks/09-08-junction-reference-fidelity/research/preview-scope-experiment.cjs
const fs = require('fs');
const { performance } = require('perf_hooks');
const { createHash } = require('crypto');
const { compileRoadModel, compileGeometry, loadOverrides } = require(process.cwd() + '/src/compile/native-road');
const { resolveDirectEditConstraints } = require(process.cwd() + '/src/compile/direct-edit-solver');
const dir = 'workbench-data/import-fE8XI7';
const start = performance.now();
const options = JSON.parse(fs.readFileSync(dir + '/active/area-config.snapshot.json')).options;
const overrides = loadOverrides(dir + '/native-road-overrides.json');
const model = compileRoadModel(fs.readFileSync(dir + '/source.osm', 'utf8'), overrides);
const document = JSON.parse(fs.readFileSync(dir + '/active/native-road-edits.json'));
const cluster = options.junctionTemplates.clusters[0];
const context = { junctionTemplates: options.junctionTemplates, selection: { type: 'cluster', id: cluster.id } };
const byNode = new Map();
for (const e of model.endpoints) { if (!byNode.has(e.nodeId)) byNode.set(e.nodeId, new Set()); byNode.get(e.nodeId).add(e.roadId); }
function scope(depth) {
const nodes = new Set(cluster.nodeIds), roads = new Set();
for (let i = 0; i <= depth; i++) {
for (const node of nodes) for (const id of byNode.get(node) || []) roads.add(id);
for (const e of model.endpoints) if (roads.has(e.roadId)) nodes.add(e.nodeId);
}
const endpoints = model.endpoints.filter(e => roads.has(e.roadId));
const ids = new Set(endpoints.map(e => e.id));
return { ...model, roads: model.roads.filter(r => roads.has(r.id)), endpoints,
connections: model.connections.filter(c => ids.has(c.fromEndpointId) && ids.has(c.toEndpointId)) };
}
function run(m, doc) {
const t = performance.now();
const resolution = resolveDirectEditConstraints(m, doc, context);
const solved = performance.now();
const compiled = compileGeometry(m, overrides, { ...options, directEdit: resolution });
const end = performance.now();
return { compiled, resolution, solveMs: solved-t, compileMs: end-solved, computeMs: end-t };
}
function features(compiled) {
const map = new Map();
for (const [layer, collection] of Object.entries(compiled)) for (const f of collection?.features || []) {
const json = JSON.stringify(f), hash = createHash('sha256').update(json).digest('hex');
const key = layer + ':' + hash;
const old = map.get(key); map.set(key, { count: (old?.count || 0)+1, layer, feature: f });
}
return map;
}
function delta(before, after) {
const result = new Map();
for (const key of new Set([...before.keys(), ...after.keys()])) {
const count = (after.get(key)?.count || 0)-(before.get(key)?.count || 0);
if (count) result.set(key, { ...(after.get(key) || before.get(key)), count });
}
return result;
}
function compare(a,b) {
const mismatches=[];
for(const key of new Set([...a.keys(),...b.keys()])) if(a.get(key)?.count !== b.get(key)?.count) {
const f=a.get(key)||b.get(key); mismatches.push({layer:f.layer,id:f.feature.properties?.native_id,full:a.get(key)?.count||0,local:b.get(key)?.count||0});
}
return {equal:!mismatches.length,mismatchCount:mismatches.length,examples:mismatches.slice(0,8)};
}
const setupMs=performance.now()-start;
const fullBase=run(model,document), fullFeatures=features(fullBase.compiled);
const handle=fullBase.resolution.handles.handles.find(h=>h.kind==='cluster-carriageway-width');
if(!handle) throw Error('Missing width handle');
const scopes=[0,1,2].map(depth=>{const m=scope(depth), base=run(m,document);return {depth,m,base:features(base.compiled),rows:[]};});
console.log(JSON.stringify({setupMs,fullRoads:model.roads.length,scopes:scopes.map(s=>({depth:s.depth,roads:s.m.roads.length})),handle:handle.handleId}));
for(let i=0;i<20;i++) {
const value=handle.value.current + 0.1 + (i%10)*0.1;
const doc={...document,constraints:[...document.constraints,{id:'experiment-width',kind:handle.kind,anchor:handle.anchor,value:{widthMeters:value},enabled:true,status:'exact'}]};
const full=run(model,doc);
if(!full.resolution.constraintStates.find(s=>s.constraintId==='experiment-width')?.applied) throw Error('Edit not applied: '+JSON.stringify(full.resolution.constraintStates));
const reference=delta(fullFeatures,features(full.compiled));
for(const s of scopes) {
const local=run(s.m,doc), diff=delta(s.base,features(local.compiled));
const t=performance.now();const payload=JSON.stringify({changes:[...diff.values()],handles:local.resolution.handles,constraintStates:local.resolution.constraintStates});const serializationMs=performance.now()-t;
const row={run:i,value,depth:s.depth,solveMs:local.solveMs,compileMs:local.compileMs,computeMs:local.computeMs,serializationMs,bytes:Buffer.byteLength(payload),fullComputeMs:full.computeMs,changed:reference.size,comparison:compare(reference,diff)};
s.rows.push(row);console.log(JSON.stringify(row));
}
}
function stats(values){const s=[...values].sort((a,b)=>a-b);return {min:s[0],median:s[Math.floor(s.length/2)],p95:s[Math.ceil(s.length*.95)-1],max:s.at(-1)};}
console.log(JSON.stringify({summary:scopes.map(s=>({depth:s.depth,roads:s.m.roads.length,allDeltasEqual:s.rows.every(r=>r.comparison.equal),computeAndSerializationMs:stats(s.rows.map(r=>r.computeMs+r.serializationMs)),fullComputeMs:stats(s.rows.map(r=>r.fullComputeMs)),bytes:stats(s.rows.map(r=>r.bytes))}))}));