Running saved geotechnical, survey, pit and link items

export const FT = 0.3048;
export const toM = (units) => (units === 'ft' ? FT : 1);

export function runProfile(geo, sectionId, units, { step = null } = {}) {
  const sec = (geo?.sections || []).find((s) => s.id === sectionId); if (!sec) return null;
  const k = toM(units), borings = (geo.borings || []).map((b) => ({ ...b, x: b.x * k, y: b.y * k, z: b.z * k, depth: b.depth * k, water: b.water === null ? null : b.water * k, layers: b.layers.map((l) => ({ ...l, from: l.from * k, to: l.to * k })) }));
  const prof = sectionProfile(borings, pl(sec.line, k), { width: sec.width * k });
  const n = Math.max(2, Math.round(prof.length / (step ? step * k : Math.max(prof.length / 40, 0.5))));
  prof.stations = Array.from({ length: n + 1 }, (_, i) => { const sta = (prof.length * i) / n; return { sta, stack: stackAt(prof, sta) }; });
  return { section: sec, profile: prof, k };
}

export function slopeGeometry(geo, slope, units, ground, { points = 80 } = {}) {
  const p = runProfile(geo, slope.section, units); if (!p) return { problems: [{ code: 'geo.slope.nosection' }] };
  const { profile, k } = p, L = profile.length; if (!ground) return { problems: [{ code: 'geo.slope.noground' }] };
  const line = pl(p.section.line, k), pos = (d) => { let acc = 0; for (let i = 1; i < line.length; i++) { const a = line[i - 1], b = line[i], l = Math.hypot(b.x - a.x, b.y - a.y); if (d <= acc + l || i === line.length - 1) { const u = Math.max(0, Math.min(1, (d - acc) / l)); return { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u }; } acc += l; } return line[0]; };
  const gz = (d) => { const q = pos(d), v = ground.elevationAt(q.x / k, q.y / k); return v === null || v === undefined ? NaN : v * k; };
  const gp = []; for (let i = 0; i <= points; i++) { const d = (L * i) / points, z = gz(d); if (Number.isFinite(z)) gp.push({ x: d, z }); }
  if (gp.length < 3) return { problems: [{ code: 'geo.slope.noground' }] };
  // units from the profile (named strata, top first at each station); a unit's top line = its top at every station where it exists
  const units_ = []; for (const s of profile.strata) units_.push(s.unit);
  const topLine = (unit) => { const pts = []; for (let i = 0; i <= points; i++) { const d = (L * i) / points, st = stackAt(profile, d).find((q) => q.unit === unit); if (st) pts.push({ x: d, z: Math.min(st.top, gp[Math.min(i, gp.length - 1)].z) }); } return pts; };
  const mats = slope.materials || {}, byUnit = {};
  for (const b of geo.borings || []) for (const l of b.layers) if (!byUnit[l.unit]) byUnit[l.unit] = l;
  const layers = [];
  const order = units_.map((u) => ({ u, line: topLine(u) })).filter((q) => q.line.length).sort((a, b) => b.line.reduce((s, q) => s + q.z, 0) / b.line.length - a.line.reduce((s, q) => s + q.z, 0) / a.line.length);
  for (const { u, line: tl } of order) { const m = mats[u] || byUnit[u] || { gamma: 18, c: 0, phi: 28 }; layers.push({ name: u, top: tl.length > 1 ? tl : [{ x: 0, z: tl[0].z }, { x: L, z: tl[0].z }], gamma: m.gamma, c: m.c, phi: m.phi, ...(m.cu !== undefined ? { cu: m.cu } : {}) }); }
  if (!layers.length) layers.push({ name: 'soil', top: gp.map((q) => ({ ...q })), gamma: 18, c: 5, phi: 28 });
  layers[0].top = gp.map((q) => ({ ...q }));   // the first layer starts at the ground
  const floor = slope.floor !== null && slope.floor !== undefined ? slope.floor * k : Math.min(...profile.borings.map((b) => b.z - b.depth), Math.min(...gp.map((q) => q.z)) - 0.5 * (Math.max(...gp.map((q) => q.z)) - Math.min(...gp.map((q) => q.z))));
  const geom = { ground: gp, layers, water: slope.water === null || slope.water === undefined ? null : slope.water * k, ru: slope.ru || 0, surcharge: (slope.surcharge || []).map((s) => ({ x0: s.x0 * k, x1: s.x1 * k, q: s.q })), floor };
  return { geom, profile, k, problems: profile.problems || [] };
}

