Flow study: 32-bit steps in the mesh and the result fields

/** Flow study + exact build → { job, problems, h, estimate }; check: no mesh copy. (experimental: accepted for old callers; no effect.) */
export function flowJob(st, regen, { check = false, experimental = false } = {}) {
  void experimental;
  const fl = st.flow || newFlow(), problems = [];
  if (!regen || !(regen.exact || regen.named) || !regen.mesh || !regen.faces || !regen.stats) return { job: null, problems: [t('study.flow.problem.need_exact')] };
  const gone = [], openings = fl.openings.map((o) => {
    const idx = o.faces.map((f) => findFaceIndex(regen.faces, f));
    if (idx.some((i) => i < 0)) gone.push(openingName(o));
    return { ...o, faces: idx.filter((i) => i >= 0) };
  });
  if (gone.length) problems.push(t('study.flow.problem.faces_gone', { names: gone.join(', ') }));
  if (fl.type === 'internal') {
    if (!openings.some((o) => o.role === 'inlet')) problems.push(t('study.flow.problem.no_inlet'));
    if (!openings.some((o) => o.role === 'outlet')) problems.push(t('study.flow.problem.no_outlet'));
    for (const o of openings) if (!o.faces.length) problems.push(t('study.flow.problem.no_faces', { name: openingName(o) }));
    const used = new Map();
    for (const o of openings) for (const f of o.faces) { if (used.has(f) && used.get(f) !== o.id) problems.push(t('study.flow.problem.face_twice', { name: openingName(o) })); used.set(f, o.id); }
  }
  const bbox = regen.stats.bbox, h = fl.h || autoCell(fl, bbox), est = cellEstimate(fl, bbox, h);
  if (est.cells > FLOW_LIMITS.gridCells) problems.push(t('study.flow.problem.grid_cells', { cells: est.cells.toLocaleString('en-US'), max: FLOW_LIMITS.gridCells.toLocaleString('en-US') }));
  const fluid = fluidOf(fl.fluid);
  const meshCopy = check ? null : { positions: Float32Array.from(regen.mesh.positions), indices: Uint32Array.from(regen.mesh.indices), triFace: regen.mesh.triFace ? Int32Array.from(regen.mesh.triFace) : null };
  const job = {
    type: fl.type, h, fluid: { name: fluid.name, density: fluid.density, viscosity: fluid.viscosity }, wall: fl.wall, model: fl.model || 'laminar', maxSteps: fl.maxSteps, tol: fl.tol,
    openings: openings.map((o) => ({ id: o.id, role: o.role, faces: o.faces, spec: o.spec, value: o.value, p: o.p })),
    faces: regen.faces.map((f) => ({ type: f.type, n: f.n ? f.n.slice() : null, o: f.o ? f.o.slice() : null, area: f.area })),
    ext: fl.type === 'external' ? { ...boxOf(fl.ext, bbox), speed: fl.ext.speed, dir: unitv(fl.ext.dir), lift: liftDir(fl.ext), refArea: fl.ext.refArea } : null,
    mesh: meshCopy, bbox: { min: bbox.min.slice(), max: bbox.max.slice() },
  };
  return { job, problems, h, estimate: est };
}

const mask = new Uint8Array(ncell), vx = new Float32Array(ncell), vy = new Float32Array(ncell), vz = new Float32Array(ncell), p = new Float32Array(ncell), nut = turb ? new Float32Array(ncell) : null;
let vmax = 0, pmin = Infinity, pmax = -Infinity;
for (let e = 0; e < ncell; e++) { if (dom.kind[e] >= 1) mask[e] = 2; p[e] = NaN; }
for (let n = 0; n < lat.nf; n++) {
  const e = lat.cells[n];
  mask[e] = 1; vx[e] = S.ux[n] * cu; vy[e] = S.uy[n] * cu; vz[e] = S.uz[n] * cu;
  p[e] = pref + (S.rho[n] - 1) / 3 * cp;
  if (nut) nut[e] = S.nut[n] / sc.nu;
  vmax = Math.max(vmax, Math.hypot(vx[e], vy[e], vz[e])); pmin = Math.min(pmin, p[e]); pmax = Math.max(pmax, p[e]);
}

