Adom Fields

@@ -0,0 +1,299 @@+//! Power delivery: each rail's impedance seen from its load pin, 1 kHz to 1 GHz, against a target, with+//! the capacitors that would bring it under. The rail is a set of branches in parallel at the load pin:+//!  - the source: a regulator output (flat below its loop crossover, then an inductance that resonates with+//!    the output capacitors, damped to Q about 1, a phase margin near 50°), or a cable from a connector;+//!  - every capacitor from the rail to ground: its value from the board, ESR by type, its body inductance+//!    from its pad span, and the mounting inductance of the copper between it and the load pin (a+//!    microstrip over the ground plane, so it grows with distance);+//!  - the rail's own copper over the ground plane, a parallel-plate capacitor.+//! |Z(f)| is the exact parallel sum; the target is V·tolerance / step current. A peak over the target becomes+//! an issue whose action is the capacitor (value, package, pin) that brings it down, chosen by re-solving+//! with each candidate. The same branches are written as an ngspice netlist and, when ngspice is there,+//! run as a cross-check. A converter's input rail also gets Middlebrook's check: its input network has to+//! stay well under the converter's negative input resistance, V²/P, or the loop can oscillate.+use crate::board::{Board, Pad, LAYERS};+use crate::fields::{Fields, Issue, Spec};+use crate::flow::{is_ground, rail_from_name};+use serde_json::{json, Value};+use std::f64::consts::PI;++const E0: f64 = 8.854e-15; // F/mm+fn r2(v: f64) -> f64 { (v * 100.0).round() / 100.0 }+fn sig(v: f64) -> f64 { if v == 0.0 || !v.is_finite() { return v; } let p = 10f64.powi(3 - v.abs().log10().floor() as i32); (v * p).round() / p }++#[derive(Clone, Copy)] struct Cx(f64, f64);+impl Cx {+    fn add(self, o: Cx) -> Cx { Cx(self.0 + o.0, self.1 + o.1) }+    fn mul(self, o: Cx) -> Cx { Cx(self.0 * o.0 - self.1 * o.1, self.0 * o.1 + self.1 * o.0) }+    fn inv(self) -> Cx { let d = self.0 * self.0 + self.1 * self.1; Cx(self.0 / d, -self.1 / d) }+    fn abs(self) -> f64 { self.0.hypot(self.1) }+}++/// One branch from the rail to ground: R, then L, then (Lp ∥ Rp), then C (0 = no such element).+#[derive(Clone)]+pub struct Branch { pub name: String, pub kind: &'static str, pub r: f64, pub l: f64, pub lp: f64, pub rp: f64, pub c: f64, pub at: Option<[f64; 2]>, pub extra: Value }+impl Branch {+    fn z(&self, w: f64) -> Cx {+        let mut z = Cx(self.r, w * self.l);+        if self.lp > 0.0 { let zl = Cx(0.0, w * self.lp); z = z.add(if self.rp > 0.0 { zl.mul(Cx(self.rp, 0.0)).mul(zl.add(Cx(self.rp, 0.0)).inv()) } else { zl }); }+        if self.c > 0.0 { z = z.add(Cx(0.0, -1.0 / (w * self.c))); }+        z+    }+}+fn zrail(bs: &[Branch], f: f64) -> Cx { let w = 2.0 * PI * f; bs.iter().fold(Cx(0.0, 0.0), |y, b| y.add(b.z(w).inv())).inv() }+pub fn freqs() -> Vec<f64> { (0..=240).map(|k| 10f64.powf(3.0 + k as f64 / 40.0)).collect() }++/// A microstrip's inductance per mm (Hammerstad), w wide at h over the plane: Z0·√εeff / c.+fn l_per_mm(w: f64, h: f64) -> f64 {+    let u = w / h; let er = 4.3;+    let ee = (er + 1.0) / 2.0 + (er - 1.0) / 2.0 / (1.0 + 12.0 / u).sqrt();+    let z0 = if u <= 1.0 { 60.0 / ee.sqrt() * (8.0 / u + u / 4.0).ln() } else { 120.0 * PI / (ee.sqrt() * (u + 1.393 + 0.667 * (u + 1.444).ln())) };+    z0 * ee.sqrt() / 2.99792458e8 * 1e-3+}+/// A capacitor's ESR by value and kind (MLCC unless the value says electrolytic, tantalum or polymer).+fn esr_of(c: f64, val: &str) -> (f64, &'static str) {+    let v = val.to_ascii_lowercase();+    if v.contains("poly") { return (0.015, "polymer"); }+    if v.contains("el") || v.contains("alu") { return (0.15, "electrolytic"); }+    if v.contains("tant") { return (0.1, "tantalum"); }+    (if c >= 10e-6 { 0.003 } else if c >= 1e-6 { 0.006 } else if c >= 100e-9 { 0.015 } else if c >= 10e-9 { 0.04 } else { 0.1 }, "ceramic")+}+fn fmt_c(c: f64) -> String { if c >= 1e-6 { format!("{}uF", sig(c * 1e6)) } else if c >= 1e-9 { format!("{}nF", sig(c * 1e9)) } else { format!("{}pF", sig(c * 1e12)) } }+fn fmt_hz(f: f64) -> String { if f >= 1e9 { format!("{:.2} GHz", f / 1e9) } else if f >= 1e6 { format!("{:.1} MHz", f / 1e6) } else { format!("{:.0} kHz", f / 1e3) } }+fn fmt_ohm(z: f64) -> String { if z >= 1.0 { format!("{:.2} Ω", z) } else { format!("{:.0} mΩ", z * 1e3) } }++#[derive(serde::Deserialize, Clone, Default)]+#[allow(non_snake_case)]+pub struct RailCfg {+    /// the target impedance (Ω); else V·tolPct/100 / stepA+    #[serde(default)] pub targetOhm: Option<f64>, #[serde(default)] pub tolPct: Option<f64>, #[serde(default)] pub stepA: Option<f64>,+    /// the band the target holds over (Hz)+    #[serde(default)] pub fminHz: Option<f64>, #[serde(default)] pub fmaxHz: Option<f64>,+    /// the source, when it is not a modelled converter: a cable's R (Ω) and L (nH); a regulator's loop crossover (Hz)+    #[serde(default)] pub sourceOhm: Option<f64>, #[serde(default)] pub sourceNh: Option<f64>, #[serde(default)] pub crossoverHz: Option<f64>,+    /// the load pin ("U3.7"), when the first chip pin on the rail is not it+    #[serde(default)] pub load: Option<String>,+}++pub fn review(f: &Fields, b: &Board, spec: &Spec, conv: &Value, issues: &mut Vec<Issue>, out_dir: Option<&std::path::Path>) -> Value {+    let rail = |n: &str| spec.voltages.get(n).copied().or_else(|| rail_from_name(n));+    let Some(gnd) = f.net_names.iter().find(|n| is_ground(n)).cloned() else { return json!({"rails": [], "note": "no ground net"}) };+    let refs: Vec<String> = { let mut v: Vec<String> = b.pads.iter().map(|p| p.reference.clone()).collect(); v.sort(); v.dedup(); v };+    let nets_of = |r: &str| -> Vec<String> { let mut v: Vec<String> = b.pads.iter().filter(|p| p.reference == r).map(|p| p.net.clone()).collect(); v.sort(); v.dedup(); v };+    let pads_of = |r: &str, n: &str| -> Vec<&Pad> { b.pads.iter().filter(|p| p.reference == r && p.net == n).collect() };+    let n = f.w * f.h;+    let real: Vec<usize> = (0..LAYERS.len()).filter(|k| f.net_ids[*k].iter().filter(|x| **x != u16::MAX).count() > n * 15 / 100).collect();+    let h = { let t: f64 = if spec.stackupMm.len() == 3 { spec.stackupMm.iter().sum() } else { 1.465 }; if real.len() <= 2 { t } else { spec.stackupMm.first().copied().unwrap_or(0.2) } };+    let gid = f.net_names.iter().position(|x| *x == gnd).map(|i| i as u16);+    let fs = freqs();+    let mut rails = Vec::new();+    for (name, nid) in f.net_names.iter().enumerate().map(|(i, x)| (x.clone(), i as u16)) {+        let Some(v) = rail(&name) else { continue }; if v <= 0.0 || is_ground(&name) || spec.switching.contains_key(&name) { continue; }+        let cfg = spec.pdn.get(&name).cloned().unwrap_or_default();+        let is_out = conv["outNet"].as_str() == Some(&name); let is_in = conv["inNet"].as_str() == Some(&name);+        let srcs: Vec<String> = spec.sources.get(&name).cloned().unwrap_or_default();+        let caps: Vec<String> = refs.iter().filter(|r| r.starts_with('C') && nets_of(r).contains(&name) && nets_of(r).contains(&gnd)).cloned().collect();+        if caps.is_empty() && !is_out { continue; }+        // what feeds the rail: the spec's sources, the modelled converter, an on-board regulator (a part named+        // like one, bridging this rail, ground and a higher rail), or the connector the solve found the+        // current entering by; nothing else is guessed: a rail with no known source gets no verdict+        let bridges = |r: &str| { let ns = nets_of(r); ns.contains(&name) && ns.contains(&gnd) && ns.iter().any(|x| *x != name && rail(x).map_or(false, |vx| vx > v)) };+        const REG: [&str; 26] = ["ldo", "reg", "tlv7", "tps7", "lp59", "lp29", "lp38", "ap21", "ap7", "mcp17", "xc62", "ams1117", "lm1117", "ld11", "ld39", "ldl", "lm317", "lm78", "78l", "ncp1", "ht7", "rt9", "sgm2", "me62", "adp1", "max88"];+        let looks_reg = |r: &str| b.values.get(r).map_or(false, |v| { let l = v.to_ascii_lowercase(); REG.iter().any(|k| l.contains(k)) });+        let reg: Option<String> = if is_out { None } else { srcs.iter().find(|r| r.starts_with('U')).cloned().or_else(|| refs.iter().find(|r| r.starts_with('U') && bridges(r) && looks_reg(r)).cloned()) };+        let entry: Vec<String> = if !srcs.is_empty() { srcs.iter().filter(|r| r.starts_with('J') || r.starts_with('P')).cloned().collect() } else { f.flow.get(&name).map(|nf| { let mut v: Vec<String> = nf.terminals.iter().filter(|t| t.side == "ext" && (t.reference.starts_with('J') || t.reference.starts_with('P'))).map(|t| t.reference.clone()).collect(); v.dedup(); v }).unwrap_or_default() };+        if !is_out && reg.is_none() && entry.is_empty() && cfg.sourceOhm.is_none() {+            let maybe: Vec<String> = refs.iter().filter(|r| r.starts_with('U') && bridges(r) && b.pads.iter().filter(|p| p.reference == **r).count() <= 8).cloned().collect();+            rails.push(json!({"net": name, "railV": v, "skipped": format!("no known source{}: name the regulator or the connector in spec sources.{}, or give pdn.{}.sourceOhm and sourceNh", if maybe.is_empty() { String::new() } else { format!(" ({} bridges {} and a higher rail: if it is the regulator, say so)", maybe.join(", "), name) }, name, name)}));+            continue;+        }+        // the load pin: named, else the chip with the most pins on the rail, else a connector pin that is not the entry+        let skip = |r: &str| srcs.iter().any(|x| x == r) || reg.as_deref() == Some(r) || entry.iter().any(|x| x == r);+        let mut chips: Vec<(String, usize)> = refs.iter().filter(|r| r.starts_with('U') && !skip(r)).map(|r| (r.clone(), b.pads.iter().filter(|p| p.reference == *r && p.net == name).count())).filter(|x| x.1 > 0).collect();+        chips.sort_by(|a, z| z.1.cmp(&a.1));+        let conn_pins: Vec<&Pad> = b.pads.iter().filter(|p| p.net == name && (p.reference.starts_with('J') || (p.reference.starts_with('P') && !p.reference.starts_with("PS")))).collect();+        let load: Option<&Pad> = cfg.load.as_ref().and_then(|l| { let (r, p) = l.split_once('.')?; b.pads.iter().find(|x| x.reference == r && x.pad == p) })+            .or_else(|| chips.first().and_then(|c| b.pads.iter().find(|p| p.reference == c.0 && p.net == name)))+            .or_else(|| conn_pins.iter().find(|p| !entry.contains(&p.reference)).copied());+        let Some(load) = load else { rails.push(json!({"net": name, "railV": v, "skipped": "no load pin: no chip or outgoing connector on the rail (pdn.<net>.load names one)"})); continue };+        let at_chip = load.reference.starts_with('U');+        // the copper's own geometry: a pour is wider than a trace+        let k0 = real.first().copied().unwrap_or(0);+        let area_top = f.net_ids[k0].iter().filter(|x| **x == nid).count() as f64 * f.d * f.d;+        let wmm = if area_top > 15.0 { 2.0 } else { 0.8 };+        let lpm = l_per_mm(wmm, h);+        let mut bs: Vec<Branch> = Vec::new();+        let mut cap_total = 0.0;+        for r in &caps {+            let Some(val) = b.values.get(r) else { continue }; let Some(c) = crate::emc::parse_value(val, 'F') else { continue };+            let cv = pads_of(r, &name); let cg = pads_of(r, &gnd); let (Some(cv), Some(cg)) = (cv.first(), cg.first()) else { continue };+            let span = (cv.x - cg.x).hypot(cv.y - cg.y);+            let (esr, kind) = esr_of(c, val);+            let esl = (0.15 + 0.3 * span) * 1e-9;+            let dist = (cv.x - load.x).hypot(cv.y - load.y);+            let mount = (lpm * dist + 0.2e-9).max(0.2e-9);+            cap_total += c;+            bs.push(Branch { name: r.clone(), kind: "capacitor", r: esr, l: esl + mount, lp: 0.0, rp: 0.0, c, at: Some([r2(cv.x), r2(cv.y)]), extra: json!({"value": val, "type": kind, "uF": sig(c * 1e6), "esrMohm": sig(esr * 1e3), "eslNh": sig(esl * 1e9), "mountNh": sig(mount * 1e9), "distMm": r2(dist), "srfHz": sig(1.0 / (2.0 * PI * (c * (esl + mount)).sqrt()))}) });+        }+        // the plane: this rail's copper facing ground on the next real layer+        let mut over = 0usize;+        if let Some(g) = gid { for w in real.windows(2) { for i in 0..n { let (a, z) = (f.net_ids[w[0]][i], f.net_ids[w[1]][i]); if (a == nid && z == g) || (a == g && z == nid) { over += 1; } } } }+        let gap = if real.len() <= 2 { h } else { spec.stackupMm.first().copied().unwrap_or(0.2) };+        let cplane = E0 * 4.3 * over as f64 * f.d * f.d / gap;+        if cplane > 0.0 { bs.push(Branch { name: "plane".into(), kind: "plane", r: 0.002, l: 0.0, lp: 0.0, rp: 0.0, c: cplane, at: Some([r2(load.x), r2(load.y)]), extra: json!({"pF": sig(cplane * 1e12), "mm2": r2(over as f64 * f.d * f.d), "gapMm": gap}) }); }+        // the source+        // a regulator loop: flat below its crossover, then L_eq resonating with the rail's capacitors there,+        // damped to Q 1; well above the crossover the loop gives up (a converter's output is its power+        // inductor), so a series L a decade above keeps the damping resistor from looking like a source+        let loop_branch = |nm: String, fc: f64, at: Option<[f64; 2]>, path: f64, what: &str| -> Branch {+            let ctot = (cap_total + cplane).max(1e-9); let wc = 2.0 * PI * fc;+            let leq = 1.0 / (wc * wc * ctot); let rd = (leq / ctot).sqrt(); let lhf = rd / (2.0 * PI * 10.0 * fc);+            Branch { name: nm, kind: "regulator", r: 0.005, l: path + lhf, lp: leq, rp: rd, c: 0.0, at, extra: json!({"crossoverHz": sig(fc), "lEqNh": sig(leq * 1e9), "dampOhm": sig(rd), "lHfNh": sig(lhf * 1e9), "rFlatMohm": 5.0, "model": format!("{what}: flat 5 mΩ, then L_eq resonating with the rail's capacitors at the loop crossover, damped to Q 1, fading out a decade above it (pdn.<net>.crossoverHz)")}) }+        };+        let path_from = |p: Option<&Pad>| p.map(|p| lpm * (p.x - load.x).hypot(p.y - load.y)).unwrap_or(0.0);+        let src: Option<Branch> = if let Some(r) = cfg.sourceOhm {+            let l = cfg.sourceNh.unwrap_or(700.0) * 1e-9; let feed = entry.first().and_then(|e| b.pads.iter().find(|p| p.reference == *e && p.net == name));+            Some(Branch { name: entry.first().map(|e| format!("{e} cable")).unwrap_or("source".into()), kind: "cable", r, l: l + path_from(feed), lp: 0.0, rp: 0.0, c: 0.0, at: feed.map(|p| [r2(p.x), r2(p.y)]), extra: json!({"rOhm": r, "nH": sig(l * 1e9), "model": "the spec's source: pdn.<net>.sourceOhm/sourceNh"}) })+        } else if is_out {+            let fsw = conv["fswHz"].as_f64().unwrap_or(500e3);+            let lp = pads_of(conv["inductor"].as_str().unwrap_or("L1"), &name).first().copied();+            Some(loop_branch(format!("{} loop", conv["switch"].as_str().unwrap_or("regulator")), cfg.crossoverHz.unwrap_or(fsw / 10.0), lp.map(|p| [r2(p.x), r2(p.y)]), path_from(lp), "the converter's output"))+        } else if let Some(u) = &reg {+            let up = pads_of(u, &name).first().copied();+            Some(loop_branch(format!("{u} loop"), cfg.crossoverHz.unwrap_or(100e3), up.map(|p| [r2(p.x), r2(p.y)]), path_from(up), "a linear regulator, crossover about 100 kHz assumed"))+        } else {+            // a connector feeding the rail: about a metre of supply leads+            let feed = entry.iter().find_map(|e| b.pads.iter().find(|p| p.reference == *e && p.net == name));+            let (r, l) = (0.03, cfg.sourceNh.unwrap_or(700.0) * 1e-9);+            Some(Branch { name: format!("{} cable", entry[0]), kind: "cable", r, l: l + path_from(feed), lp: 0.0, rp: 0.0, c: 0.0, at: feed.map(|p| [r2(p.x), r2(p.y)]), extra: json!({"rOhm": r, "nH": sig(l * 1e9), "model": "about a metre of supply leads: 30 mΩ, 0.7 µH (spec pdn.<net>.sourceOhm/sourceNh)"}) })+        };+        if let Some(s) = src { bs.insert(0, s); }+        if bs.is_empty() { continue; }+        // the target and its band+        let step = cfg.stepA.unwrap_or_else(|| if is_in { conv["iout"].as_f64().unwrap_or(1.0) } else { spec.loads.get(&name).map(|l| l.amps * 0.5).unwrap_or(0.1) });+        let tol = cfg.tolPct.unwrap_or(5.0);+        let zt = cfg.targetOhm.unwrap_or(v * tol / 100.0 / step.max(1e-6));+        let flo = cfg.fminHz.unwrap_or(1e3);+        let fhi = cfg.fmaxHz.unwrap_or_else(|| if is_in { 0.35 / (conv["riseNs"].as_f64().unwrap_or(8.0) * 1e-9) } else if at_chip { 100e6 } else { 1e6 });+        let band = |x: f64| x >= flo * 0.999 && x <= fhi * 1.001;+        let curve = |bs: &[Branch]| -> Vec<f64> { fs.iter().map(|x| zrail(bs, *x).abs()).collect() };+        let worst = |z: &[f64]| -> (usize, f64) { let mut wi = 0; let mut wr = 0.0; for (i, x) in fs.iter().enumerate() { if band(*x) && z[i] / zt > wr { wr = z[i] / zt; wi = i; } } (wi, wr) };+        let z0 = curve(&bs);+        let (wi, wr) = worst(&z0);+        // which branches make the peak: the inductive one and the capacitive one with the largest admittance+        let blame = |bs: &[Branch], fq: f64| -> (Option<String>, Option<String>) { let w = 2.0 * PI * fq; let (mut li, mut ci) = ((None, 0.0), (None, 0.0)); for x in bs { let z = x.z(w); let y = 1.0 / z.abs(); if z.1 > 0.0 { if y > li.1 { li = (Some(x.name.clone()), y); } } else if y > ci.1 { ci = (Some(x.name.clone()), y); } } (li.0, ci.0) };+        let (bl, bc) = blame(&bs, fs[wi]);+        let load_name = format!("{}.{}", load.reference, load.pad);+        // the fix: add the capacitor that lowers the worst peak most, re-solve, up to three+        let mut fixes: Vec<Value> = Vec::new(); let mut cur = bs.clone(); let mut cur_r = wr; let mut zf = z0.clone();+        if wr > 1.0 {+            let mlcc = [1e-9, 2.2e-9, 4.7e-9, 10e-9, 22e-9, 47e-9, 100e-9, 220e-9, 470e-9, 1e-6, 2.2e-6, 4.7e-6, 10e-6, 22e-6];+            let mount = lpm * 1.0 + 0.2e-9;+            for _ in 0..3 {+                let mut best: Option<(f64, Branch)> = None;+                let mut cands: Vec<Branch> = mlcc.iter().map(|&c| { let (pkg, span) = if c <= 1e-6 { ("0402", 1.0) } else if c <= 4.7e-6 { ("0603", 1.6) } else { ("0805", 2.0) }; let (esr, _) = esr_of(c, ""); let esl = (0.15 + 0.3 * span) * 1e-9; Branch { name: format!("new {}", fmt_c(c)), kind: "capacitor", r: esr, l: esl + mount, lp: 0.0, rp: 0.0, c, at: Some([r2(load.x), r2(load.y)]), extra: json!({"value": fmt_c(c), "package": pkg, "type": "ceramic", "new": true}) } }).collect();+                // a damping bulk capacitor for a low resonance: its ESR soaks up the LC ring+                for c in [47e-6, 100e-6, 220e-6] { cands.push(Branch { name: format!("new {}", fmt_c(c)), kind: "capacitor", r: 0.15, l: 3e-9 + mount, lp: 0.0, rp: 0.0, c, at: Some([r2(load.x), r2(load.y)]), extra: json!({"value": fmt_c(c), "package": "SMD can", "type": "electrolytic", "esrOhm": 0.15, "new": true}) }); }+                for cand in cands { let mut t = cur.clone(); t.push(cand.clone()); let z = curve(&t); let (_, r) = worst(&z); if best.as_ref().map_or(true, |b| r < b.0 * 0.98) { best = Some((r, cand)); } }+                let Some((r, cand)) = best else { break };+                if r > cur_r * 0.97 { break; }+                let before = cur_r; cur.push(cand.clone()); zf = curve(&cur); let (wi2, _) = worst(&zf); cur_r = r;+                fixes.push(json!({"value": cand.extra["value"], "package": cand.extra["package"], "type": cand.extra["type"], "nearPin": load_name, "ratioBefore": sig(before), "ratioAfter": sig(r), "worstAfterHz": sig(fs[wi2]), "worstAfterOhm": sig(zf[wi2])}));+                if r <= 1.0 { break; }+            }+            let peak = format!("{}: |Z| {} at {} seen from {}, {:.1}× its {} target ({} V, ±{} % for a {} A step){}", name, fmt_ohm(z0[wi]), fmt_hz(fs[wi]), load_name, wr, fmt_ohm(zt), v, tol, sig(step), match (&bl, &bc) { (Some(l), Some(c)) if wr > 1.0 => format!(": {} going inductive against {}", l, c), _ => String::new() });+            let sev = if wr > 2.0 { "medium" } else { "low" };+            if fixes.is_empty() {+                issues.push(Issue { severity: sev.into(), kind: "pdn-impedance".into(), what: peak.clone(), at: Some([r2(load.x), r2(load.y)]), layer: Some(LAYERS[k0].into()), net: Some(name.clone()), reference: Some(load.reference.clone()), fix: format!("No single capacitor brings it under: widen {} and its ground into planes, and move the existing capacitors next to {}.", name, load_name), action: Some(json!({"type": "review", "net": name, "why": "PDN impedance over target"})) });+            }+            for (k, fx) in fixes.iter().enumerate() {+                let what = if k == 0 { peak.clone() } else { format!("{}: still {:.1}× the target after the capacitor(s) above", name, fixes[k - 1]["ratioAfter"].as_f64().unwrap_or(0.0)) };+                let ok = fx["ratioAfter"].as_f64().unwrap_or(9.0) <= 1.0;+                issues.push(Issue { severity: sev.into(), kind: "pdn-impedance".into(), what, at: Some([r2(load.x), r2(load.y)]), layer: Some(LAYERS[k0].into()), net: Some(name.clone()), reference: Some(load.reference.clone()),+                    fix: format!("Add a {} {} {} from {} to {} within 1 mm of {}: the worst peak drops to {:.2}× the target{}.", fx["value"].as_str().unwrap_or(""), fx["package"].as_str().unwrap_or(""), fx["type"].as_str().unwrap_or(""), name, gnd, load_name, fx["ratioAfter"].as_f64().unwrap_or(0.0), if ok { ", under it" } else { "" }),+                    action: Some(json!({"type": "add-part", "what": "capacitor", "value": fx["value"], "package": fx["package"], "dielectric": fx["type"], "between": [name, gnd], "nearPin": load_name, "maxDistMm": 1.0, "why": "PDN impedance", "ratioAfter": fx["ratioAfter"]})) });+            }+            if !fixes.is_empty() && cur_r > 1.0 {+                issues.push(Issue { severity: sev.into(), kind: "pdn-impedance".into(), what: format!("{}: still {:.1}× the target after {} added capacitor(s): the copper's own inductance sets the floor", name, cur_r, fixes.len()), at: Some([r2(load.x), r2(load.y)]), layer: Some(LAYERS[k0].into()), net: Some(name.clone()), reference: Some(load.reference.clone()),+                    fix: format!("Pour {} as a plane right over {} on the next layer (a thinner dielectric lowers the inductance in proportion), or relax the target for {} (spec pdn.{}).", name, gnd, name, name),+                    action: Some(json!({"type": "pour", "net": name, "over": gnd, "why": "PDN impedance floor: mounting inductance", "ratioAfterParts": sig(cur_r)})) });+            }+        }+        // Middlebrook: a converter's input network against its negative input resistance+        let mut mb = Value::Null;+        if is_in {+            let (vin, vout, io) = (conv["vin"].as_f64().unwrap_or(v), conv["vout"].as_f64().unwrap_or(0.0), conv["iout"].as_f64().unwrap_or(0.0));+            let p = vout * io / 0.9;+            if p > 0.0 {+                let rneg = vin * vin / p; let fsw = conv["fswHz"].as_f64().unwrap_or(500e3);+                // the negative resistance holds only inside the converter's loop bandwidth: up to fsw at most+                let (mi, mz) = z0.iter().enumerate().filter(|(i, _)| fs[*i] <= fsw).fold((0, 0.0), |a, (i, z)| if *z > a.1 { (i, *z) } else { a });+                let margin = 20.0 * (rneg / mz).log10();+                mb = json!({"negInputOhm": sig(rneg), "peakOhm": sig(mz), "atHz": sig(fs[mi]), "marginDb": r2(margin), "ok": margin >= 10.0});+                if margin < 10.0 {+                    let cin: f64 = bs.iter().filter(|x| x.kind == "capacitor").map(|x| x.c).sum(); let lsrc = bs.first().map(|x| x.l).unwrap_or(0.7e-6);+                    let cd = (4.0 * cin).max(10e-6); let rd = (lsrc / cin.max(1e-9)).sqrt();+                    issues.push(Issue { severity: if margin < 0.0 { "high".into() } else { "medium".into() }, kind: "input-filter-stability".into(), what: format!("{}: the input network peaks at {} near {}, only {:.0} dB under the converter's negative input resistance ({}): the input can ring with the regulator's loop", name, fmt_ohm(mz), fmt_hz(fs[mi]), margin, fmt_ohm(rneg)), at: Some([r2(load.x), r2(load.y)]), layer: Some(LAYERS[k0].into()), net: Some(name.clone()), reference: Some(load.reference.clone()),+                        fix: format!("Add a damping bulk capacitor on {}: at least {} with about {} of ESR (an electrolytic or a ceramic plus a series resistor), near {}.", name, fmt_c(cd), fmt_ohm(rd), load_name),+                        action: Some(json!({"type": "add-part", "what": "capacitor", "value": fmt_c(cd), "dielectric": "electrolytic", "esrOhm": sig(rd), "between": [name, gnd], "nearPin": load_name, "maxDistMm": 10.0, "why": "input filter damping (Middlebrook)"})) });+                }+            }+        }+        // the ngspice cross-check of the same branches+        let mut spice = Value::Null;+        if let Some(dir) = out_dir {+            let net_txt = netlist(&name, &load_name, &bs);+            let file = dir.join(format!("pdn-{}.cir", name.replace(|c: char| !c.is_ascii_alphanumeric(), "_")));+            if std::fs::write(&file, &net_txt).is_ok() { spice = run_spice(&file, &fs, &z0); spice["netlist"] = json!(file.file_name().map(|x| x.to_string_lossy().to_string())); }+        }+        let br: Vec<Value> = bs.iter().map(|x| json!({"name": x.name, "kind": x.kind, "at": x.at, "r": x.r, "l": x.l, "lp": x.lp, "rp": x.rp, "c": x.c, "info": x.extra})).collect();+        let added: Vec<Value> = cur.iter().skip(bs.len()).map(|x| json!({"name": x.name, "kind": x.kind, "at": x.at, "r": x.r, "l": x.l, "lp": 0.0, "rp": 0.0, "c": x.c, "info": x.extra})).collect();+        rails.push(json!({"net": name, "railV": v, "load": load_name, "loadAt": [r2(load.x), r2(load.y)], "targetOhm": sig(zt), "stepA": sig(step), "tolPct": tol, "bandHz": [flo, sig(fhi)],+            "worst": {"hz": sig(fs[wi]), "ohm": sig(z0[wi]), "ratio": sig(wr), "inductive": bl, "capacitive": bc}, "traceWidthMm": wmm, "nHPerMm": sig(lpm * 1e9),+            "branches": br, "added": added, "fixes": fixes, "zOhm": z0.iter().map(|x| sig(*x)).collect::<Vec<_>>(), "zAfterOhm": if fixes.is_empty() { Value::Null } else { json!(zf.iter().map(|x| sig(*x)).collect::<Vec<_>>()) }, "middlebrook": mb, "spice": spice}));+    }+    json!({"fHz": fs.iter().map(|x| sig(*x)).collect::<Vec<_>>(), "rails": rails, "model": "each branch R + L + (Lp ∥ Rp) + C in parallel at the load pin; nominal capacitor values (no DC-bias derating); ESR by type; mounting inductance from a microstrip over the plane"})+}++/// The same branches as an ngspice deck: a 1 A AC current into the rail, so |V| is |Z|.+pub fn netlist(net: &str, load: &str, bs: &[Branch]) -> String {+    let mut s = format!("* adom-fields PDN: {} seen from {}\n* each branch R, L, (Lp || Rp), C to ground; 1 A AC in, so V(rail) is Z\nIin 0 rail AC 1\n", net, load);+    for (k, b) in bs.iter().enumerate() {+        let mut node = "rail".to_string(); let mut m = 0; let mut nx = |s: &mut String, kind: &str, val: f64| -> () { let next = format!("b{}_{}", k, m); m += 1; s.push_str(&format!("{}{}_{} {} {} {:e}\n", kind, k, m, node, next, val)); node = next; };+        s.push_str(&format!("* {} ({})\n", b.name, b.kind));+        nx(&mut s, "R", b.r.max(1e-6)); if b.l > 0.0 { nx(&mut s, "L", b.l); }+        if b.lp > 0.0 { let next = format!("b{}_p", k); s.push_str(&format!("Lp{} {} {} {:e}\n", k, node, next, b.lp)); if b.rp > 0.0 { s.push_str(&format!("Rp{} {} {} {:e}\n", k, node, next, b.rp)); } node = next; }+        if b.c > 0.0 { s.push_str(&format!("C{} {} 0 {:e}\n", k, node, b.c)); } else { s.push_str(&format!("Rg{} {} 0 1e-6\n", k, node)); }+    }+    s.push_str(".ac dec 40 1k 1g\n.end\n");+    s+}++fn run_spice(file: &std::path::Path, fs: &[f64], z: &[f64]) -> Value {+    let out = file.with_extension("ac.txt");+    let ctl = file.with_extension("ctl.cir");+    let deck = std::fs::read_to_string(file).unwrap_or_default().replace(".end\n", &format!(".control\nset wr_singlescale\nrun\nwrdata {} vm(rail)\n.endc\n.end\n", out.display()));+    if std::fs::write(&ctl, deck).is_err() { return json!({"ran": false}); }+    let r = std::process::Command::new("timeout").args(["30", "ngspice", "-b"]).arg(&ctl).output();+    let _ = std::fs::remove_file(&ctl);+    let Ok(r) = r else { return json!({"ran": false, "why": "ngspice not installed"}) };+    if !r.status.success() { return json!({"ran": false, "why": "ngspice failed"}); }+    let txt = std::fs::read_to_string(&out).unwrap_or_default(); let _ = std::fs::remove_file(&out);+    let pts: Vec<(f64, f64)> = txt.lines().filter_map(|l| { let v: Vec<f64> = l.split_whitespace().filter_map(|x| x.parse().ok()).collect(); if v.len() >= 2 { Some((v[0], v[1])) } else { None } }).collect();+    if pts.is_empty() { return json!({"ran": false, "why": "no ngspice output"}); }+    let mut err: f64 = 0.0; let mut cmp = 0;+    for (i, fq) in fs.iter().enumerate() { if let Some(p) = pts.iter().find(|p| (p.0 / fq - 1.0).abs() < 1e-3) { err = err.max((p.1 / z[i] - 1.0).abs()); cmp += 1; } }+    json!({"ran": true, "points": cmp, "maxErrPct": sig(err * 100.0)})+}++#[cfg(test)] mod tests {+    use super::*;+    #[test] fn rlc_series_resonance() {+        // a lone 100 nF with 1 nH and 10 mΩ: |Z| is the ESR at its SRF, 15.9 MHz+        let b = vec![Branch { name: "c".into(), kind: "capacitor", r: 0.01, l: 1e-9, lp: 0.0, rp: 0.0, c: 100e-9, at: None, extra: Value::Null }];+        let f0 = 1.0 / (2.0 * PI * (1e-9f64 * 100e-9).sqrt());+        assert!((zrail(&b, f0).abs() - 0.01).abs() < 1e-6);+        assert!((zrail(&b, 1e3).abs() - 1.0 / (2.0 * PI * 1e3 * 100e-9)).abs() / 1591.5 < 1e-3);+    }+    #[test] fn microstrip() { let l = l_per_mm(0.8, 1.465) * 1e9; assert!(l > 0.5 && l < 0.9, "{l}"); }+}

