Antenna Radiation Pattern Visualizer

Start from a preset

Geometry

Advanced

Wire	From (m)			To (m)			Thick. mm	Mesh
Wire	E	N	Up	E	N	Up	Thick. mm	Mesh

Drag the blue handles in the 3D view to reshape the antenna. The red dot is the feed point.

Feed point

Where the feed line connects.

On wire

Position along that wire · 50% one endmiddleother end

Simulation

Frequency (MHz)

λ = 42.22 m · 40 m band

Environment

Height above ground · 0.0 m

Feed line impedance (Ω)

Conductor material

Pattern Antenna Current colours dB range Opacity

low

peak

Pattern cuts

SWR vs frequency

±% pts

// ===== src/core/constants.js =====
// Physical constants (SI units) used throughout the electromagnetic solver.
export const C0 = 299792458;
export const MU0 = 4e-7 * Math.PI;
export const EPS0 = 1 / (MU0 * C0 * C0);
export const ETA0 = Math.sqrt(MU0 / EPS0);

export const MATERIALS = {
  pec: { label: 'Perfect conductor', sigma: 0 },
  copper: { label: 'Copper', sigma: 5.8e7 },
  aluminium: { label: 'Aluminium', sigma: 3.5e7 },
  brass: { label: 'Brass', sigma: 1.5e7 },
  steel: { label: 'Steel', sigma: 1.45e6 },
  stainless: { label: 'Stainless steel', sigma: 1.1e6 },
};

// Amateur allocations in MHz, widest of the three ITU regions.
export const AMATEUR_BANDS = [
  { name: '2200 m', start: 0.1357, stop: 0.1378 },
  { name: '630 m', start: 0.472, stop: 0.479 },
  { name: '160 m', start: 1.8, stop: 2.0 },
  { name: '80 m', start: 3.5, stop: 4.0 },
  { name: '60 m', start: 5.3515, stop: 5.3665 },
  { name: '40 m', start: 7.0, stop: 7.3 },
  { name: '30 m', start: 10.1, stop: 10.15 },
  { name: '20 m', start: 14.0, stop: 14.35 },
  { name: '17 m', start: 18.068, stop: 18.168 },
  { name: '15 m', start: 21.0, stop: 21.45 },
  { name: '12 m', start: 24.89, stop: 24.99 },
  { name: '10 m', start: 28.0, stop: 29.7 },
  { name: '6 m', start: 50.0, stop: 54.0 },
  { name: '4 m', start: 70.0, stop: 70.5 },
  { name: '2 m', start: 144.0, stop: 148.0 },
  { name: '1.25 m', start: 222.0, stop: 225.0 },
  { name: '70 cm', start: 430.0, stop: 440.0 },
  { name: '33 cm', start: 902.0, stop: 928.0 },
  { name: '23 cm', start: 1240.0, stop: 1300.0 },
];

export function bandFor(frequencyMHz) {
  return AMATEUR_BANDS.find((b) => frequencyMHz >= b.start && frequencyMHz <= b.stop) ?? null;
}

// ===== src/core/linalg.js =====
// Dense complex linear algebra on interleaved Float64Arrays ([re, im, re, im, ...]).
// Matrices are row-major: element (i, j) lives at offset 2 * (i * n + j).

export function createMatrix(n) {
  return new Float64Array(2 * n * n);
}

export function createVector(n) {
  return new Float64Array(2 * n);
}

/**
 * In-place LU factorisation with partial pivoting.
 * @returns {Int32Array} pivot row indices
 */
export function luFactor(A, n) {
  const piv = new Int32Array(n);
  for (let k = 0; k < n; k++) {
    let best = -1;
    let bestMag = -1;
    for (let i = k; i < n; i++) {
      const o = 2 * (i * n + k);
      const mag = A[o] * A[o] + A[o + 1] * A[o + 1];
      if (mag > bestMag) {
        bestMag = mag;
        best = i;
      }
    }
    if (bestMag === 0) throw new Error('Impedance matrix is singular — check the geometry for overlapping or zero-length wires.');
    piv[k] = best;
    if (best !== k) {
      const ro = 2 * k * n;
      const rb = 2 * best * n;
      for (let j = 0; j < 2 * n; j++) {
        const t = A[ro + j];
        A[ro + j] = A[rb + j];
        A[rb + j] = t;
      }
    }
    const dk = 2 * (k * n + k);
    const dr = A[dk];
    const di = A[dk + 1];
    const den = dr * dr + di * di;
    for (let i = k + 1; i < n; i++) {
      const oi = 2 * (i * n + k);
      const ar = A[oi];
      const ai = A[oi + 1];
      const mr = (ar * dr + ai * di) / den;
      const mi = (ai * dr - ar * di) / den;
      A[oi] = mr;
      A[oi + 1] = mi;
      if (mr === 0 && mi === 0) continue;
      for (let j = k + 1; j < n; j++) {
        const ok = 2 * (k * n + j);
        const oj = 2 * (i * n + j);
        const kr = A[ok];
        const ki = A[ok + 1];
        A[oj] -= mr * kr - mi * ki;
        A[oj + 1] -= mr * ki + mi * kr;
      }
    }
  }
  return piv;
}

/** Solves L*U*x = b in place on b. */
export function luSolve(A, piv, b, n) {
  // The stored L columns are in the fully permuted ordering, so every row
  // interchange has to be applied to the right-hand side up front.
  for (let k = 0; k < n; k++) {
    const p = piv[k];
    if (p === k) continue;
    const t0 = b[2 * k];
    const t1 = b[2 * k + 1];
    b[2 * k] = b[2 * p];
    b[2 * k + 1] = b[2 * p + 1];
    b[2 * p] = t0;
    b[2 * p + 1] = t1;
  }
  for (let i = 1; i < n; i++) {
    let sr = b[2 * i];
    let si = b[2 * i + 1];
    for (let j = 0; j < i; j++) {
      const o = 2 * (i * n + j);
      const mr = A[o];
      const mi = A[o + 1];
      const xr = b[2 * j];
      const xi = b[2 * j + 1];
      sr -= mr * xr - mi * xi;
      si -= mr * xi + mi * xr;
    }
    b[2 * i] = sr;
    b[2 * i + 1] = si;
  }
  for (let i = n - 1; i >= 0; i--) {
    let sr = b[2 * i];
    let si = b[2 * i + 1];
    for (let j = i + 1; j < n; j++) {
      const o = 2 * (i * n + j);
      const ar = A[o];
      const ai = A[o + 1];
      const xr = b[2 * j];
      const xi = b[2 * j + 1];
      sr -= ar * xr - ai * xi;
      si -= ar * xi + ai * xr;
    }
    const d = 2 * (i * n + i);
    const dr = A[d];
    const di = A[d + 1];
    const den = dr * dr + di * di;
    b[2 * i] = (sr * dr + si * di) / den;
    b[2 * i + 1] = (si * dr - sr * di) / den;
  }
  return b;
}

export function cdiv(ar, ai, br, bi) {
  const den = br * br + bi * bi;
  return [(ar * br + ai * bi) / den, (ai * br - ar * bi) / den];
}

// ===== src/core/mesh.js =====
// Converts an antenna model (list of straight wires) into a MoM mesh:
// a list of straight segments plus overlapping triangular (piecewise-linear)
// current basis functions defined around each wire node.

const NODE_TOL = 1e-6; // metres — endpoints closer than this are the same node
const GROUND_TOL = 1e-6;

function key(p) {
  return `${Math.round(p[0] / NODE_TOL)}|${Math.round(p[1] / NODE_TOL)}|${Math.round(p[2] / NODE_TOL)}`;
}

/**
 * Builds the discretised mesh.
 * @param {object} model antenna model
 * @returns {{segments:Array, bases:Array, feedBasis:number, warnings:string[]}}
 */
export function buildMesh(model) {
  const warnings = [];
  const lambda = C0 / (model.frequencyMHz * 1e6);
  const segments = [];
  const nodes = [];
  const nodeMap = new Map();

const wireNodeIds = new Map();
  const dz = model.heightOffset ?? 0;

for (const wire of model.wires) {
    const n = Math.max(1, Math.round(wire.segments));
    const [x1, y1] = wire.p1;
    const [x2, y2] = wire.p2;
    const z1 = wire.p1[2] + dz;
    const z2 = wire.p2[2] + dz;
    const total = Math.hypot(x2 - x1, y2 - y1, z2 - z1);
    if (total < 1e-9) {
      warnings.push(`Wire "${wire.name}" has zero length and was ignored.`);
      continue;
    }
    const segLen = total / n;
    if (segLen < 4 * wire.radius) {
      warnings.push(`Wire "${wire.name}": segment length is only ${(segLen / wire.radius).toFixed(1)}× the radius (thin-wire theory needs ≳ 8×). Reduce the segment count or the radius.`);
    }
    if (segLen > lambda / 8) {
      warnings.push(`Wire "${wire.name}": segments are ${(segLen / lambda).toFixed(3)} λ long (use ≤ 0.1 λ for accurate results).`);
    }

const ids = [];
    for (let i = 0; i <= n; i++) {
      const t = i / n;
      ids.push(nodeIndex([x1 + (x2 - x1) * t, y1 + (y2 - y1) * t, z1 + (z2 - z1) * t]));
    }
    wireNodeIds.set(wire.id, ids);

for (let i = 0; i < n; i++) {
      const a = nodes[ids[i]].pos;
      const b = nodes[ids[i + 1]].pos;
      const segIdx = segments.length;
      segments.push({
        wireId: wire.id,
        n1: ids[i],
        n2: ids[i + 1],
        p1: a,
        p2: b,
        len: segLen,
        dir: [(b[0] - a[0]) / segLen, (b[1] - a[1]) / segLen, (b[2] - a[2]) / segLen],
        radius: wire.radius,
        sigma: wire.conductivity ?? 0,
      });
      nodes[ids[i]].conns.push({ seg: segIdx, atEnd: 0 });
      nodes[ids[i + 1]].conns.push({ seg: segIdx, atEnd: 1 });
    }
  }

const groundOn = model.ground === 'perfect';

// Entry describes the current ramp of one basis function on one segment.
  // r(t) = Q + t * D for t in [0, 1]; current profile p(t) = t; direction u.
  const makeEntry = (conn, nodePos, rise) => {
    const seg = segments[conn.seg];
    const far = conn.atEnd === 1 ? seg.p1 : seg.p2;
    const d = [nodePos[0] - far[0], nodePos[1] - far[1], nodePos[2] - far[2]];
    const s = rise ? 1 : -1;
    return {
      seg: conn.seg,
      qx: far[0], qy: far[1], qz: far[2],
      dx: d[0], dy: d[1], dz: d[2],
      ux: (s * d[0]) / seg.len,
      uy: (s * d[1]) / seg.len,
      uz: (s * d[2]) / seg.len,
      L: seg.len,
      div: s / seg.len,
      radius: seg.radius,
      sigma: seg.sigma,
      rise,
    };
  };

if (groundOn) {
    for (const seg of segments) {
      if (seg.p1[2] < -GROUND_TOL || seg.p2[2] < -GROUND_TOL) {
        warnings.push('Part of the geometry is below the ground plane (z < 0). Results there are not physical.');
        break;
      }
    }
  }

const feedBasis = resolveFeed(model, wireNodeIds, nodes, bases, segments, warnings);
  return { segments, nodes, bases, feedBasis, warnings, lambda };
}