/** Static pressure at the part's surface: per vertex, sampled half a cell into the fluid along the vertex normal (trilinear over fluid cells; NaN where no fluid touches). */
export function surfacePressure(pm, F) {
  const P = pm.positions, I = pm.indices, nv = P.length / 3, nrm = new Float64Array(nv * 3), out = new Float32Array(nv);
  for (let t = 0; t < I.length; t += 3) {
    const a = 3 * I[t], b = 3 * I[t + 1], c = 3 * I[t + 2];
    const u = [P[b] - P[a], P[b + 1] - P[a + 1], P[b + 2] - P[a + 2]], w = [P[c] - P[a], P[c + 1] - P[a + 1], P[c + 2] - P[a + 2]];
    const n = [u[1] * w[2] - u[2] * w[1], u[2] * w[0] - u[0] * w[2], u[0] * w[1] - u[1] * w[0]];
    for (const v of [a, b, c]) { nrm[v] += n[0]; nrm[v + 1] += n[1]; nrm[v + 2] += n[2]; }
  }
  const { nx, ny, nz, h, origin, mask, p } = F;
  for (let v = 0; v < nv; v++) {
    const l = Math.hypot(nrm[3 * v], nrm[3 * v + 1], nrm[3 * v + 2]) || 1;
    let best = NaN;
    for (const off of [0.75, 1.25, 0.35, 1.75]) {
      const x = (P[3 * v] + off * h * nrm[3 * v] / l - origin[0]) / h - 0.5, y = (P[3 * v + 1] + off * h * nrm[3 * v + 1] / l - origin[1]) / h - 0.5, z = (P[3 * v + 2] + off * h * nrm[3 * v + 2] / l - origin[2]) / h - 0.5;
      const i = Math.floor(x), j = Math.floor(y), k = Math.floor(z), tx = x - i, ty = y - j, tz = z - k;
      let s = 0, ws = 0;
      for (let cn = 0; cn < 8; cn++) {
        const ii = i + (cn & 1), jj = j + ((cn >> 1) & 1), kk = k + ((cn >> 2) & 1);
        if (ii < 0 || jj < 0 || kk < 0 || ii >= nx || jj >= ny || kk >= nz) continue;
        const e = ii + nx * (jj + ny * kk);
        if (mask[e] !== 1) continue;
        const w = (cn & 1 ? tx : 1 - tx) * ((cn >> 1) & 1 ? ty : 1 - ty) * ((cn >> 2) & 1 ? tz : 1 - tz) + 1e-6;
        s += w * p[e]; ws += w;
      }
      if (ws > 0) { best = s / ws; break; }
    }
    out[v] = best;
  }
  return out;
}

function probe(host, ev) {
  if (!F.probeEl || !fresh(host) || !ev) return;
  const objs = ['plane', 'surface'].map((k) => host.view.overlays && host.view.overlays.get(OV + k)).filter(Boolean);
  const hit = objs.length ? host.view.ray(ev.clientX, ev.clientY).intersectObjects(objs, false)[0] : null;
  if (!hit) { F.probeEl.textContent = t('study.flow.ui.probe.hint'); return; }
  const r = F.result, Fd = r.fields, p = hit.point.toArray(), at = p.map((v) => U.fmt(v, 2)).join(', ');
  if (hit.object.userData.flowPlot === 'plane') {
    const ijk = [0, 1, 2].map((a) => Math.min([Fd.nx, Fd.ny, Fd.nz][a] - 1, Math.max(0, Math.floor((p[a] - Fd.origin[a]) / Fd.h))));
    const e = ijk[0] + Fd.nx * (ijk[1] + Fd.ny * ijk[2]);
    if (Fd.mask[e] !== 1) { F.probeEl.textContent = t('study.flow.ui.probe.not_fluid', { at }); return; }
    F.probeEl.textContent = t('study.flow.ui.probe.cell', { speed: U.sig(Math.hypot(Fd.vx[e], Fd.vy[e], Fd.vz[e])), v: [Fd.vx[e], Fd.vy[e], Fd.vz[e]].map((v) => U.sig(v)).join(', '), p: U.sig(Fd.p[e]), at });
    return;
  }
  const v = U.valueAt(r.plotMesh, r.surfP, hit.faceIndex, p);
  F.probeEl.textContent = Number.isFinite(v) ? t('study.flow.ui.probe.surface', { p: U.sig(v), at }) : t('study.flow.ui.probe.dry', { at });
}

const mach = r.vmax * r.lattice.dt / (r.mesh.h / 1000) * Math.sqrt(3);   // the fastest cell, in lattice speed of sound