@@ -0,0 +1,189 @@+// Adom Fields: power delivery. Each rail's impedance seen from its load pin, from the solve's own review+// (fields.json review.pdn: the branches, |Z(f)|, the target, the fixes), drawn on the board while the+// frequency sweeps from 1 kHz to 1 GHz:+//  - every branch (the regulator or the cable, each capacitor, the plane) stands a column at its place, its+//    height its share of the load's current at this frequency: the bulk capacitors carry the low end, the+//    small ceramics the high end, the source only the slow part. At an anti-resonance two branches swap+//    current with each other and their columns overshoot 100 %: the rail rings;+//  - arcs carry each branch's share to the load pin;+//  - at the load pin, the rail's wobble for the step current stands inside a glass sleeve, the tolerance:+//    under the rim it is green, over it red. That is the impedance against its target;+//  - the rail's copper glows the same colour.+// The panel draws |Z(f)| per rail on log axes with its target and band, the fix curve dashed, and a slider.+export async function attach(ctx) {+  const { BAB, scene, V, camera, state, LAYERS, frameDt, root, flow } = ctx;+  if (!flow || !flow.data) return null;+  const { lay, real, W, H, d, meta, nets, zOf, bx, by } = flow.data;+  const pd = (state.fields.review || {}).pdn || { rails: [], fHz: [] };+  const rails = (pd.rails || []).filter(r => r.branches && r.branches.length);+  const fHz = pd.fHz || [];+  const group = new BAB.TransformNode('fields-pdn', scene); group.parent = root; group.setEnabled(false);+  const k0 = real[0];+  // ---- the model, the same as the solve: R + jωL + (jωLp ∥ Rp) + 1/(jωC) per branch, all in parallel ----+  const cx = { add: (a, b) => [a[0] + b[0], a[1] + b[1]], mul: (a, b) => [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]], inv: (a) => { const q = a[0] * a[0] + a[1] * a[1]; return [a[0] / q, -a[1] / q]; }, abs: (a) => Math.hypot(a[0], a[1]) };+  function zb(b, f) { const w = 2 * Math.PI * f; let z = [b.r, w * b.l]; if (b.lp > 0) { const zl = [0, w * b.lp]; z = cx.add(z, b.rp > 0 ? cx.mul(cx.mul(zl, [b.rp, 0]), cx.inv(cx.add(zl, [b.rp, 0]))) : zl); } if (b.c > 0) z = cx.add(z, [0, -1 / (w * b.c)]); return z; }+  function solve(bs, f) { const zs = bs.map(b => zb(b, f)); const y = zs.reduce((a, z) => cx.add(a, cx.inv(z)), [0, 0]); const zt = cx.inv(y); return { z: cx.abs(zt), share: zs.map(z => cx.abs(cx.mul(zt, cx.inv(z)))) }; }+  // ---- one set of meshes per rail ------------------------------------------------------------------------+  const colOf = (kind) => kind === 'regulator' || kind === 'cable' ? [0.35, 0.6, 1] : kind === 'plane' ? [0.75, 0.45, 1] : [0.3, 1, 0.75];+  const host = document.getElementById('labels');+  const mkTag = (cls) => { const el = document.createElement('div'); el.className = 'lbl pdn ' + (cls || ''); el.hidden = true; host.appendChild(el); return el; };+  const idOf = (name) => nets.findIndex(n => n.name === name);+  const R = rails.map((r, ri) => {+    const g = new BAB.TransformNode('pdn-rail-' + r.net, scene); g.parent = group; g.setEnabled(false);+    const [lx, ly] = r.loadAt;+    const cols = r.branches.concat(r.added || []).map((b, bi) => {+      const added = bi >= r.branches.length;+      const [x, y] = b.at || r.loadAt;+      // a branch sitting on the load pin (the plane, a new capacitor) steps aside so it does not hide it+      const off = Math.hypot(x - lx, y - ly) < 0.6 ? (b.kind === 'plane' ? [1.4, -1.1] : [-1.4, -1.1 - 0.9 * bi % 3]) : [0, 0];+      const px = x + off[0], py = y + off[1];+      const c = BAB.MeshBuilder.CreateCylinder('pdn-col-' + r.net + bi, { height: 1, diameter: b.kind === 'plane' ? 0.9 : 0.7, tessellation: 18 }, scene);+      c.rotation.x = Math.PI / 2; c.position.x = bx(px); c.position.y = by(py);+      const m = new BAB.StandardMaterial('pdn-col-m' + r.net + bi, scene); m.emissiveColor = new BAB.Color3(...colOf(b.kind)); m.disableLighting = true; m.alpha = added ? 0.45 : 0.85;+      c.material = m; c.parent = g; c.renderingGroupId = 2; c.isPickable = false;+      // the arc from the branch to the load pin+      const pts = []; const span = Math.hypot(px - lx, py - ly);+      for (let a = 0; a <= 20; a++) { const t = a / 20; pts.push(bx(px + (lx - px) * t), by(py + (ly - py) * t), 0.2 + Math.min(3, 0.35 * span) * Math.sin(Math.PI * t)); }+      let arc = null;+      if (span > 0.3) try { arc = BAB.CreateGreasedLine('pdn-arc-' + r.net + bi, { points: pts }, { color: new BAB.Color3(...colOf(b.kind)), width: 0.16, useDash: true, dashCount: 10, dashRatio: 0.45, sizeAttenuation: true }, scene); arc.parent = g; arc.renderingGroupId = 2; arc.isPickable = false; } catch (e) { void e; }+      const tag = mkTag(); const nm = b.kind === 'capacitor' ? `${added ? '<i>+</i> ' : ''}${b.name.replace(/^new /, '')}` : b.kind === 'plane' ? 'plane' : b.name;+      const val = b.kind === 'capacitor' ? (b.info.value || '').split(' ')[0] : b.kind === 'plane' ? (b.info.pF + ' pF') : '';+      return { b, c, m, arc, tag, px, py, nm, val, added, h: 0 };+    });+    // the load pin: the wobble column in its tolerance sleeve+    const sleeveH = 3.2;+    const sleeve = BAB.MeshBuilder.CreateCylinder('pdn-sleeve-' + r.net, { height: sleeveH, diameter: 1.6, tessellation: 32, cap: BAB.Mesh.NO_CAP, sideOrientation: BAB.Mesh.DOUBLESIDE }, scene);+    sleeve.rotation.x = Math.PI / 2; sleeve.position.x = bx(lx); sleeve.position.y = by(ly); sleeve.position.z = sleeveH / 2;+    const sm = new BAB.StandardMaterial('pdn-sleeve-m' + r.net, scene); sm.emissiveColor = new BAB.Color3(0.85, 0.9, 1); sm.disableLighting = true; sm.alpha = 0.16; sm.backFaceCulling = false; sleeve.material = sm; sleeve.parent = g; sleeve.renderingGroupId = 2; sleeve.isPickable = false;+    const rim = BAB.MeshBuilder.CreateTorus('pdn-rim-' + r.net, { diameter: 1.6, thickness: 0.07, tessellation: 40 }, scene); rim.rotation.x = Math.PI / 2; rim.position.x = bx(lx); rim.position.y = by(ly); rim.position.z = sleeveH;+    const rmm = new BAB.StandardMaterial('pdn-rim-m' + r.net, scene); rmm.emissiveColor = new BAB.Color3(1, 1, 1); rmm.disableLighting = true; rim.material = rmm; rim.parent = g; rim.renderingGroupId = 2; rim.isPickable = false;+    const lc = BAB.MeshBuilder.CreateCylinder('pdn-load-' + r.net, { height: 1, diameter: 1.1, tessellation: 28 }, scene); lc.rotation.x = Math.PI / 2; lc.position.x = bx(lx); lc.position.y = by(ly);+    const lm = new BAB.StandardMaterial('pdn-load-m' + r.net, scene); lm.disableLighting = true; lm.alpha = 0.92; lc.material = lm; lc.parent = g; lc.renderingGroupId = 2; lc.isPickable = false;+    const loadTag = mkTag('big');+    // the rail's copper, tinted by how it stands against the target+    const id = idOf(r.net), tex = new Uint8Array(W * H * 4);+    for (const k of real) for (let i = 0; i < W * H; i++) if (lay[k].net[i] === id) { tex[i * 4] = tex[i * 4 + 1] = tex[i * 4 + 2] = 255; tex[i * 4 + 3] = 255; }+    const rt = new BAB.RawTexture(tex, W, H, BAB.Constants.TEXTUREFORMAT_RGBA, scene, false, false, BAB.Texture.NEAREST_SAMPLINGMODE, BAB.Constants.TEXTURETYPE_UNSIGNED_BYTE);+    const p = BAB.MeshBuilder.CreatePlane('pdn-cu-' + r.net, { width: W * d, height: H * d, sideOrientation: BAB.Mesh.DOUBLESIDE }, scene);+    { const uvs = p.getVerticesData(BAB.VertexBuffer.UVKind); for (let i = 1; i < uvs.length; i += 2) uvs[i] = 1 - uvs[i]; p.setVerticesData(BAB.VertexBuffer.UVKind, uvs); }+    p.position.x = bx(meta.x0 + W * d / 2); p.position.y = by(meta.y0 + H * d / 2);+    const pm = new BAB.StandardMaterial('pdn-cu-m' + r.net, scene); pm.diffuseTexture = rt; rt.hasAlpha = true; pm.useAlphaFromDiffuseTexture = true; pm.disableLighting = true; pm.backFaceCulling = false; pm.diffuseColor = new BAB.Color3(0, 0, 0);+    p.material = pm; p.parent = g; p.renderingGroupId = 1; p.isPickable = false;+    const hue = ['#5cc8ff', '#ffb84d', '#c38bff', '#7dff9a'][ri % 4];+    return { r, g, cols, sleeveH, lc, lm, loadTag, pm, hue, all: r.branches.concat(r.added || []) };+  });+  // ---- the panel ----------------------------------------------------------------------------------------+  const fmtHz = (f) => f >= 1e9 ? (f / 1e9).toFixed(2) + ' GHz' : f >= 1e6 ? (f / 1e6).toFixed(f >= 1e8 ? 0 : 1) + ' MHz' : (f / 1e3).toFixed(f >= 1e5 ? 0 : 1) + ' kHz';+  const fmtO = (z) => z >= 1 ? z.toFixed(2) + ' Ω' : (z * 1e3).toFixed(z >= 0.01 ? 0 : 1) + ' mΩ';+  const panel = document.createElement('div'); panel.className = 'cyclemeter pdnpanel'; panel.hidden = true; document.querySelector('.stage').appendChild(panel);+  const sel = { i: rails.length ? rails.reduce((b, r, i) => r.worst.ratio > rails[b].worst.ratio ? i : b, 0) : 0, sweep: true, lf: 3, picked: false };+  if (!rails.length) panel.innerHTML = `<div class="ch">Power delivery</div><div class="body"><div class="row">No rail with a load pin and capacitors to check.</div></div>`;+  else {+    panel.innerHTML = `<div class="ch" title="Click to fold">Power delivery</div><div class="body">+      ${rails.map((r, i) => `<div class="row rail" data-i="${i}" style="cursor:pointer"><span class="dot" style="background:${R[i].hue}"></span>${r.net} from ${r.load}<i style="color:${r.worst.ratio > 1 ? '#ff6b5e' : '#5cf08f'}">${r.worst.ratio.toFixed(2)}× target</i></div>`).join('')}+      ${(pd.rails || []).filter(r => r.skipped).map(r => `<div class="row" title="${String(r.skipped).replace(/"/g, '&quot;')}" style="color:var(--text-2)"><span class="dot" style="background:#6e7681"></span>${r.net}<i>not checked: no known source</i></div>`).join('')}+      <canvas id="pdnChart" width="460" height="210"></canvas>+      <div class="row"><button id="pdnPlay" class="pdnbtn" title="Sweep the frequency">❚❚</button><input id="pdnF" type="range" min="3" max="9" step="0.005" value="3" style="flex:1"><i id="pdnFv">1 kHz</i></div>+      <div id="pdnNow" style="color:var(--text-2);margin-top:5px;font-family:'JetBrains Mono';font-size:11px;line-height:1.45"></div>+      <div class="row" style="color:var(--text-2)">${rails.every(r => r.spice && r.spice.ran) ? `ngspice agrees within ${Math.max(...rails.map(r => r.spice.maxErrPct)).toFixed(2)} %` : 'ngspice cross-check not run'}</div>+    </div>`;+    panel.addEventListener('click', (e) => { if (e.target.closest('.ch')) panel.classList.toggle('folded'); const row = e.target.closest('.rail'); if (row) { sel.i = +row.dataset.i; sel.picked = true; } });+    panel.querySelector('#pdnPlay').addEventListener('click', () => { sel.sweep = !sel.sweep; panel.querySelector('#pdnPlay').textContent = sel.sweep ? '❚❚' : '▶'; });+    panel.querySelector('#pdnF').addEventListener('input', (e) => { sel.lf = +e.target.value; sel.sweep = false; panel.querySelector('#pdnPlay').textContent = '▶'; });+  }+  function chart(f) {+    const cv = panel.querySelector('#pdnChart'); if (!cv) return; const g = cv.getContext('2d'), w = cv.width, h = cv.height, L = 40, B = 22, T = 8, Rr = 8;+    g.clearRect(0, 0, w, h);+    const zs = rails.flatMap(r => r.zOhm.concat([r.targetOhm])); const zlo = Math.pow(10, Math.floor(Math.log10(Math.max(1e-4, Math.min(...zs))))), zhi = Math.pow(10, Math.ceil(Math.log10(Math.max(...zs))));+    const X = (fq) => L + (Math.log10(fq) - 3) / 6 * (w - L - Rr), Y = (z) => T + (1 - (Math.log10(z) - Math.log10(zlo)) / (Math.log10(zhi) - Math.log10(zlo))) * (h - T - B);+    g.font = '10px JetBrains Mono'; g.fillStyle = '#8b949e'; g.strokeStyle = 'rgba(255,255,255,.08)'; g.lineWidth = 1;+    for (let e = 3; e <= 9; e++) { g.beginPath(); g.moveTo(X(10 ** e), T); g.lineTo(X(10 ** e), h - B); g.stroke(); g.fillText(['1k', '10k', '100k', '1M', '10M', '100M', '1G'][e - 3], X(10 ** e) - 8, h - 7); }+    for (let e = Math.log10(zlo); e <= Math.log10(zhi) + 1e-9; e++) { const z = 10 ** e; g.beginPath(); g.moveTo(L, Y(z)); g.lineTo(w - Rr, Y(z)); g.stroke(); g.fillText(z >= 1 ? z + 'Ω' : (z * 1e3) + 'm', 2, Y(z) + 3); }+    rails.forEach((r, i) => {+      const on = i === sel.i, col = R[i].hue;+      // the band where the target holds, and the target+      if (on) { g.fillStyle = 'rgba(255,255,255,.04)'; g.fillRect(X(r.bandHz[0]), T, X(r.bandHz[1]) - X(r.bandHz[0]), h - T - B); }+      g.strokeStyle = col; g.globalAlpha = on ? 0.9 : 0.35; g.setLineDash([5, 4]); g.beginPath(); g.moveTo(X(r.bandHz[0]), Y(r.targetOhm)); g.lineTo(X(r.bandHz[1]), Y(r.targetOhm)); g.stroke(); g.setLineDash([]);+      g.lineWidth = on ? 2.2 : 1.2; g.beginPath(); fHz.forEach((fq, k) => { const p = [X(fq), Y(Math.max(zlo, r.zOhm[k]))]; k ? g.lineTo(...p) : g.moveTo(...p); }); g.stroke();+      if (on && r.zAfterOhm) { g.setLineDash([2, 3]); g.strokeStyle = '#5cf08f'; g.beginPath(); fHz.forEach((fq, k) => { const p = [X(fq), Y(Math.max(zlo, r.zAfterOhm[k]))]; k ? g.lineTo(...p) : g.moveTo(...p); }); g.stroke(); g.setLineDash([]); }+      g.lineWidth = 1; g.globalAlpha = 1;+    });+    // the cursor+    const r = rails[sel.i], z = solve(R[sel.i].r.branches, f).z;+    g.strokeStyle = '#fff'; g.beginPath(); g.moveTo(X(f), T); g.lineTo(X(f), h - B); g.stroke();+    g.fillStyle = z > r.targetOhm ? '#ff6b5e' : '#5cf08f'; g.beginPath(); g.arc(X(f), Y(Math.max(zlo, z)), 4, 0, 7); g.fill();+  }+  // ---- frame ------------------------------------------------------------------------------------------+  const knob = { on: 0, to: 0, t: 0 };+  let lastChart = 0;+  scene.onBeforeRenderObservable.add(() => {+    const dt = frameDt();+    knob.on += (knob.to - knob.on) * (1 - Math.exp(-dt * 2.5)); if (Math.abs(knob.to - knob.on) < 1e-3) knob.on = knob.to;+    const live = knob.on > 0.01 && rails.length; group.setEnabled(!!live); group.position.z = zOf(k0) + 0.1;+    if (!live) { for (const x of R) { x.loadTag.hidden = true; for (const c of x.cols) c.tag.hidden = true; } return; }+    const sp = +state.view.speed || 1; knob.t += dt * sp;+    // one decade every 2.5 s, rail after rail unless one was picked+    if (sel.sweep) { sel.lf += dt * sp / 2.5; if (sel.lf > 9) { sel.lf = 3; if (!sel.picked && rails.length > 1) sel.i = (sel.i + 1) % rails.length; } const s = panel.querySelector('#pdnF'); if (s) s.value = sel.lf; }+    const f = Math.pow(10, sel.lf);+    const e = V.getEngine(), w = e.getRenderWidth(), h = e.getRenderHeight(), hostEl = document.getElementById('host'), wm = group.getWorldMatrix();+    const place = (el, x, y, z) => { const p = BAB.Vector3.Project(BAB.Vector3.TransformCoordinates(new BAB.Vector3(bx(x), by(y), z), wm), BAB.Matrix.Identity(), scene.getTransformMatrix(), camera.viewport.toGlobal(w, h)); el.hidden = p.z > 1 || p.z < 0; el.style.left = (p.x / (w / hostEl.clientWidth)) + 'px'; el.style.top = (p.y / (h / hostEl.clientHeight)) + 'px'; };+    R.forEach((x, i) => {+      const on = i === sel.i; x.g.setEnabled(on);+      if (!on) { x.loadTag.hidden = true; for (const c of x.cols) c.tag.hidden = true; return; }+      // with the fixes added only when they exist; the columns of new parts stay ghosted+      const s = solve(x.all, f), base = solve(x.r.branches, f), ratio = base.z / x.r.targetOhm;+      x.cols.forEach((c, bi) => {+        const share = c.added ? 0 : base.share[bi]; const hh = Math.min(9, 0.15 + 3.2 * share);+        c.h += (hh - c.h) * (1 - Math.exp(-dt * 10));+        c.c.scaling.y = c.h; c.c.position.z = c.h / 2; c.m.alpha = c.added ? 0.25 : (0.35 + 0.6 * Math.min(1, share)) * knob.on;+        if (c.arc) { c.arc.visibility = c.added ? 0 : Math.min(1, 0.1 + share) * knob.on; if (c.arc.greasedLineMaterial) c.arc.greasedLineMaterial.dashOffset = -knob.t * (0.2 + 1.6 * Math.min(1.5, share)); }+        c.tag.innerHTML = `<b>${c.nm}</b> ${c.val} <span class="${share > 1.05 ? 'v' : 'g'}">${c.added ? 'fix' : (share * 100).toFixed(0) + ' %'}</span>`;+        place(c.tag, c.px, c.py, c.h + 0.5); if (!c.added && share < 0.03) c.tag.hidden = true;+      });+      // the wobble in its sleeve: under the rim green, over it red, bobbing with the frequency (slowed)+      const lh = Math.min(x.sleeveH * 3, x.sleeveH * ratio) * (0.88 + 0.12 * Math.sin(knob.t * 6));+      x.lc.scaling.y = Math.max(0.05, lh); x.lc.position.z = Math.max(0.05, lh) / 2;+      // the target holds only inside the rail's band: outside it the column turns a neutral steel blue+      const inBand = f >= x.r.bandHz[0] * 0.999 && f <= x.r.bandHz[1] * 1.001;+      const over = inBand && ratio > 1, t = Math.min(1, ratio);+      x.lm.emissiveColor = !inBand ? new BAB.Color3(0.45, 0.55, 0.7) : over ? new BAB.Color3(1, 0.3, 0.25) : new BAB.Color3(0.25 + 0.6 * t, 1 - 0.2 * t, 0.45 - 0.3 * t);+      x.pm.emissiveColor = x.lm.emissiveColor; x.pm.alpha = knob.on * (0.25 + 0.35 * Math.min(1.5, ratio) / 1.5);+      x.loadTag.innerHTML = `<b>${x.r.net}</b> at ${x.r.load} · ${fmtHz(f)} ${inBand ? `<span class="${over ? 'v' : 'g'}">${fmtO(base.z)} · ${ratio.toFixed(2)}×</span>` : `${fmtO(base.z)} · outside its band`}${x.r.zAfterOhm ? ` <span class="g">→ ${(s.z / x.r.targetOhm).toFixed(2)}× fixed</span>` : ''}`;+      place(x.loadTag, x.r.loadAt[0], x.r.loadAt[1], Math.max(x.sleeveH, lh) + 1.0);+      // tags over clustered parts would stack: push each one below the one it collides with+      const vis = [x.loadTag, ...x.cols.map(c => c.tag)].filter(el => !el.hidden).map(el => ({ el, x: parseFloat(el.style.left), y: parseFloat(el.style.top), w: el.offsetWidth, h: el.offsetHeight })).sort((a, b) => a.y - b.y);+      for (let a = 0; a < vis.length; a++) for (let b = 0; b < a; b++) { const A = vis[a], B = vis[b]; if (Math.abs(A.x - B.x) < (A.w + B.w) / 2 && A.y < B.y + B.h + 2) { A.y = B.y + B.h + 2; A.el.style.top = A.y + 'px'; } }+      if (performance.now() - lastChart > 90) {+        lastChart = performance.now(); chart(f);+        const fv = panel.querySelector('#pdnFv'); if (fv) fv.textContent = fmtHz(f);+        const top = x.cols.map((c, bi) => ({ c, s: c.added ? 0 : base.share[bi] })).sort((a, b) => b.s - a.s)[0];+        const now = panel.querySelector('#pdnNow'); if (now && top) now.innerHTML = `${fmtHz(f)}: ${fmtO(base.z)} ${inBand ? 'against ' + fmtO(x.r.targetOhm) : '(outside the band the target covers)'}; <b style="color:var(--text)">${top.c.nm}</b> carries ${(top.s * 100).toFixed(0)} %${top.s > 1.05 ? ' (ringing)' : ''}`;+      }+    });+  });+  function apply(view) {+    knob.to = view.quantity === 'pdn' ? 1 : 0; panel.hidden = view.quantity !== 'pdn';+    if (view.quantity !== 'pdn') return;+    if (view.net) { const i = rails.findIndex(r => r.net === view.net); if (i >= 0) { sel.i = i; sel.picked = true; } }+    for (const Lname of LAYERS) { const m = ctx.layerMeshes[Lname]; if (m && m.material) m.material.alpha = Lname === 'F.Cu' ? 0.3 : 0; }+    const leg = document.getElementById('legend'); if (leg) leg.hidden = true;+  }+  function describe() {+    return ['<b>Power delivery</b>: each rail\'s impedance from its load pin, the frequency sweeping 1 kHz to 1 GHz',+      '<b>Columns</b> = each branch\'s share of the load\'s current at this frequency: <span style="color:#5cf08f">green</span> capacitors, <span style="color:#5a9aff">blue</span> the regulator or the supply cable, <span style="color:#c38bff">violet</span> the plane',+      'Over 100 % = two branches ringing against each other (an anti-resonance)',+      '<b>The glass sleeve</b> at the load pin = the target impedance (the rail\'s tolerance for its step current); the column inside is |Z|, green under the rim, red over',+      'A peak over the target is in the fix plan with the capacitor that brings it under; ngspice runs the same circuit'];+  }+  function narration() {+    if (!rails.length) return 'This is the Power view, but this board has no rail with a load pin and capacitors to check.';+    const say = (z) => z >= 1 ? `${z.toFixed(1)} ohms` : `${Math.round(z * 1000)} milliohms`;+    const hz = (f) => f >= 1e6 ? `${(f / 1e6).toFixed(f >= 1e7 ? 0 : 1)} megahertz` : `${Math.round(f / 1e3)} kilohertz`;+    const parts = rails.map(r => `${r.net}, seen from ${r.load.replace('.', ' pin ')}, peaks at ${say(r.worst.ohm)} near ${hz(r.worst.hz)}, ${r.worst.ratio > 1 ? `${r.worst.ratio.toFixed(1)} times its target, so the fix plan adds ${r.fixes.map(x => x.value.replace('uF', ' microfarad').replace('nF', ' nanofarad')).join(' and ')} right at that pin` : `${Math.round(r.worst.ratio * 100)} percent of its target of ${say(r.targetOhm)}`}${r.worst.inductive && r.worst.capacitive ? `; that peak is ${who(r.worst.inductive, r, r.worst.capacitive)}` : ''}.`);+    const mb = rails.find(r => r.middlebrook);+    function who(name, r, cap) { const b = r.branches.find(x => x.name === name); if (b && b.kind === 'cable') return `the supply leads into ${name.replace(' cable', '')} ringing against ${cap}`; if (b && b.kind === 'regulator') return `where the regulator's control loop hands the rail over to ${cap}`; return `${name} ringing against ${cap}`; }+    return `This is the Power view: how stiff each rail is, from slow changes to fast ones. A chip pulls current in steps, and the rail's impedance decides how far its voltage wobbles. Watch the frequency sweep: at the low end the regulator or the supply holds the rail, then the big capacitors take over, then the small ones nearest the pin. Each column is one part's share of the current. When a column shoots past a hundred percent, two parts are passing current back and forth: the rail is ringing. The glass sleeve at the load pin is the target; the column inside it is the impedance, green under the rim, red over it. ${parts.join(' ')}${mb && mb.middlebrook ? (mb.middlebrook.ok ? ` The input also passes the stability check: its network stays ${Math.round(mb.middlebrook.marginDb)} decibels under the converter's negative input resistance, so the converter cannot ring with its own input.` : ` The input fails the stability check: its network comes within ${Math.round(mb.middlebrook.marginDb)} decibels of the converter's negative input resistance, so the fix plan adds a damping capacitor.`) : ''} ngspice runs the same circuit as a cross-check, and every finding goes into the fix plan for the AI.`;+  }+  console.log(`pdn: ${rails.map(r => `${r.net} ${r.worst.ratio}× at ${r.worst.hz} Hz`).join(', ')}`);+  return { apply, describe, narration };+}