function resolveFeed(model, wireNodeIds, nodes, bases, segments, warnings) {
  const feed = model.feed;
  const wire = model.wires.find((w) => w.id === feed?.wireId) ?? model.wires[0];
  if (!wire) return -1;
  const ids = wireNodeIds.get(wire.id);
  if (!ids) return -1;
  const n = ids.length - 1;
  const groundedEndsAllowed = model.ground === 'perfect';
  let idx = Math.round((feed?.fraction ?? 0.5) * n);
  idx = Math.min(n, Math.max(0, idx));
  if (!groundedEndsAllowed) idx = Math.min(n - 1, Math.max(1, idx));

// ===== src/core/mom.js =====
// Thin-wire Electric Field Integral Equation solved with a Galerkin
// method of moments (triangular basis + reduced kernel), optionally with a
// perfectly conducting ground plane at z = 0 handled by image theory.

// 4-point Gauss–Legendre nodes/weights mapped to [0, 1].
const GT = [0.0694318442029737, 0.3300094782075719, 0.6699905217924281, 0.9305681557970263];
const GW = [0.1739274225687269, 0.3260725774312731, 0.3260725774312731, 0.1739274225687269];

const MAX_OUTER = 16;
const INNER_SUB = 2;

/** Squared distance from point p to the segment q0 -> q0 + d. */
function pointSegDist2(px, py, pz, qx, qy, qz, dx, dy, dz, len2) {
  let t = ((px - qx) * dx + (py - qy) * dy + (pz - qz) * dz) / len2;
  t = t < 0 ? 0 : t > 1 ? 1 : t;
  const ex = px - (qx + t * dx);
  const ey = py - (qy + t * dy);
  const ez = pz - (qz + t * dz);
  return ex * ex + ey * ey + ez * ez;
}

/**
 * Integrates the potential kernels over a pair of basis entries using
 * singularity extraction: the static 1/R part of the inner integral is
 * evaluated in closed form, the remaining (exp(-jkR) - 1)/R part is smooth.
 *
 * out = [I1re, I1im, I0re, I0im] with
 *   I1 = ∫∫ p_a p_b G dl dl'   and   I0 = ∫∫ G dl dl'
 */
function pairIntegrals(ea, eb, k, mirror, out) {
  const qbx = eb.qx;
  const qby = eb.qy;
  const qbz = mirror ? -eb.qz : eb.qz;
  const dbx = eb.dx;
  const dby = eb.dy;
  const dbz = mirror ? -eb.dz : eb.dz;
  const Lb = eb.L;
  const ubx = dbx / Lb;
  const uby = dby / Lb;
  const ubz = dbz / Lb;
  const a2 = eb.radius * eb.radius;
  const lb2 = Lb * Lb;

// Closest approach between the two segments drives the outer subdivision.
  let dmin2 = Infinity;
  for (let i = 0; i <= 4; i++) {
    const t = i / 4;
    const d2 = pointSegDist2(
      ea.qx + t * ea.dx, ea.qy + t * ea.dy, ea.qz + t * ea.dz,
      qbx, qby, qbz, dbx, dby, dbz, lb2,
    );
    if (d2 < dmin2) dmin2 = d2;
  }
  const scale = Math.max(Math.sqrt(dmin2), 0.5 * (ea.radius + eb.radius));
  const nOuter = Math.min(MAX_OUTER, Math.max(2, Math.ceil((1.2 * ea.L) / scale)));

let i1r = 0, i1i = 0, i0r = 0, i0i = 0;

for (let io = 0; io < nOuter; io++) {
    for (let p = 0; p < 4; p++) {
      const ta = (io + GT[p]) / nOuter;
      const wa = GW[p] / nOuter;
      const rx = ea.qx + ta * ea.dx;
      const ry = ea.qy + ta * ea.dy;
      const rz = ea.qz + ta * ea.dz;

// --- static part, exact ---
      const wx = rx - qbx;
      const wy = ry - qby;
      const wz = rz - qbz;
      const s0 = wx * ubx + wy * uby + wz * ubz;
      const h2 = Math.max(wx * wx + wy * wy + wz * wz - s0 * s0 + a2, 1e-30);
      const h = Math.sqrt(h2);
      const A = -s0;
      const B = Lb - s0;
      const ra = Math.sqrt(A * A + h2);
      const rb = Math.sqrt(B * B + h2);
      const f0 = Math.asinh(B / h) - Math.asinh(A / h);
      const stat0 = f0;
      const stat1 = (rb - ra + s0 * f0) / Lb;

// --- dynamic remainder (exp(-jkR) - 1)/R, smooth ---
      let d0r = 0, d0i = 0, d1r = 0, d1i = 0;
      for (let ii = 0; ii < INNER_SUB; ii++) {
        for (let q = 0; q < 4; q++) {
          const tb = (ii + GT[q]) / INNER_SUB;
          const wb = (GW[q] / INNER_SUB) * Lb;
          const ex = rx - (qbx + tb * dbx);
          const ey = ry - (qby + tb * dby);
          const ez = rz - (qbz + tb * dbz);
          const R = Math.sqrt(ex * ex + ey * ey + ez * ez + a2);
          const kr = k * R;
          const gr = (Math.cos(kr) - 1) / R;
          const gi = -Math.sin(kr) / R;
          d0r += wb * gr;
          d0i += wb * gi;
          d1r += wb * tb * gr;
          d1i += wb * tb * gi;
        }
      }

i0r += wa * (stat0 + d0r);
      i0i += wa * d0i;
      i1r += wa * ta * (stat1 + d1r);
      i1i += wa * ta * d1i;
    }
  }

const La = ea.L;
  out[0] = i1r * La;
  out[1] = i1i * La;
  out[2] = i0r * La;
  out[3] = i0i * La;
}

/** Surface impedance per unit length of a round wire (high-frequency skin effect). */
function surfaceImpedance(sigma, radius, omega) {
  if (!sigma || sigma <= 0) return 0;
  const rs = Math.sqrt((omega * MU0) / (2 * sigma));
  return rs / (2 * Math.PI * radius);
}

/**
 * Assembles the N×N complex impedance matrix of the structure.
 */
export function fillImpedanceMatrix(mesh, frequency, ground) {
  const bases = mesh.bases;
  const n = bases.length;
  const Z = createMatrix(n);
  const omega = 2 * Math.PI * frequency;
  const k = omega / C0;
  const pre = ETA0 / (4 * Math.PI);
  const useImage = ground === 'perfect';
  const buf = new Float64Array(4);

for (let m = 0; m < n; m++) {
    const em = bases[m].entries;
    for (let p = m; p < n; p++) {
      const ep = bases[p].entries;
      let tr = 0;
      let ti = 0;
      for (const ea of em) {
        for (const eb of ep) {
          const dot = ea.ux * eb.ux + ea.uy * eb.uy + ea.uz * eb.uz;
          const dd = ea.div * eb.div;
          pairIntegrals(ea, eb, k, false, buf);
          tr += k * dot * buf[0] - (dd / k) * buf[2];
          ti += k * dot * buf[1] - (dd / k) * buf[3];
          if (useImage) {
            const dotI = ea.ux * eb.ux + ea.uy * eb.uy - ea.uz * eb.uz;
            pairIntegrals(ea, eb, k, true, buf);
            tr -= k * dotI * buf[0] - (dd / k) * buf[2];
            ti -= k * dotI * buf[1] - (dd / k) * buf[3];
          }
        }
      }
      // Z = j * pre * T
      let zr = -pre * ti;
      let zi = pre * tr;

// Ohmic (internal) impedance of overlapping basis functions.
      for (const ea of em) {
        for (const eb of ep) {
          if (ea.seg !== eb.seg || !ea.sigma) continue;
          const zs = surfaceImpedance(ea.sigma, ea.radius, omega);
          if (!zs) continue;
          const sameParam = ea.qx === eb.qx && ea.qy === eb.qy && ea.qz === eb.qz;
          const overlap = (sameParam ? 1 / 3 : 1 / 6) * ea.L;
          const dot = ea.ux * eb.ux + ea.uy * eb.uy + ea.uz * eb.uz;
          zr += zs * overlap * dot;
          zi += zs * overlap * dot;
        }
      }

const o1 = 2 * (m * n + p);
      Z[o1] = zr;
      Z[o1 + 1] = zi;
      if (p !== m) {
        const o2 = 2 * (p * n + m);
        Z[o2] = zr;
        Z[o2 + 1] = zi;
      }
    }
  }
  return Z;
}

/**
 * Solves for the basis-function currents produced by a 1 V delta-gap source.
 * @returns {{I: Float64Array, zin:{r:number,x:number}, feedCurrent:{re:number,im:number}}}
 */
export function solveCurrents(mesh, frequency, ground) {
  const n = mesh.bases.length;
  if (n === 0) throw new Error('No current basis functions: give each wire at least 2 segments, or connect the wires.');
  if (mesh.feedBasis < 0) throw new Error('Could not place the feed point on the structure.');

const Z = fillImpedanceMatrix(mesh, frequency, ground);
  const piv = luFactor(Z, n);
  const I = createVector(n);
  I[2 * mesh.feedBasis] = 1; // 1 V excitation
  luSolve(Z, piv, I, n);

// ===== src/core/farfield.js =====
// Far-field radiation pattern, directivity, gain and radiated power
// obtained from the method-of-moments current solution.

// 6-point Gauss–Legendre nodes/weights on [0, 1].
const FT = [0.0337652428984240, 0.1693953067668678, 0.3806904069584015, 0.6193095930415985, 0.8306046932331322, 0.9662347571015760];
const FW = [0.0856622461895852, 0.1803807865240693, 0.2339569672863455, 0.2339569672863455, 0.1803807865240693, 0.0856622461895852];

/**
 * Collapses the current solution into a list of weighted radiating point sources.
 * Each point contributes v * exp(j k r̂·r) to the radiation vector N.
 */
function buildSources(mesh, I, ground) {
  const useImage = ground === 'perfect';
  const perEntry = FT.length * (useImage ? 2 : 1);
  let count = 0;
  for (const b of mesh.bases) count += b.entries.length * perEntry;

const px = new Float64Array(count);
  const py = new Float64Array(count);
  const pz = new Float64Array(count);
  const v = new Float64Array(count * 6); // vx(re,im), vy(re,im), vz(re,im)

/**
 * Computes the full-sphere gain pattern.
 * @returns pattern grid, radiated power and directivity statistics
 */
export function computePattern(mesh, I, frequency, ground, options = {}) {
  const stepDeg = options.stepDeg ?? 5;
  const k = (2 * Math.PI * frequency) / C0;
  const src = buildSources(mesh, I, ground);
  const groundOn = ground === 'perfect';

const thetaCount = Math.round(180 / stepDeg) + 1;
  const phiCount = Math.round(360 / stepDeg) + 1;
  const dTheta = (Math.PI / 180) * stepDeg;
  const dPhi = (Math.PI / 180) * stepDeg;

const u = new Float64Array(thetaCount * phiCount); // radiation intensity W/sr
  const eTheta = new Float64Array(thetaCount * phiCount);
  const ePhi = new Float64Array(thetaCount * phiCount);

const uFactor = (ETA0 * k * k) / (32 * Math.PI * Math.PI);
  // With a ground plane the integration stops at the horizon, which then
  // becomes a trapezoid endpoint and only gets half weight.
  const lastTheta = groundOn ? Math.round(90 / stepDeg) : thetaCount - 1;
  let pRad = 0;

for (let it = 0; it < thetaCount; it++) {
    const th = it * dTheta;
    const st = Math.sin(th);
    const ct = Math.cos(th);
    const blocked = groundOn && it > lastTheta;
    for (let ip = 0; ip < phiCount; ip++) {
      const idx = it * phiCount + ip;
      if (blocked) continue;
      const ph = ip * dPhi;
      const sp = Math.sin(ph);
      const cp = Math.cos(ph);
      const rx = st * cp;
      const ry = st * sp;
      const rz = ct;

let nxr = 0, nxi = 0, nyr = 0, nyi = 0, nzr = 0, nzi = 0;
      for (let i = 0; i < src.count; i++) {
        const phase = k * (rx * src.px[i] + ry * src.py[i] + rz * src.pz[i]);
        const c = Math.cos(phase);
        const s = Math.sin(phase);
        const o = i * 6;
        const ar = src.v[o], ai = src.v[o + 1];
        nxr += ar * c - ai * s; nxi += ar * s + ai * c;
        const br = src.v[o + 2], bi = src.v[o + 3];
        nyr += br * c - bi * s; nyi += br * s + bi * c;
        const dr = src.v[o + 4], di = src.v[o + 5];
        nzr += dr * c - di * s; nzi += dr * s + di * c;
      }

const tr = ct * cp * nxr + ct * sp * nyr - st * nzr;
      const ti = ct * cp * nxi + ct * sp * nyi - st * nzi;
      const pr = -sp * nxr + cp * nyr;
      const pi = -sp * nxi + cp * nyi;

const mag2 = tr * tr + ti * ti + pr * pr + pi * pi;
      u[idx] = uFactor * mag2;
      eTheta[idx] = Math.sqrt(tr * tr + ti * ti);
      ePhi[idx] = Math.sqrt(pr * pr + pi * pi);

if (ip < phiCount - 1) {
        const wTheta = it === 0 || it === lastTheta ? 0.5 : 1;
        pRad += u[idx] * st * dTheta * dPhi * wTheta;
      }
    }
  }

let uMax = 0;
  let maxIdx = 0;
  for (let i = 0; i < u.length; i++) {
    if (u[i] > uMax) {
      uMax = u[i];
      maxIdx = i;
    }
  }

return {
    stepDeg,
    thetaCount,
    phiCount,
    u,
    eTheta,
    ePhi,
    pRad,
    uMax,
    maxTheta: Math.floor(maxIdx / phiCount) * stepDeg,
    maxPhi: ((maxIdx % phiCount) * stepDeg) % 360,
  };
}

export function sampleDirectivity(pattern, thetaDeg, phiDeg) {
  const { thetaCount, phiCount, stepDeg, u, pRad } = pattern;
  let t = Math.round(thetaDeg / stepDeg);
  let p = Math.round(((phiDeg % 360) + 360) % 360 / stepDeg);
  t = Math.min(thetaCount - 1, Math.max(0, t));
  p = Math.min(phiCount - 1, Math.max(0, p));
  const value = u[t * phiCount + p];
  return pRad > 0 ? (4 * Math.PI * value) / pRad : 0;
}

// ===== src/core/model.js =====
// Antenna model helpers: construction, validation and serialisation.
// Lengths are in metres, wire radii in metres, frequency in MHz.

let nextId = 1;
export function newWireId() {
  return `w${nextId++}`;
}

export function wavelength(model) {
  return C0 / (model.frequencyMHz * 1e6);
}

export function wireLength(wire) {
  return Math.hypot(wire.p2[0] - wire.p1[0], wire.p2[1] - wire.p1[1], wire.p2[2] - wire.p1[2]);
}

export function makeWire(partial = {}) {
  return {
    id: newWireId(),
    name: partial.name ?? 'Wire',
    p1: partial.p1 ? [...partial.p1] : [0, -10, 10],
    p2: partial.p2 ? [...partial.p2] : [0, 10, 10],
    radius: partial.radius ?? 0.001,
    segments: partial.segments ?? 21,
    conductivity: partial.conductivity ?? MATERIALS.copper.sigma,
  };
}

export function makeModel(partial = {}) {
  const wires = (partial.wires ?? [makeWire()]).map((w) => ({ ...makeWire(w), id: w.id ?? newWireId() }));
  const feed = partial.feed ? { ...partial.feed } : { wireId: wires[0].id, fraction: 0.5 };
  if (!wires.some((w) => w.id === feed.wireId)) feed.wireId = wires[0].id;
  return {
    name: partial.name ?? 'Untitled antenna',
    frequencyMHz: partial.frequencyMHz ?? 7.1,
    ground: partial.ground ?? 'free',
    z0: partial.z0 ?? 50,
    heightOffset: partial.heightOffset ?? 0,
    wires,
    feed,
  };
}

/** Segment count that keeps segments at roughly λ/20 and at least 8× the radius. */
export function suggestedSegments(wire, lambda) {
  const len = wireLength(wire);
  if (len <= 0) return 1;
  const byWavelength = Math.ceil(len / (lambda / 20));
  const byRadius = Math.max(1, Math.floor(len / (8 * wire.radius)));
  return Math.max(1, Math.min(Math.max(byWavelength, 1), byRadius, 201));
}

/** Holds the segment length steady when a wire is stretched or shortened. */
export function keepMeshDensity(wire, previousLength) {
  const len = wireLength(wire);
  if (previousLength <= 0 || len <= 0) return;
  const scaled = Math.round(wire.segments * (len / previousLength));
  wire.segments = Math.max(1, Math.min(401, scaled));
}

/** Rotates the antenna 90° clockwise in place, seen from the positive end of the axis. */
export function rotateModel(model, axis) {
  const turn = ([x, y, z]) => (axis === 'x' ? [x, z, -y] : axis === 'y' ? [-z, y, x] : [y, -x, z]);
  const lo = [Infinity, Infinity, Infinity];
  const hi = [-Infinity, -Infinity, -Infinity];
  for (const w of model.wires) {
    for (const p of [w.p1, w.p2]) {
      for (let i = 0; i < 3; i++) {
        lo[i] = Math.min(lo[i], p[i]);
        hi[i] = Math.max(hi[i], p[i]);
      }
    }
  }
  // Spinning about the antenna's own centre keeps it put; rotating about the
  // world origin would walk it towards the axis and eventually stick there.
  const c = [0, 1, 2].map((i) => (lo[i] + hi[i]) / 2);
  const spin = (p) => {
    const r = turn([p[0] - c[0], p[1] - c[1], p[2] - c[2]]);
    return [r[0] + c[0], r[1] + c[1], r[2] + c[2]];
  };
  for (const w of model.wires) {
    w.p1 = spin(w.p1);
    w.p2 = spin(w.p2);
  }
  if (model.ground !== 'perfect') return;
  // Image theory is only valid with the whole structure at or above the ground.
  const offset = model.heightOffset ?? 0;
  let lowest = Infinity;
  for (const w of model.wires) lowest = Math.min(lowest, w.p1[2], w.p2[2]);
  lowest += offset;
  if (lowest < 0) {
    for (const w of model.wires) {
      w.p1[2] -= lowest;
      w.p2[2] -= lowest;
    }
  }
}

export function cloneModel(model) {
  return JSON.parse(JSON.stringify(model));
}

export function modelToJson(model) {
  return JSON.stringify(model, null, 2);
}

export function modelFromJson(text) {
  const raw = JSON.parse(text);
  if (!Array.isArray(raw.wires) || raw.wires.length === 0) throw new Error('File contains no wires.');
  for (const w of raw.wires) {
    if (!Array.isArray(w.p1) || !Array.isArray(w.p2) || w.p1.length !== 3 || w.p2.length !== 3) {
      throw new Error('Each wire needs p1 and p2 arrays of three numbers.');
    }
  }
  return makeModel(raw);
}

// ===== src/core/presets.js =====
// Ready-made amateur radio antennas. Geometry is derived from the design
// wavelength so the shapes stay meaningful if the frequency is changed.

const CU = MATERIALS.copper.sigma;
const AL = MATERIALS.aluminium.sigma;

// Common wire and tubing sizes, as radius in metres.
const AWG12 = 0.001026;
const AWG14 = 0.000814;
const ROD_6MM = 0.003;
const TUBE_25MM = 0.0127;
const TUBE_50MM = 0.025;

function lambdaOf(fMHz) {
  return C0 / (fMHz * 1e6);
}

/** Classic 40 m half-wave dipole on a 10 m mast. */
function dipole40(fMHz = 7.1) {
  const L = lambdaOf(fMHz);
  const half = 0.2385 * L;
  const h = 10;
  return build({
    name: '40 m dipole, 10 m high',
    fMHz,
    ground: 'perfect',
    wires: [makeWire({ name: 'Dipole', p1: [0, -half, h], p2: [0, half, h], radius: AWG12, segments: 41, conductivity: CU })],
  });
}

/** 20 m inverted-V, apex on a 12 m mast, 90° included angle. */
function invertedV20(fMHz = 14.15) {
  const L = lambdaOf(fMHz);
  const leg = 0.2497 * L;
  const run = leg * Math.SQRT1_2;
  const apex = 12;
  return build({
    name: '20 m inverted-V, 12 m apex',
    fMHz,
    ground: 'perfect',
    wires: [
      makeWire({ name: 'Leg north', p1: [0, 0, apex], p2: [0, run, apex - run], radius: AWG14, segments: 21, conductivity: CU }),
      makeWire({ name: 'Leg south', p1: [0, 0, apex], p2: [0, -run, apex - run], radius: AWG14, segments: 21, conductivity: CU }),
    ],
    feedFraction: 0,
  });
}

/** Full-size 3-element monoband beam, quoted in free space like the catalogues. */
function yagi20(fMHz = 14.15) {
  const L = lambdaOf(fMHz);
  const el = (name, halfLen, x) => makeWire({
    name,
    p1: [x, -halfLen * L, 0],
    p2: [x, halfLen * L, 0],
    radius: TUBE_25MM,
    segments: 21,
    conductivity: AL,
  });
  return build({
    name: '20 m 3-element Yagi (free space)',
    fMHz,
    wires: [
      el('Driven element', 0.239, 0),
      el('Reflector', 0.25, -0.2 * L),
      el('Director', 0.22, 0.15 * L),
    ],
  });
}

/** Delta loop fed a quarter wave from the apex, which makes it vertically polarised. */
function deltaLoop20(fMHz = 14.15) {
  const L = lambdaOf(fMHz);
  const perimeter = 1.075 * L;
  const side = perimeter / 3;
  const halfBase = side / 2;
  const base = 6;
  const apex = base + (side * Math.sqrt(3)) / 2;
  const wire = (name, p1, p2) => makeWire({ name, p1, p2, radius: AWG12, segments: 15, conductivity: CU });
  return build({
    name: '20 m delta loop, vertically polarised',
    fMHz,
    ground: 'perfect',
    wires: [
      wire('Base', [0, -halfBase, base], [0, halfBase, base]),
      wire('East side', [0, halfBase, base], [0, 0, apex]),
      wire('West side', [0, 0, apex], [0, -halfBase, base]),
    ],
    feedIndex: 1,
    feedFraction: 1 - (0.25 * L) / side,
  });
}

/** Folded dipole on 300 Ω ladder line. */
function foldedDipole20(fMHz = 14.15) {
  const L = lambdaOf(fMHz);
  const half = 0.239 * L;
  const s = 0.15;
  const long = (name, x) => makeWire({ name, p1: [x, -half, 0], p2: [x, half, 0], radius: AWG12, segments: 41, conductivity: CU });
  const link = (name, y) => makeWire({ name, p1: [0, y, 0], p2: [s, y, 0], radius: AWG12, segments: 1, conductivity: CU });
  return build({
    name: '20 m folded dipole (300 Ω)',
    fMHz,
    wires: [long('Driven side', 0), long('Return side', s), link('North link', half), link('South link', -half)],
    z0: 300,
  });
}

/** Ground-mounted quarter-wave vertical with an ideal radial field. */
function vertical80(fMHz = 3.65) {
  const L = lambdaOf(fMHz);
  return build({
    name: '80 m quarter-wave vertical',
    fMHz,
    ground: 'perfect',
    wires: [makeWire({ name: 'Radiator', p1: [0, 0, 0], p2: [0, 0, 0.242 * L], radius: TUBE_50MM, segments: 21, conductivity: AL })],
    feedFraction: 0,
  });
}

/** Full-wave square loop lying flat 12 m up — the classic quiet NVIS antenna. */
function horizontalLoop80(fMHz = 3.65) {
  const L = lambdaOf(fMHz);
  const half = (1.018 * L) / 8;
  const h = 12;
  const corners = [
    [-half, -half, h],
    [half, -half, h],
    [half, half, h],
    [-half, half, h],
  ];
  const names = ['South side', 'East side', 'North side', 'West side'];
  const wires = corners.map((p, i) => makeWire({
    name: names[i],
    p1: p,
    p2: corners[(i + 1) % 4],
    radius: AWG12,
    segments: 21,
    conductivity: CU,
  }));
  return build({ name: '80 m full-wave horizontal loop', fMHz, ground: 'perfect', wires });
}

/** Top-band inverted-L: 18 m up the tower, then a horizontal flat top. */
function invertedL160(fMHz = 1.835) {
  const L = lambdaOf(fMHz);
  const vertical = 18;
  const flatTop = 0.2505 * L - vertical;
  return build({
    name: '160 m inverted-L',
    fMHz,
    ground: 'perfect',
    wires: [
      makeWire({ name: 'Vertical', p1: [0, 0, 0], p2: [0, 0, vertical], radius: AWG12, segments: 19, conductivity: CU }),
      makeWire({ name: 'Flat top', p1: [0, 0, vertical], p2: [flatTop, 0, vertical], radius: AWG12, segments: 23, conductivity: CU }),
    ],
    feedFraction: 0,
  });
}

/** The classic first build: 2 m quarter-wave ground plane with drooping radials. */
function groundPlane2m(fMHz = 146) {
  const L = lambdaOf(fMHz);
  const run = 0.26 * L * Math.SQRT1_2;
  const wires = [makeWire({ name: 'Radiator', p1: [0, 0, 0], p2: [0, 0, 0.2295 * L], radius: 0.001, segments: 11, conductivity: CU })];
  for (let i = 0; i < 4; i++) {
    const a = (i * Math.PI) / 2;
    wires.push(makeWire({
      name: `Radial ${i + 1}`,
      p1: [0, 0, 0],
      p2: [run * Math.cos(a), run * Math.sin(a), -run],
      radius: 0.001,
      segments: 11,
      conductivity: CU,
    }));
  }
  return build({ name: '2 m ground plane, 45° radials', fMHz, wires, feedFraction: 0 });
}

/** Portable 3-element beam for 2 m SSB. */
function yagi2m(fMHz = 145) {
  const L = lambdaOf(fMHz);
  const el = (name, halfLen, x) => makeWire({
    name,
    p1: [x, -halfLen * L, 0],
    p2: [x, halfLen * L, 0],
    radius: ROD_6MM,
    segments: 15,
    conductivity: AL,
  });
  return build({
    name: '2 m 3-element Yagi',
    fMHz,
    wires: [
      el('Driven element', 0.239, 0),
      el('Reflector', 0.25, -0.2 * L),
      el('Director', 0.22, 0.15 * L),
    ],
  });
}

export const PRESETS = [
  { id: 'dipole40', label: '40 m dipole, 10 m high (7.1 MHz)', create: () => dipole40() },
  { id: 'invv20', label: '20 m inverted-V, 12 m apex (14.15 MHz)', create: () => invertedV20() },
  { id: 'yagi20', label: '20 m 3-element Yagi (14.15 MHz)', create: () => yagi20() },
  { id: 'delta20', label: '20 m delta loop (14.15 MHz)', create: () => deltaLoop20() },
  { id: 'folded20', label: '20 m folded dipole, 300 Ω (14.15 MHz)', create: () => foldedDipole20() },
  { id: 'vert80', label: '80 m quarter-wave vertical (3.65 MHz)', create: () => vertical80() },
  { id: 'loop80', label: '80 m full-wave horizontal loop (3.65 MHz)', create: () => horizontalLoop80() },
  { id: 'invl160', label: '160 m inverted-L (1.835 MHz)', create: () => invertedL160() },
  { id: 'gp2m', label: '2 m ground plane (146 MHz)', create: () => groundPlane2m() },
  { id: 'yagi2m', label: '2 m 3-element Yagi (145 MHz)', create: () => yagi2m() },
];

export function presetById(id) {
  return PRESETS.find((p) => p.id === id);
}

// ===== src/core/analysis.js =====
// High level analysis: runs the solver and packages everything the UI needs.

function swrFrom(zin, z0) {
  const dr = zin.r + z0;
  const di = zin.x;
  const nr = zin.r - z0;
  const den = dr * dr + di * di;
  const gr = (nr * dr + di * di) / den;
  const gi = (di * dr - nr * di) / den;
  const mag = Math.min(0.999999, Math.hypot(gr, gi));
  return { gamma: mag, swr: (1 + mag) / (1 - mag), returnLoss: -20 * Math.log10(Math.max(mag, 1e-9)) };
}

/** Current magnitude at the midpoint of every segment, for 3D colouring. */
function segmentCurrents(mesh, I) {
  const out = new Float64Array(mesh.segments.length);
  const re = new Float64Array(mesh.segments.length);
  const im = new Float64Array(mesh.segments.length);
  mesh.bases.forEach((basis, j) => {
    const ir = I[2 * j];
    const ii = I[2 * j + 1];
    for (const e of basis.entries) {
      const seg = mesh.segments[e.seg];
      const align = e.ux * seg.dir[0] + e.uy * seg.dir[1] + e.uz * seg.dir[2];
      re[e.seg] += 0.5 * ir * align;
      im[e.seg] += 0.5 * ii * align;
    }
  });
  for (let i = 0; i < out.length; i++) out[i] = Math.hypot(re[i], im[i]);
  return out;
}

export function analyze(model, options = {}) {
  const frequency = model.frequencyMHz * 1e6;
  const lambda = C0 / frequency;
  const mesh = buildMesh(model);
  const { I, zin, feedCurrent } = solveCurrents(mesh, frequency, model.ground);
  const pattern = computePattern(mesh, I, frequency, model.ground, { stepDeg: options.stepDeg ?? 5 });

const pIn = 0.5 * feedCurrent.re; // 1 V delta-gap excitation
  const efficiency = pIn > 0 ? Math.min(1, pattern.pRad / pIn) : 0;
  const directivity = pattern.pRad > 0 ? (4 * Math.PI * pattern.uMax) / pattern.pRad : 0;
  const gain = directivity * efficiency;

const backTheta = model.ground === 'perfect' ? pattern.maxTheta : 180 - pattern.maxTheta;
  const back = sampleDirectivity(pattern, backTheta, pattern.maxPhi + 180) * efficiency;
  const fb = back > 0 ? 10 * Math.log10(gain / back) : Infinity;

// dBi grid used by the 3D surface.
  const gainDb = new Float64Array(pattern.u.length);
  const scale = pattern.pRad > 0 ? (4 * Math.PI * efficiency) / pattern.pRad : 0;
  for (let i = 0; i < gainDb.length; i++) {
    const g = pattern.u[i] * scale;
    gainDb[i] = g > 0 ? 10 * Math.log10(g) : -999;
  }

return {
    ok: true,
    frequencyMHz: model.frequencyMHz,
    lambda,
    zin,
    ...swrFrom(zin, model.z0),
    z0: model.z0,
    feedCurrent,
    pIn,
    pRad: pattern.pRad,
    efficiency,
    directivityDbi: directivity > 0 ? 10 * Math.log10(directivity) : -999,
    gainDbi: gain > 0 ? 10 * Math.log10(gain) : -999,
    maxTheta: pattern.maxTheta,
    maxPhi: pattern.maxPhi,
    frontToBackDb: Number.isFinite(fb) ? fb : null,
    pattern: {
      stepDeg: pattern.stepDeg,
      thetaCount: pattern.thetaCount,
      phiCount: pattern.phiCount,
      gainDb,
    },
    cuts: {
      azimuth: cutData(pattern, efficiency, 'azimuth', pattern.maxTheta),
      elevation: cutData(pattern, efficiency, 'elevation', pattern.maxPhi),
      azimuthThetaDeg: pattern.maxTheta,
      elevationPhiDeg: pattern.maxPhi,
    },
    segments: mesh.segments.map((s) => ({ p1: s.p1, p2: s.p2, radius: s.radius, wireId: s.wireId })),
    segmentCurrents: segmentCurrents(mesh, I),
    feedPoint: mesh.feedBasis >= 0 ? mesh.nodes[mesh.bases[mesh.feedBasis].node].pos : null,
    basisCount: mesh.bases.length,
    warnings: mesh.warnings,
  };
}

/** Impedance / SWR versus frequency (far field is skipped for speed). */
export function sweep(model, startMHz, stopMHz, points, onProgress) {
  const out = [];
  const n = Math.max(2, points);
  for (let i = 0; i < n; i++) {
    const f = startMHz + ((stopMHz - startMHz) * i) / (n - 1);
    const m = { ...model, frequencyMHz: f };
    try {
      const mesh = buildMesh(m);
      const { zin } = solveCurrents(mesh, f * 1e6, m.ground);
      out.push({ frequencyMHz: f, r: zin.r, x: zin.x, ...swrFrom(zin, m.z0) });
    } catch {
      out.push({ frequencyMHz: f, r: NaN, x: NaN, swr: NaN, gamma: NaN, returnLoss: NaN });
    }
    onProgress?.((i + 1) / n);
  }
  return out;
}

// ===== standalone glue =====
import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';

const payload = (id) => document.getElementById(id).value;
const coreSource = payload('radvis-core');
const workerSource = payload('radvis-worker');
const coreUrl = URL.createObjectURL(new Blob([coreSource], { type: 'text/javascript' }));
const { AMATEUR_BANDS, MATERIALS, PRESETS, analyze, bandFor, keepMeshDensity, makeWire, modelFromJson, modelToJson, presetById, rotateModel, suggestedSegments, sweep, wavelength, wireLength } = await import(coreUrl);

/** Looks like a Worker, but solves on the main thread where blob workers are blocked (file:// pages). */
function createSolver() {
  const shim = {
    onmessage: null,
    onerror: null,
    worker: null,
    last: null,
    postMessage(msg) {
      this.last = msg;
      if (this.worker) this.worker.postMessage(msg);
      else setTimeout(() => runLocally(msg, (data) => this.onmessage?.({ data })), 0);
    },
  };
  try {
    const url = URL.createObjectURL(new Blob([coreSource, workerSource].join('\n'), { type: 'text/javascript' }));
    const worker = new Worker(url, { type: 'module' });
    worker.onmessage = (ev) => shim.onmessage?.(ev);
    worker.onerror = () => {
      worker.terminate();
      shim.worker = null;
      if (shim.last) shim.postMessage(shim.last);
    };
    shim.worker = worker;
  } catch {
    shim.worker = null;
  }
  return shim;
}

// ===== src/ui/charts.js =====
// Lightweight 2D plots (polar pattern cuts and an SWR sweep) on canvas.

const FG = '#ececed';
const MUTED = '#8e8e99';
const GRID = '#3a3a42';
const ACCENT = '#4fc3f7';

/**
 * Polar plot. `points` is [{angle (deg, 0 = up, clockwise), dbi}].
 */
function drawPolar(canvas, points, opts = {}) {
  const { ctx, w, h } = prepare(canvas);
  const title = opts.title ?? '';
  const range = opts.range ?? 40;
  const cx = w / 2;
  const cy = h / 2 + 4;
  const R = Math.min(w, h) / 2 - 22;

ctx.font = '11px ui-sans-serif, system-ui, sans-serif';
  ctx.textAlign = 'center';

if (!points || points.length === 0) {
    ctx.fillStyle = MUTED;
    ctx.fillText('No data', cx, cy);
    return;
  }

const maxDb = opts.maxDb ?? points.reduce((m, p) => Math.max(m, p.dbi), -999);
  const top = Math.ceil(maxDb / 5) * 5;

ctx.strokeStyle = GRID;
  ctx.fillStyle = MUTED;
  ctx.lineWidth = 1;
  for (let i = 1; i <= 4; i++) {
    const r = (R * i) / 4;
    ctx.beginPath();
    ctx.arc(cx, cy, r, 0, Math.PI * 2);
    ctx.stroke();
    const label = `${(top - range + (range * i) / 4).toFixed(0)}`;
    if (i < 4) ctx.fillText(label, cx + 2, cy - r + 11);
  }
  for (let a = 0; a < 360; a += 30) {
    const rad = ((a - 90) * Math.PI) / 180;
    ctx.beginPath();
    ctx.moveTo(cx, cy);
    ctx.lineTo(cx + R * Math.cos(rad), cy + R * Math.sin(rad));
    ctx.stroke();
  }
  ctx.fillStyle = MUTED;
  const label = (a) => opts.labels?.[a] ?? `${a}°`;
  ctx.textAlign = 'center';
  ctx.fillText(label(0), cx, cy - R - 6);
  ctx.fillText(label(180), cx, cy + R + 14);
  ctx.textAlign = 'right';
  ctx.fillText(label(270), cx - R - 5, cy + 4);
  ctx.textAlign = 'left';
  ctx.fillText(label(90), cx + R + 5, cy + 4);
  ctx.textAlign = 'center';

const radiusOf = (dbi) => Math.max(0, Math.min(1, (dbi - (top - range)) / range)) * R;

ctx.beginPath();
  points.forEach((p, i) => {
    const rad = ((p.angle - 90) * Math.PI) / 180;
    const r = radiusOf(p.dbi);
    const x = cx + r * Math.cos(rad);
    const y = cy + r * Math.sin(rad);
    if (i === 0) ctx.moveTo(x, y);
    else ctx.lineTo(x, y);
  });
  ctx.closePath();
  ctx.fillStyle = 'rgba(79,195,247,0.18)';
  ctx.fill();
  ctx.strokeStyle = ACCENT;
  ctx.lineWidth = 1.8;
  ctx.stroke();

ctx.fillStyle = FG;
  ctx.font = '600 12px ui-sans-serif, system-ui, sans-serif';
  ctx.fillText(title, cx, 11);
}

/** SWR versus frequency. */
function drawSweep(canvas, data, opts = {}) {
  const { ctx, w, h } = prepare(canvas);
  const pad = { l: 34, r: 10, t: 16, b: 22 };
  const iw = w - pad.l - pad.r;
  const ih = h - pad.t - pad.b;

ctx.font = '10px ui-sans-serif, system-ui, sans-serif';
  if (!data || data.length === 0) {
    ctx.fillStyle = MUTED;
    ctx.textAlign = 'center';
    ctx.fillText(opts.placeholder ?? 'Run a frequency sweep to see SWR', w / 2, h / 2);
    return;
  }

const valid = data.filter((d) => Number.isFinite(d.swr));
  const f0 = data[0].frequencyMHz;
  const f1 = data[data.length - 1].frequencyMHz;
  const sMax = Math.max(3, Math.min(10, Math.ceil(Math.max(...valid.map((d) => d.swr)))));
  const X = (f) => pad.l + ((f - f0) / (f1 - f0 || 1)) * iw;
  const Y = (s) => pad.t + ih - ((Math.min(s, sMax) - 1) / (sMax - 1)) * ih;

ctx.strokeStyle = GRID;
  ctx.fillStyle = MUTED;
  ctx.lineWidth = 1;
  ctx.textAlign = 'right';
  for (let s = 1; s <= sMax; s += Math.max(1, Math.round((sMax - 1) / 4))) {
    const y = Y(s);
    ctx.beginPath();
    ctx.moveTo(pad.l, y);
    ctx.lineTo(w - pad.r, y);
    ctx.stroke();
    ctx.fillText(`${s}`, pad.l - 5, y + 3);
  }
  ctx.textAlign = 'center';
  for (let i = 0; i <= 4; i++) {
    const f = f0 + ((f1 - f0) * i) / 4;
    const x = X(f);
    ctx.strokeStyle = GRID;
    ctx.beginPath();
    ctx.moveTo(x, pad.t);
    ctx.lineTo(x, pad.t + ih);
    ctx.stroke();
    ctx.fillStyle = MUTED;
    ctx.textAlign = i === 0 ? 'left' : i === 4 ? 'right' : 'center';
    ctx.fillText(f.toFixed(f1 - f0 < 10 ? 2 : 1), x, h - 7);
  }
  ctx.textAlign = 'center';

// SWR = 2 reference line
  if (sMax >= 2) {
    ctx.strokeStyle = 'rgba(227,195,58,0.5)';
    ctx.setLineDash([4, 3]);
    ctx.beginPath();
    ctx.moveTo(pad.l, Y(2));
    ctx.lineTo(w - pad.r, Y(2));
    ctx.stroke();
    ctx.setLineDash([]);
  }

// Amateur band edges
  if (opts.band) {
    ctx.fillStyle = 'rgba(39,192,138,0.10)';
    const xa = Math.max(pad.l, X(opts.band.start));
    const xb = Math.min(w - pad.r, X(opts.band.stop));
    if (xb > xa) {
      ctx.fillRect(xa, pad.t, xb - xa, ih);
      ctx.strokeStyle = 'rgba(39,192,138,0.6)';
      ctx.beginPath();
      ctx.moveTo(xa, pad.t);
      ctx.lineTo(xa, pad.t + ih);
      ctx.moveTo(xb, pad.t);
      ctx.lineTo(xb, pad.t + ih);
      ctx.stroke();
    }
  }

ctx.strokeStyle = ACCENT;
  ctx.lineWidth = 2;
  ctx.beginPath();
  let started = false;
  for (const d of data) {
    if (!Number.isFinite(d.swr)) {
      started = false;
      continue;
    }
    const x = X(d.frequencyMHz);
    const y = Y(d.swr);
    if (!started) {
      ctx.moveTo(x, y);
      started = true;
    } else ctx.lineTo(x, y);
  }
  ctx.stroke();

if (Number.isFinite(opts.markerMHz)) {
    const x = X(opts.markerMHz);
    ctx.strokeStyle = '#ff3b6b';
    ctx.lineWidth = 1.2;
    ctx.beginPath();
    ctx.moveTo(x, pad.t);
    ctx.lineTo(x, pad.t + ih);
    ctx.stroke();
  }

const best = valid.reduce((a, b) => (b.swr < a.swr ? b : a), valid[0]);
  ctx.fillStyle = FG;
  ctx.textAlign = 'left';
  ctx.fillText(`min SWR ${best.swr.toFixed(2)} @ ${best.frequencyMHz.toFixed(3)} MHz`, pad.l, 11);
}

// ===== src/ui/results.js =====
// Renders the match badge, the numeric cards and the model-check list.

const POINTS = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];

/** Azimuth is measured from +X (east); hams read compass bearings from north. */
function bearingFromPhi(phiDeg) {
  return ((90 - phiDeg) % 360 + 360) % 360;
}

function compassPoint(bearing) {
  return POINTS[Math.round((((bearing % 360) + 360) % 360) / 22.5) % 16];
}

function card(label, value, tip = '') {
  return `<div class="metric glass"${tip ? ` title="${tip}"` : ''}>
    <span>${label}</span>
    <strong>${value}</strong>
  </div>`;
}

function swrClass(swr) {
  if (swr <= 1.5) return 'good';
  if (swr <= 3) return 'warn';
  return 'bad';
}

/** Match verdict plus the three power figures that go with it. */
function renderSummary(el, result) {
  if (!result) {
    el.hidden = true;
    return;
  }
  const { swr, z0, gamma, returnLoss, efficiency } = result;
  const kind = swr <= 2 ? 'good' : swr <= 3 ? 'warn' : 'bad';
  const headline = swr <= 1.5 ? 'Great match' : swr <= 2 ? 'Good match' : swr <= 3 ? 'Workable match' : 'Poor match';

function renderMetrics(el, result) {
  if (!result) {
    el.innerHTML = '<p class="empty">Nothing calculated yet.</p>';
    return;
  }
  const { zin, gainDbi } = result;
  const elev = 90 - result.maxTheta;

el.innerHTML = [
    card('Feedpoint impedance', `${zin.r.toFixed(1)} ${zin.x >= 0 ? '+' : '−'} j${Math.abs(zin.x).toFixed(1)} Ω`,
      'What your feed line sees. The j term is reactance; zero means resonant.'),
    card('Peak gain', `${gainDbi.toFixed(2)} dBi`,
      'dBi compares against an ideal point radiator. Over ground the figure already includes the reflection gain.'),
    card('Take-off angle', `${elev.toFixed(0)}°`,
      'Elevation of the strongest lobe. Low angles reach far, high angles go local.'),
  ].join('');
}

// ===== src/ui/panel.js =====
// Sidebar: simulation settings, the wire table and the feed-point selector.

const COORD_KEYS = [
  ['p1', 0], ['p1', 1], ['p1', 2],
  ['p2', 0], ['p2', 1], ['p2', 2],
];

// Metres, with enough decimals to stay useful at VHF without overflowing the cell.
const fmt = (v) => {
  const a = Math.abs(v);
  if (a >= 100) return v.toFixed(1);
  if (a >= 1) return v.toFixed(2);
  return v.toFixed(3);
};

class Sidebar {
  /**
   * @param {object} refs DOM elements
   * @param {{onChange:(opts?:object)=>void}} handlers
   */
  constructor(refs, handlers) {
    this.refs = refs;
    this.handlers = handlers;
    this.model = null;
    this.rows = new Map();
    this._initStatic();
  }

_initStatic() {
    const { presetSelect, materialSelect, bandSelect } = this.refs;
    presetSelect.innerHTML = PRESETS.map((p) => `<option value="${p.id}">${p.label}</option>`).join('');
    materialSelect.innerHTML = Object.entries(MATERIALS)
      .map(([k, m]) => `<option value="${k}">${m.label}${m.sigma ? ` (${(m.sigma / 1e6).toFixed(1)} MS/m)` : ''}</option>`)
      .join('');
    bandSelect.innerHTML = '<option value="">Band…</option>' +
      AMATEUR_BANDS.map((b) => `<option value="${b.name}">${b.name}</option>`).join('');

bandSelect.addEventListener('change', () => {
      const band = AMATEUR_BANDS.find((b) => b.name === bandSelect.value);
      bandSelect.value = '';
      if (!band) return;
      this.model.frequencyMHz = Number(((band.start + band.stop) / 2).toFixed(4));
      this.refs.freq.value = String(this.model.frequencyMHz);
      this._updateLambda();
      this.handlers.onChange();
    });

this.refs.freq.addEventListener('change', () => {
      const v = Number(this.refs.freq.value);
      if (!Number.isFinite(v) || v <= 0) return;
      this.model.frequencyMHz = v;
      this._updateLambda();
      this.handlers.onChange();
    });
    this.refs.groundSelect.addEventListener('change', () => {
      this.model.ground = this.refs.groundSelect.value;
      this.refs.groundHint.hidden = this.model.ground !== 'perfect';
      this.handlers.onChange({ structural: true });
    });
    this.refs.z0.addEventListener('change', () => {
      const v = Number(this.refs.z0.value);
      if (v > 0) {
        this.model.z0 = v;
        this._syncZ0Preset();
        this.handlers.onChange();
      }
    });
    this.refs.z0Preset.addEventListener('change', () => {
      const custom = this.refs.z0Preset.value === 'custom';
      this.refs.z0.hidden = !custom;
      if (custom) {
        this.refs.z0.focus();
        return;
      }
      this.model.z0 = Number(this.refs.z0Preset.value);
      this.refs.z0.value = String(this.model.z0);
      this.handlers.onChange();
    });
    this.refs.advancedGeom.addEventListener('change', () => {
      document.getElementById('app').classList.toggle('advanced', this.refs.advancedGeom.checked);
    });
    this.refs.heightOffset.addEventListener('input', () => {
      this.model.heightOffset = Number(this.refs.heightOffset.value);
      this._updateHeight();
      this.handlers.onChange({ structural: true });
    });
    this.refs.materialSelect.addEventListener('change', () => {
      const sigma = MATERIALS[this.refs.materialSelect.value].sigma;
      for (const w of this.model.wires) w.conductivity = sigma;
      this.handlers.onChange();
    });

this.refs.addWireBtn.addEventListener('click', () => {
      const lam = wavelength(this.model);
      const w = makeWire({
        name: `Wire ${this.model.wires.length + 1}`,
        p1: [0, 0, 0],
        p2: [0, 0.25 * lam, 0],
        radius: 0.001,
        conductivity: this.model.wires[0]?.conductivity ?? MATERIALS.copper.sigma,
      });
      w.segments = suggestedSegments(w, lam);
      this.model.wires.push(w);
      this.render(this.model, { structural: true });
      this.handlers.onChange({ structural: true });
    });

this.refs.autoSegBtn.addEventListener('click', () => {
      const lam = wavelength(this.model);
      for (const w of this.model.wires) w.segments = suggestedSegments(w, lam);
      this.render(this.model, { structural: true });
      this.handlers.onChange({ structural: true });
    });

this.refs.feedWire.addEventListener('change', () => {
      this.model.feed.wireId = this.refs.feedWire.value;
      this._markFeedRow();
      this.handlers.onChange({ structural: true });
    });
    this.refs.feedFraction.addEventListener('input', () => {
      this.model.feed.fraction = Number(this.refs.feedFraction.value);
      this.refs.feedFractionOut.textContent = `${Math.round(this.model.feed.fraction * 100)}%`;
      this.handlers.onChange({ structural: true });
    });

this.refs.presetSelect.addEventListener('dblclick', () => this.refs.loadPresetBtn.click());
  }

render(model, { structural = true } = {}) {
    this.model = model;
    this.refs.freq.value = String(model.frequencyMHz);
    this.refs.groundSelect.value = model.ground;
    this.refs.groundHint.hidden = model.ground !== 'perfect';
    this.refs.z0.value = String(model.z0);
    this._syncZ0Preset();
    const sigma = model.wires[0]?.conductivity ?? 0;
    const matKey = Object.keys(MATERIALS).find((k) => MATERIALS[k].sigma === sigma) ?? 'copper';
    this.refs.materialSelect.value = matKey;
    this._updateLambda();

if (structural) this._buildTable();
    else this.syncValues();

this.refs.feedWire.innerHTML = model.wires.map((w) => `<option value="${w.id}">${w.name}</option>`).join('');
    this.refs.feedWire.value = model.feed.wireId;
    this.refs.feedFraction.value = String(model.feed.fraction);
    this.refs.feedFractionOut.textContent = `${Math.round(model.feed.fraction * 100)}%`;
    this._markFeedRow();
  }

/** Refreshes the numeric inputs without rebuilding the DOM (used while dragging). */
  syncValues() {
    for (const w of this.model.wires) {
      const row = this.rows.get(w.id);
      if (!row) continue;
      COORD_KEYS.forEach(([p, i], n) => {
        if (document.activeElement !== row.coords[n]) row.coords[n].value = fmt(w[p][i]);
      });
      if (document.activeElement !== row.radius) row.radius.value = (w.radius * 1000).toFixed(2);
      if (document.activeElement !== row.segments) row.segments.value = String(w.segments);
    }
  }

_updateLambda() {
    const lam = wavelength(this.model);
    this.refs.lambdaOut.textContent = lam >= 0.5 ? `${lam.toFixed(2)} m` : `${(lam * 1000).toFixed(1)} mm`;
    const band = bandFor(this.model.frequencyMHz);
    this.refs.bandOut.textContent = band
      ? `${band.name} band (${band.start}–${band.stop} MHz)`
      : 'outside the amateur bands';
    this._updateHeight();
  }

/** The slider reaches one wavelength up, which covers every practical mast. */
  _updateHeight() {
    const max = Math.max(10, Math.min(100, Math.round(wavelength(this.model))));
    const value = Math.min(this.model.heightOffset ?? 0, max);
    this.model.heightOffset = value;
    this.refs.heightOffset.max = String(max);
    this.refs.heightOffset.step = max > 25 ? '0.5' : '0.05';
    this.refs.heightOffset.value = String(value);
    this.refs.heightOut.textContent = `${value.toFixed(value < 10 ? 2 : 1)} m`;
  }

_markFeedRow() {
    for (const [id, row] of this.rows) row.tr.classList.toggle('feed', id === this.model.feed.wireId);
  }

_syncZ0Preset() {
    const known = [...this.refs.z0Preset.options].some((o) => o.value === String(this.model.z0));
    this.refs.z0Preset.value = known ? String(this.model.z0) : 'custom';
    this.refs.z0.hidden = known;
  }

_buildTable() {
    const tbody = this.refs.wireTbody;
    tbody.textContent = '';
    this.rows.clear();

for (const wire of this.model.wires) {
      const tr = document.createElement('tr');
      const cells = [];

const nameInput = document.createElement('input');
      nameInput.className = 'name';
      nameInput.value = wire.name;
      nameInput.addEventListener('change', () => {
        wire.name = nameInput.value;
        this.refs.feedWire.querySelector(`option[value="${wire.id}"]`).textContent = wire.name;
      });
      const nameWrap = document.createElement('div');
      nameWrap.className = 'name-cell';
      nameWrap.appendChild(nameInput);
      cells.push(nameWrap);

cells.forEach((el, i) => {
        const td = document.createElement('td');
        // The last two inputs are the thickness and mesh columns.
        if (i >= cells.length - 2) td.className = 'adv-col';
        td.appendChild(el);
        tr.appendChild(td);
      });

tbody.appendChild(tr);
      this.rows.set(wire.id, { tr, coords, radius, segments, nameInput });
    }
  }
}

// ===== src/ui/viewer3d.js =====
// 3D scene: antenna geometry, draggable endpoints and the radiation pattern
// surface. Uses three.js from a CDN via the import map in index.html.

const UP = new THREE.Vector3(0, 0, 1);

const COLOR_STOPS = [
  [0.0, 0x1b2a6b],
  [0.25, 0x1d8fd1],
  [0.5, 0x27c08a],
  [0.72, 0xe3c33a],
  [1.0, 0xe5443a],
];

/** Appends a capless cylinder between a and b into the supplied arrays. */
function pushTube(pos, col, idx, a, b, radius, rgb, sides = 8) {
  const dir = new THREE.Vector3().subVectors(b, a);
  const len = dir.length();
  if (len < 1e-12) return;
  dir.divideScalar(len);
  const ref = Math.abs(dir.z) > 0.9 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 0, 1);
  const u = new THREE.Vector3().crossVectors(dir, ref).normalize();
  const v = new THREE.Vector3().crossVectors(dir, u).normalize();
  const base = pos.length / 3;
  for (let i = 0; i < sides; i++) {
    const ang = (i / sides) * Math.PI * 2;
    const ox = u.x * Math.cos(ang) * radius + v.x * Math.sin(ang) * radius;
    const oy = u.y * Math.cos(ang) * radius + v.y * Math.sin(ang) * radius;
    const oz = u.z * Math.cos(ang) * radius + v.z * Math.sin(ang) * radius;
    pos.push(a.x + ox, a.y + oy, a.z + oz);
    col.push(rgb[0], rgb[1], rgb[2]);
    pos.push(b.x + ox, b.y + oy, b.z + oz);
    col.push(rgb[0], rgb[1], rgb[2]);
  }
  for (let i = 0; i < sides; i++) {
    const i0 = base + i * 2;
    const i1 = base + i * 2 + 1;
    const j0 = base + ((i + 1) % sides) * 2;
    const j1 = j0 + 1;
    idx.push(i0, j0, i1, i1, j0, j1);
  }
}

/** Billboard label drawn from a canvas texture, since three.js has no text. */
function makeLabel(text) {
  const size = 128;
  const canvas = document.createElement('canvas');
  canvas.width = size;
  canvas.height = size;
  const ctx = canvas.getContext('2d');
  ctx.font = '600 62px ui-sans-serif, system-ui, sans-serif';
  ctx.textAlign = 'center';
  ctx.textBaseline = 'middle';
  ctx.fillStyle = 'rgba(0, 0, 0, 0.4)';
  ctx.fillText(text, size / 2 + 2, size / 2 + 2);
  ctx.fillStyle = '#6f768a';
  ctx.fillText(text, size / 2, size / 2);
  const texture = new THREE.CanvasTexture(canvas);
  texture.colorSpace = THREE.SRGBColorSpace;
  const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
    map: texture,
    transparent: true,
    opacity: 0.8,
    depthTest: false,
    depthWrite: false,
  }));
  sprite.renderOrder = 13;
  return sprite;
}