export function runSlope(geo, slope, units, ground, { search = true, circle = null, slices = 60 } = {}) {
  const g = slopeGeometry(geo, slope, units, ground); if (!g.geom) return { problems: g.problems };
  const o = { method: slope.method, kh: slope.kh, slices };
  if (circle) { const r = bishop(g.geom, { xc: circle.xc * g.k, zc: circle.zc * g.k, R: circle.R * g.k }, o); return { geom: g.geom, fs: r.fs, critical: { circle, fs: r.fs, xl: r.xl, xr: r.xr }, problems: r.problems, k: g.k }; }
  const r = searchSlip(g.geom, { ...o, nx: 14, nz: 10, nr: 14 });
  return { geom: g.geom, fs: r.critical ? r.critical.fs : NaN, critical: r.critical, grid: r.grid, problems: [...(r.problems || []), ...(r.critical?.problems || []), ...(r.critical ? (r.critical.fs < FS_TARGETS.long ? [{ code: 'geo.slope.low', value: r.critical.fs, limit: FS_TARGETS.long }] : []) : [])], k: g.k, tried: r.tried };
}

export function runSettlement(geo, s, units) {
  const b = (geo?.borings || []).find((x) => x.id === s.boring); if (!b) return { problems: [{ code: 'geo.settle.noboring' }] };
  const k = toM(units), layers = b.layers.map((l) => ({ top: (b.z - l.from) * k, bottom: (b.z - l.to) * k, gamma: l.gamma, gammaSat: l.gammaSat, cc: l.cc, cs: l.cs, e0: l.e0, sigmaC: l.sigmaC, es: l.es, nu: l.nu, cv: l.cv }));
  const water = s.water !== null && s.water !== undefined ? (b.z - s.water) * k : b.water !== null ? (b.z - b.water) * k : null;
  const base = layers[0].top + (s.load.depth || 0) * 0;
  const res = settlement({ layers, load: { q: s.load.q, B: s.load.B * k, L: s.load.L * k, depth: base - Math.max(s.load.depth, 0) * k, at: s.load.at, method: s.load.method }, water, ground: layers[0].top, step: 1 });
  const clay = b.layers.filter((l) => l.cv && l.cc);
  let time = null;
  if (clay.length && res.consolidation > 0) { const l = clay[0], H = ((l.to - l.from) * k) / 2, cv = l.cv; time = { t50: timeFor(0.5, H, cv), t90: timeFor(0.9, H, cv), curve: timeCurve(res.consolidation, H, cv, timeFor(0.95, H, cv), 20), Hdr: H, cv }; }
  const problems = res.total > 0.025 ? [{ code: 'geo.settle.total', value: res.total, limit: 0.025 }] : [];
  return { ...res, time, problems };
}

/** A traverse (start, legs of distance + azimuth in degrees, optionally a known end) closed by the compass rule. Lengths in the project unit. */
export function runTraverse(tv) {
  const r = bowditch(tv.start, tv.legs.map((l) => ({ dist: l.dist, az: l.az * D2R })), { end: tv.end || null });
  const problems = r.precision < 5000 ? [{ code: 'geo.traverse.loose', value: r.precision }] : [];
  return { ...r, problems };
}

export function runLink(l, units, ground) {
  const k = toM(units), A = { x: l.a.x * k, y: l.a.y * k }, B = { x: l.b.x * k, y: l.b.y * k };
  const g = (x, y) => { const v = ground ? ground.elevationAt(x / k, y / k) : 0; return v === null || v === undefined ? NaN : v * k; };
  const terrain = terrainAlong(g, A, B, 100), dKm = Math.hypot(B.x - A.x, B.y - A.y) / 1000;
  const los = losProfile(terrain, { hA: l.a.h * k, hB: l.b.h * k, f: l.f, k: l.k, clutter: l.clutter * k });
  const budget = linkBudget({ pt: l.pt, gt: l.gt, gr: l.gr, dKm, fMHz: l.f * 1000, sensitivity: l.sensitivity });
  const mast = los.clear ? null : mastHeightFor(terrain, { hB: l.b.h * k, f: l.f, k: l.k, clutter: l.clutter * k });
  const avail = availability({ dKm, fGHz: l.f, fadeMargin: budget.margin, terrain: l.terrain }), tower = l.towerWidth > 0 ? towerBase({ height: l.a.h * k, width: l.towerWidth * k, solidity: l.towerSolidity, antennas: [{ area: l.antennaArea * k * k, h: l.a.h * k, cd: 1.2 }], v: l.wind, weight: l.towerWeight, footing: l.footing * k }) : null;
  const problems = []; if (!los.clear) problems.push({ code: 'tel.los.blocked', clearance: los.min?.clearance, ratio: los.min?.ratio });
  if (budget.margin < 10) problems.push({ code: 'tel.margin.low', margin: budget.margin });
  // 0.8 EG.28: the legs under that wind moment, against the person's capacity and factor (no code's numbers are built in)
  const legs = tower ? towerLegs({ legs: l.towerLegs, width: l.towerWidth * k, moment: tower.moment, vertical: l.towerWeight, legCapacity: l.legCapacity, loadFactor: l.loadFactor, E: l.legE, I: l.legI, L: l.legLength * k, K: l.legK }) : null;
  if (legs?.utilization > 1) problems.push({ code: 'tel.leg.over', util: legs.utilization });
  if (legs?.bucklingUtil > 1) problems.push({ code: 'tel.leg.buckling', util: legs.bucklingUtil });
  return { terrain, los, budget, mast: mast === null ? null : mast / k, dKm, fspl: fspl(dKm, l.f * 1000), availability: avail, tower, legs, problems };
}