class Viewer3D {
  constructor(container, callbacks = {}) {
    this.container = container;
    this.callbacks = callbacks;
    this.options = {
      showPattern: true,
      showWires: true,
      showHandles: true,
      patternScale: 'db',
      dbRange: 40,
      patternOpacity: 0.85,
      showCurrent: true,
    };
    this.model = null;
    this.result = null;
    this.extent = 1;
    this.lambda = 1;

this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: false });
    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
    this.renderer.setSize(container.clientWidth, container.clientHeight);
    container.appendChild(this.renderer.domElement);

this.scene = new THREE.Scene();
    this.scene.background = new THREE.Color(0x0b1020);

this.camera = new THREE.PerspectiveCamera(45, container.clientWidth / container.clientHeight, 0.01, 5000);
    this.camera.up.copy(UP);
    this.camera.position.set(2, -2.4, 1.6);

this.controls = new OrbitControls(this.camera, this.renderer.domElement);
    this.controls.enableDamping = true;
    this.controls.dampingFactor = 0.08;

this.scene.add(new THREE.AmbientLight(0xffffff, 0.75));
    const key = new THREE.DirectionalLight(0xffffff, 1.1);
    key.position.set(2, -3, 4);
    this.scene.add(key);
    const fill = new THREE.DirectionalLight(0x88aaff, 0.4);
    fill.position.set(-3, 2, -2);
    this.scene.add(fill);

this.grid = new THREE.GridHelper(2, 20, 0x3b4a7a, 0x1d2746);
    this.grid.rotation.x = Math.PI / 2;
    this.scene.add(this.grid);

this.axes = new THREE.AxesHelper(1);
    this.scene.add(this.axes);

this.compass = new THREE.Group();
    for (const dir of ['N', 'E', 'S', 'W']) {
      const label = makeLabel(dir);
      label.userData.dir = dir;
      this.compass.add(label);
    }
    this.scene.add(this.compass);

this.wireGroup = new THREE.Group();
    this.handleGroup = new THREE.Group();
    this.patternGroup = new THREE.Group();
    this.scene.add(this.wireGroup, this.handleGroup, this.patternGroup);

this.groundMesh = new THREE.Mesh(
      new THREE.PlaneGeometry(1, 1),
      new THREE.MeshBasicMaterial({ color: 0x2b6cb0, transparent: true, opacity: 0.18, side: THREE.DoubleSide, depthWrite: false }),
    );
    this.groundMesh.visible = false;
    this.scene.add(this.groundMesh);

this.raycaster = new THREE.Raycaster();
    this.pointer = new THREE.Vector2();
    this.dragPlane = new THREE.Plane();
    this.dragTarget = null;
    this.dragOffset = new THREE.Vector3();