/** A coverage sketch: the received power over the ground around a transmitter (telecom.js coverage). `ground(x, y)` in the project unit, like runLink's. */
export function runCover(c, units, ground) {
  const k = toM(units), g = (x, y) => { const v = ground ? ground.elevationAt(x / k, y / k) : 0; return v === null || v === undefined ? NaN : v * k; };
  const n = Math.floor(c.range / c.step);
  if (n > 150) return { ok: false, problems: [{ code: 'tel.cover.fine', cells: (2 * n + 1) ** 2 }] };
  const r = coverage(g, { x: c.tx.x * k, y: c.tx.y * k, h: c.tx.h * k }, { f: c.f, pt: c.pt, gt: c.gt, gr: c.gr, sensitivity: c.sensitivity, rxH: c.rxH * k, radius: c.range * k, step: c.step * k, k: c.k, clutter: c.clutter * k });
  let far = 0; for (let j = 0; j < r.ny; j++) for (let i = 0; i < r.nx; i++) { const p = r.pr[i + r.nx * j]; if (p >= c.sensitivity) far = Math.max(far, Math.hypot(r.x0 + i * r.step - c.tx.x * k, r.y0 + j * r.step - c.tx.y * k)); }
  const problems = [];
  if (!r.cells) problems.push({ code: 'tel.cover.noground' });
  return { ok: true, ...r, farthest: far / k, problems };
}

export function runPit(p, units) {
  const k = toM(units), model = makeModel({ nx: p.nx, ny: p.ny, nz: p.nz, size: p.size.map((v) => v * k), origin: p.origin.map((v) => v * k), density: p.density });
  idw(model, p.samples.map((s) => ({ x: s.x * k, y: s.y * k, z: s.z * k, grade: s.grade })), { power: 2, radius: Infinity });
  const values = blockValues(model, { price: p.price, recovery: p.recovery, processCost: p.processCost, miningCost: p.miningCost });
  const rampW = (p.rampWidth || 0) * k, slopeRad = p.rampOn === 'yes' && rampW > 0 ? slopeWithRamp(p.slope * D2R, p.size[2] * k, rampW) : p.slope * D2R;   // a ramp lane on every bench flattens the wall (spiral ramp)
  const result = ultimatePit(model, values, { slope: slopeRad });
  let phases = null, plan = null;
  if (p.phases > 0) {
    const n = Math.max(1, Math.round(p.phases)), factors = Array.from({ length: n }, (_, i) => (n === 1 ? 1 : 0.4 + (0.6 * i) / (n - 1)));
    phases = nestedPits(model, { price: p.price, recovery: p.recovery, processCost: p.processCost, miningCost: p.miningCost }, { factors, slope: slopeRad });
    if (p.oreCapacity > 0 || p.moveCapacity > 0) plan = schedule(model, phases, values, { oreCapacity: p.oreCapacity > 0 ? p.oreCapacity : Infinity, moveCapacity: p.moveCapacity > 0 ? p.moveCapacity : Infinity, discount: p.discount });
  }
  const summary = pitSummary(model, values, result), ramp = rampLength({ benchHeight: p.size[2] * k, grade: p.rampGrade || 0.1, benches: Math.max(0, summary.benches.length) });
  // the haul ramp laid on the pit's walls and the problems it raises (rule 29): the road is a sketch on the block model's stepped walls
  const road = rampW > 0 ? rampRoute(model, result.mined, { grade: p.rampGrade || 0.1, width: rampW }) : null;
  const problems = (road?.flags || []).filter((f) => f !== 'noRamp').map((code) => ({ code: 'pit.ramp.' + code, item: p.name || p.id }));
  return { model, values, result, phases, plan, ramp, road, problems, slopeUsed: slopeRad / D2R, summary, gradeTonnage: gradeTonnage(model, [0, 0.25, 0.5, 1, 2, 4].map((v) => v * (Math.max(...model.grade) / 4 || 1)), result.mined) };
}