this._bindPointer();
    this._observer = new ResizeObserver(() => this.resize());
    this._observer.observe(container);
    this._animate = this._animate.bind(this);
    this.renderer.setAnimationLoop(this._animate);
  }

setOptions(patch) {
    Object.assign(this.options, patch);
    this.wireGroup.visible = this.options.showWires;
    this.handleGroup.visible = this.options.showWires && this.options.showHandles;
    this.patternGroup.visible = this.options.showPattern;
    if (this.result) this._buildPattern();
    this._buildWires();
  }

setModel(model, { fit = false } = {}) {
    this.model = model;
    this.lambda = 299792458 / (model.frequencyMHz * 1e6);
    this.heightOffset = model.heightOffset ?? 0;
    this._updateExtent();
    this._buildWires();
    this._buildHandles();
    this.groundMesh.visible = model.ground === 'perfect';
    const s = this.extent * 4;
    this.groundMesh.geometry.dispose();
    this.groundMesh.geometry = new THREE.PlaneGeometry(s, s);
    this.grid.scale.setScalar(this.extent * 2);
    this.axes.scale.setScalar(this.extent * 0.8);
    this._placeCompass();
    if (fit) this.fitView();
  }

/** Sits the N/E/S/W labels just outside the ground grid. */
  _placeCompass() {
    const r = this.extent * 2.12;
    const s = this.extent * 0.22;
    const at = { N: [0, r, 0], E: [r, 0, 0], S: [0, -r, 0], W: [-r, 0, 0] };
    for (const label of this.compass.children) {
      label.position.set(...at[label.userData.dir]);
      label.scale.set(s, s, 1);
    }
  }

setResult(result) {
    this.result = result;
    this._buildWires();
    this._buildPattern();
  }

clearResult() {
    this.result = null;
    this._disposeGroup(this.patternGroup);
    this._buildWires();
  }

/** Rebuilds only the conductor geometry (used while dragging a handle). */
  refreshWires() {
    this._updateExtent();
    this._buildWires();
  }

fitView() {
    const r = Math.max(this.extent, this._patternRadius()) * 2.8;
    this.controls.target.set(0, 0, this.model?.ground === 'perfect' ? this.extent * 0.3 : 0);
    this.camera.position.set(r * 0.75, -r * 0.9, r * 0.5);
    this.controls.update();
  }

/** Big enough to enclose the antenna, so the lobes read against the structure. */
  _patternRadius() {
    return Math.max(this.patternReach * 1.25, this.lambda * 0.35);
  }

resize() {
    const w = this.container.clientWidth;
    const h = this.container.clientHeight;
    if (!w || !h) return;
    this.camera.aspect = w / h;
    this.camera.updateProjectionMatrix();
    this.renderer.setSize(w, h);
  }

dispose() {
    this._observer.disconnect();
    this.renderer.setAnimationLoop(null);
    this.renderer.dispose();
  }

_animate() {
    this.controls.update();
    this.renderer.render(this.scene, this.camera);
  }

/** `span` is the antenna's own size; `extent` also covers how high it sits. */
  _updateExtent() {
    let span = 0;
    let top = 0;
    const dz = this.heightOffset ?? 0;
    const lo = [Infinity, Infinity, Infinity];
    const hi = [-Infinity, -Infinity, -Infinity];
    for (const w of this.model.wires) {
      for (const p of [w.p1, w.p2]) {
        span = Math.max(span, Math.abs(p[0]), Math.abs(p[1]), Math.abs(p[2]));
        top = Math.max(top, Math.abs(p[2] + dz));
        const z = p[2] + dz;
        lo[0] = Math.min(lo[0], p[0]); hi[0] = Math.max(hi[0], p[0]);
        lo[1] = Math.min(lo[1], p[1]); hi[1] = Math.max(hi[1], p[1]);
        lo[2] = Math.min(lo[2], z); hi[2] = Math.max(hi[2], z);
      }
    }
    this.span = Math.max(span, 1e-3);
    this.extent = Math.max(this.span, top);

// Energy leaves the conductors, so the lobes radiate from the antenna itself —
    // over ground they simply stop at the horizon.
    this.patternAnchor = [
      (lo[0] + hi[0]) / 2,
      (lo[1] + hi[1]) / 2,
      (lo[2] + hi[2]) / 2,
    ];
    let reach = 0;
    for (const w of this.model.wires) {
      for (const p of [w.p1, w.p2]) {
        reach = Math.max(reach, Math.hypot(
          p[0] - this.patternAnchor[0],
          p[1] - this.patternAnchor[1],
          p[2] + dz - this.patternAnchor[2],
        ));
      }
    }
    this.patternReach = Math.max(reach, 1e-3);
  }

_disposeGroup(group) {
    while (group.children.length) {
      const c = group.children.pop();
      c.geometry?.dispose();
      if (Array.isArray(c.material)) c.material.forEach((m) => m.dispose());
      else c.material?.dispose();
    }
  }

_buildWires() {
    if (!this.model) return;
    this._disposeGroup(this.wireGroup);
    const pos = [];
    const col = [];
    const idx = [];
    const drawRadius = (r) => Math.max(r, this.span * 0.016);

if (!pos.length) return;
    const geo = new THREE.BufferGeometry();
    geo.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
    geo.setAttribute('color', new THREE.Float32BufferAttribute(col, 3));
    geo.setIndex(idx);
    geo.computeVertexNormals();
    this.wireGroup.add(new THREE.Mesh(geo, new THREE.MeshStandardMaterial({
      vertexColors: true,
      roughness: 0.3,
      metalness: 0.2,
      emissive: 0xffffff,
      emissiveIntensity: 0.18,
    })));

// Second pass without depth testing, so the conductors stay readable
    // even when they are buried inside the pattern surface.
    const ghost = new THREE.Mesh(geo, new THREE.MeshBasicMaterial({
      vertexColors: true,
      transparent: true,
      opacity: 0.55,
      depthTest: false,
      depthWrite: false,
    }));
    ghost.renderOrder = 10;
    this.wireGroup.add(ghost);

const feed = this.result?.feedPoint ?? this._feedPoint();
    if (feed) {
      const marker = new THREE.Mesh(
        new THREE.SphereGeometry(this.span * 0.028, 16, 12),
        new THREE.MeshBasicMaterial({ color: 0xff3b6b, depthTest: false, depthWrite: false, transparent: true }),
      );
      marker.position.set(...feed);
      marker.renderOrder = 11;
      marker.userData.isFeed = true;
      this.wireGroup.add(marker);
    }
  }

_feedPoint() {
    const w = this.model.wires.find((x) => x.id === this.model.feed.wireId);
    if (!w) return null;
    const f = this.model.feed.fraction;
    const p = [0, 1, 2].map((i) => w.p1[i] + (w.p2[i] - w.p1[i]) * f);
    p[2] += this.heightOffset ?? 0;
    return p;
  }

_buildHandles() {
    this._disposeGroup(this.handleGroup);
    const geo = new THREE.SphereGeometry(this.span * 0.032, 16, 12);
    const dz = this.heightOffset ?? 0;
    for (const w of this.model.wires) {
      for (const end of [0, 1]) {
        const mesh = new THREE.Mesh(geo.clone(), new THREE.MeshBasicMaterial({
          color: 0x7fd1ff,
          transparent: true,
          opacity: 0.95,
          depthTest: false,
        }));
        const p = end === 0 ? w.p1 : w.p2;
        mesh.position.set(p[0], p[1], p[2] + dz);
        mesh.renderOrder = 12;
        mesh.userData = { wireId: w.id, end };
        this.handleGroup.add(mesh);
      }
    }
    this.handleGroup.visible = this.options.showWires && this.options.showHandles;
  }

_buildPattern() {
    this._disposeGroup(this.patternGroup);
    if (!this.result || !this.options.showPattern) return;
    this.patternGroup.position.set(...this.patternAnchor);
    const { thetaCount, phiCount, stepDeg, gainDb } = this.result.pattern;
    const maxDb = this.result.gainDbi;
    const range = this.options.dbRange;
    const scale = this._patternRadius();

const pos = new Float32Array(thetaCount * phiCount * 3);
    const col = new Float32Array(thetaCount * phiCount * 3);
    const idx = [];

for (let it = 0; it < thetaCount; it++) {
      const th = (it * stepDeg * Math.PI) / 180;
      for (let ip = 0; ip < phiCount; ip++) {
        const ph = (ip * stepDeg * Math.PI) / 180;
        const g = gainDb[it * phiCount + ip];
        let r;
        if (this.options.patternScale === 'db') {
          r = Math.max(0, (g - (maxDb - range)) / range);
        } else {
          r = Math.pow(10, (g - maxDb) / 10);
        }
        if (!Number.isFinite(r)) r = 0;
        const k = (it * phiCount + ip) * 3;
        const rr = r * scale;
        pos[k] = rr * Math.sin(th) * Math.cos(ph);
        pos[k + 1] = rr * Math.sin(th) * Math.sin(ph);
        pos[k + 2] = rr * Math.cos(th);
        const rgb = colorAt(r);
        col[k] = rgb[0];
        col[k + 1] = rgb[1];
        col[k + 2] = rgb[2];
      }
    }
    for (let it = 0; it < thetaCount - 1; it++) {
      for (let ip = 0; ip < phiCount - 1; ip++) {
        const a = it * phiCount + ip;
        const b = a + 1;
        const c = a + phiCount;
        const d = c + 1;
        idx.push(a, c, b, b, c, d);
      }
    }
    const geo = new THREE.BufferGeometry();
    geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
    geo.setAttribute('color', new THREE.BufferAttribute(col, 3));
    geo.setIndex(idx);
    geo.computeVertexNormals();
    const mat = new THREE.MeshStandardMaterial({
      vertexColors: true,
      transparent: this.options.patternOpacity < 1,
      opacity: this.options.patternOpacity,
      side: THREE.DoubleSide,
      roughness: 0.6,
      metalness: 0.05,
      depthWrite: this.options.patternOpacity > 0.95,
    });
    this.patternGroup.add(new THREE.Mesh(geo, mat));

const wire = new THREE.Mesh(geo, new THREE.MeshBasicMaterial({ color: 0x0b1020, wireframe: true, transparent: true, opacity: 0.12 }));
    this.patternGroup.add(wire);
    this.patternGroup.visible = true;
  }

_bindPointer() {
    const el = this.renderer.domElement;
    const toPointer = (ev) => {
      const rect = el.getBoundingClientRect();
      this.pointer.x = ((ev.clientX - rect.left) / rect.width) * 2 - 1;
      this.pointer.y = -((ev.clientY - rect.top) / rect.height) * 2 + 1;
    };

el.addEventListener('pointerdown', (ev) => {
      if (!this.options.showHandles || !this.handleGroup.visible) return;
      toPointer(ev);
      this.raycaster.setFromCamera(this.pointer, this.camera);
      const hit = this.raycaster.intersectObjects(this.handleGroup.children, false)[0];
      if (!hit) return;
      this.dragTarget = hit.object;
      this.controls.enabled = false;
      const normal = this.camera.getWorldDirection(new THREE.Vector3()).negate();
      this.dragPlane.setFromNormalAndCoplanarPoint(normal, this.dragTarget.position);
      this.dragOffset.copy(this.dragTarget.position).sub(hit.point);
      el.setPointerCapture(ev.pointerId);
      this.dragTarget.material.color.set(0xffd166);
    });

el.addEventListener('pointermove', (ev) => {
      if (!this.dragTarget) return;
      toPointer(ev);
      this.raycaster.setFromCamera(this.pointer, this.camera);
      const p = new THREE.Vector3();
      if (!this.raycaster.ray.intersectPlane(this.dragPlane, p)) return;
      p.add(this.dragOffset);
      if (this.model?.ground === 'perfect' && p.z < 0) p.z = 0;
      this.dragTarget.position.copy(p);
      const { wireId, end } = this.dragTarget.userData;
      this.callbacks.onHandleDrag?.(wireId, end, [p.x, p.y, p.z], false);
    });

const endDrag = (ev) => {
      if (!this.dragTarget) return;
      const { wireId, end } = this.dragTarget.userData;
      const p = this.dragTarget.position;
      this.dragTarget.material.color.set(0x7fd1ff);
      this.dragTarget = null;
      this.controls.enabled = true;
      el.releasePointerCapture?.(ev.pointerId);
      this.callbacks.onHandleDrag?.(wireId, end, [p.x, p.y, p.z], true);
    };
    el.addEventListener('pointerup', endDrag);
    el.addEventListener('pointercancel', endDrag);
  }
}

// ===== src/main.js =====
// Application wiring: model state, solver worker, 3D view, charts and panels.

const $ = (id) => document.getElementById(id);

const refs = {
  presetSelect: $('presetSelect'),
  loadPresetBtn: $('loadPresetBtn'),
  freq: $('freq'),
  bandSelect: $('bandSelect'),
  lambdaOut: $('lambdaOut'),
  bandOut: $('bandOut'),
  groundSelect: $('groundSelect'),
  groundHint: $('groundHint'),
  heightOffset: $('heightOffset'),
  heightOut: $('heightOut'),
  z0: $('z0'),
  z0Preset: $('z0Preset'),
  materialSelect: $('materialSelect'),
  wireTbody: $('wireTbody'),
  addWireBtn: $('addWireBtn'),
  autoSegBtn: $('autoSegBtn'),
  advancedGeom: $('advancedGeom'),
  feedWire: $('feedWire'),
  feedFraction: $('feedFraction'),
  feedFractionOut: $('feedFractionOut'),
};

const statusEl = $('status');
const metricsEl = $('metrics');
const summaryEl = $('summaryBox');
const warningsPanel = $('warningsPanel');
const warningsList = $('warnings');
const azCanvas = $('azCanvas');
const elCanvas = $('elCanvas');
const sweepCanvas = $('sweepCanvas');
const sweepProgress = $('sweepProgress');
const modelNameEl = $('modelName');

let model = PRESETS[0].create();
let result = null;
let sweepData = null;
let requestId = 0;
let pendingAnalysis = 0;
let debounceTimer = 0;

const worker = createSolver();

const sidebar = new Sidebar(refs, {
  onChange() {
    viewer.setModel(model);
    scheduleAnalysis();
  },
});

function setStatus(text, kind = '') {
  statusEl.textContent = text;
  statusEl.className = `status ${kind}`;
}

function scheduleAnalysis() {
  if (!$('autoSolve').checked) {
    setStatus('Model changed — press Analyse');
    return;
  }
  clearTimeout(debounceTimer);
  debounceTimer = window.setTimeout(runAnalysis, 300);
}

function runSweep() {
  const span = Math.max(0.1, Number($('sweepSpan').value)) / 100;
  const f = model.frequencyMHz;
  startSweep(f * (1 - span), f * (1 + span));
}

function sweepOptions() {
  const band = bandFor(model.frequencyMHz);
  return { markerMHz: model.frequencyMHz, band };
}

worker.onmessage = (ev) => {
  const msg = ev.data;
  if (msg.type === 'analyze:done') {
    if (msg.id !== pendingAnalysis) return;
    result = msg.result;
    viewer.setResult(result);
    renderSummary(summaryEl, result);
    renderMetrics(metricsEl, result);
    renderWarnings(warningsPanel, warningsList, result.warnings);
    drawCuts();
    drawSweep(sweepCanvas, sweepData, sweepOptions());
    setStatus(`Solved ${result.basisCount} unknowns in ${result.solveTimeMs.toFixed(0)} ms`);
  } else if (msg.type === 'sweep:progress') {
    sweepProgress.firstElementChild.style.width = `${(msg.progress * 100).toFixed(0)}%`;
  } else if (msg.type === 'sweep:done') {
    sweepData = msg.data;
    sweepProgress.hidden = true;
    drawSweep(sweepCanvas, sweepData, sweepOptions());
    setStatus('Sweep complete');
  } else if (msg.type === 'error') {
    sweepProgress.hidden = true;
    setStatus(msg.message, 'error');
    renderWarnings(warningsPanel, warningsList, [msg.message]);
  }
};

worker.onerror = (err) => setStatus(`Solver failed: ${err.message}`, 'error');

// ---- toolbar & file actions -------------------------------------------------

$('solveBtn').addEventListener('click', runAnalysis);
$('runSweep').addEventListener('click', runSweep);
$('runBandSweep').addEventListener('click', runBandSweep);
$('resetView').addEventListener('click', () => viewer.fitView());

for (const btn of document.querySelectorAll('#rotateTools button')) {
  btn.addEventListener('click', () => {
    rotateModel(model, btn.dataset.axis);
    sidebar.syncValues();
    viewer.setModel(model);
    scheduleAnalysis();
  });
}

$('loadPresetBtn').addEventListener('click', () => {
  const preset = presetById(refs.presetSelect.value);
  if (preset) loadModel(preset.create());
});

for (const [id, key] of [['togglePattern', 'showPattern'], ['toggleWires', 'showWires'], ['toggleCurrent', 'showCurrent']]) {
  $(id).addEventListener('change', (e) => viewer.setOptions({ [key]: e.target.checked }));
}
$('scaleSelect').addEventListener('change', (e) => viewer.setOptions({ patternScale: e.target.value }));
$('dbRange').addEventListener('input', (e) => {
  viewer.setOptions({ dbRange: Number(e.target.value) });
  drawCuts();
});
$('opacity').addEventListener('input', (e) => viewer.setOptions({ patternOpacity: Number(e.target.value) }));

$('exportBtn').addEventListener('click', () => {
  const blob = new Blob([modelToJson(model)], { type: 'application/json' });
  const a = document.createElement('a');
  a.href = URL.createObjectURL(blob);
  a.download = `${model.name.replace(/[^\w.-]+/g, '_') || 'antenna'}.json`;
  a.click();
  setTimeout(() => URL.revokeObjectURL(a.href), 1000);
});

$('importBtn').addEventListener('click', () => $('importFile').click());
$('importFile').addEventListener('change', async (e) => {
  const file = e.target.files?.[0];
  if (!file) return;
  try {
    loadModel(modelFromJson(await file.text()));
  } catch (err) {
    setStatus(`Could not open file: ${err.message}`, 'error');
  }
  e.target.value = '';
});

window.addEventListener('resize', () => {
  drawCuts();
  drawSweep(sweepCanvas, sweepData, sweepOptions());
});

// ---- boot -------------------------------------------------------------------

sidebar.render(model, { structural: true });
viewer.setModel(model, { fit: true });
modelNameEl.textContent = model.name;
renderSummary(summaryEl, null);
renderMetrics(metricsEl, null);
drawPolar(azCanvas, null);
drawPolar(elCanvas, null);
drawSweep(sweepCanvas, null);
runAnalysis();