Adom Fields

@@ -1,7 +1,8 @@ //! The board as the solver needs it: outline, filled copper per net and layer, tracks, pads, vias. use crate::sexp::{parse, Sx}; -pub const LAYERS: [&str; 4] = ["F.Cu", "In1.Cu", "In2.Cu", "B.Cu"];+/// the copper slots, top to bottom: boards up to six layers (a two- or four-layer board leaves the inner slots it lacks empty)+pub const LAYERS: [&str; 6] = ["F.Cu", "In1.Cu", "In2.Cu", "In3.Cu", "In4.Cu", "B.Cu"];  #[derive(Debug, Clone)] pub struct Poly { pub net: String, pub layer: String, pub pts: Vec<(f64, f64)> }@@ -41,6 +42,13 @@ pub struct Board {     /// reads the technology from them: an electrolytic's Value is just "47uF 35V")     pub mpns: std::collections::BTreeMap<String, String>,     pub footprints: std::collections::BTreeMap<String, String>,+    /// the copper layers the board declares (a two-layer board has no In1/In2: pads never spread onto them)+    pub copper: Vec<String>,+    /// the dielectric between each pair of consecutive real copper layers, top down, from the board's own stackup+    /// (else its overall thickness), when the file carries one+    pub stack_mm: Option<Vec<f64>>,+    /// εr of each of those gaps (thickness-weighted over its dielectric sublayers), when the stackup says+    pub stack_er: Option<Vec<f64>>, }  fn rot(x: f64, y: f64, deg: f64) -> (f64, f64) { let a = deg.to_radians(); (x * a.cos() - y * a.sin(), x * a.sin() + y * a.cos()) }@@ -48,10 +56,30 @@ fn rot(x: f64, y: f64, deg: f64) -> (f64, f64) { let a = deg.to_radians(); (x * impl Board {     pub fn load(path: &str) -> Result<Board, String> {         let text = std::fs::read_to_string(path).map_err(|e| format!("{path}: {e}"))?;-        if crate::eagle::is_eagle(&text) { let mut b = crate::eagle::load(&text)?; b.source = "fusion".into(); return Ok(b); }+        if crate::eagle::is_eagle(&text) { let mut b = crate::eagle::load(&text)?; b.source = "fusion".into(); b.copper = LAYERS.iter().filter(|l| b.layer_names.iter().any(|n| n == *l)).map(|l| l.to_string()).collect(); return Ok(b); }         let root = parse(&text);         let mut b = Board::default(); b.source = "kicad".into();         b.layer_names = root.kid("layers").map(|l| l.list().iter().skip(1).filter_map(|x| x.atom(1).map(str::to_string)).collect()).unwrap_or_default();+        b.copper = LAYERS.iter().filter(|l| b.layer_names.iter().any(|n| n == *l)).map(|l| l.to_string()).collect();+        // the saved stackup: the dielectric thickness between each pair of consecutive copper layers+        if let Some(st) = root.kid("setup").and_then(|s| s.kid("stackup")) {+            let mut gaps: Vec<f64> = Vec::new(); let mut ers: Vec<f64> = Vec::new(); let (mut acc, mut acc_er) = (0.0, 0.0); let mut seen_cu = false;+            for l in st.kids("layer") {+                let name = l.atom(1).unwrap_or("");+                let t = l.kid("thickness").and_then(|x| x.num(1)).unwrap_or(0.0);+                if name.ends_with(".Cu") { if seen_cu { gaps.push(acc); ers.push(if acc > 0.0 && acc_er > 0.0 { acc_er / acc } else { 0.0 }); } acc = 0.0; acc_er = 0.0; seen_cu = true; }+                else if seen_cu && name.starts_with("dielectric") { acc += t; if let Some(e) = l.kid("epsilon_r").and_then(|x| x.num(1)) { acc_er += e * t; } }+            }+            if ers.len() == gaps.len() && !ers.is_empty() && ers.iter().all(|e| *e >= 1.0) { b.stack_er = Some(ers.clone()); }+            if !gaps.is_empty() && gaps.iter().all(|g| *g > 0.0) { b.stack_mm = Some(gaps); }+        }+        // no stackup saved: the board's overall thickness, less its copper, split the usual way+        if b.stack_mm.is_none() {+            if let Some(t) = root.kid("general").and_then(|g| g.kid("thickness")).and_then(|t| t.num(1)) {+                let ncu = if b.copper.is_empty() { 4 } else { b.copper.len() }; let d = t - 0.035 * ncu as f64;+                if d > 0.2 { b.stack_mm = Some(match ncu { 2 => vec![d], 4 => vec![0.2, (d - 0.4).max(0.1), 0.2], _ => { let c = ((d - 0.4) / 3.0).max(0.05); vec![0.2, c, c, c, 0.2] } }); }+            }+        }         let net_names: std::collections::BTreeMap<String,String> = root.kids("net").iter().filter_map(|n|Some((n.atom(1)?.to_string(),n.atom(2)?.to_string()))).collect();         let net_name = |n: &Sx| { let value=n.last_atom().unwrap_or(""); net_names.get(value).cloned().unwrap_or_else(||value.to_string()) };         // outline: the Edge.Cuts graphics' bounding box@@ -102,7 +130,9 @@ impl Board {                 let kind = p.atom(2).unwrap_or("smd");                 let shape = p.atom(3).unwrap_or("rect");                 let lay: Vec<String> = p.kid("layers").map(|l| l.list().iter().skip(1).filter_map(|x| if let Sx::Atom(a) = x { Some(a.clone()) } else { None }).collect()).unwrap_or_default();-                let on: Vec<String> = if kind == "thru_hole" { LAYERS.iter().map(|s| s.to_string()).collect() } else { LAYERS.iter().filter(|l| lay.iter().any(|x| x == *l || x == "*.Cu")).map(|s| s.to_string()).collect() };+                // only onto copper the board has: a plated pad on a two-layer board is on F.Cu and B.Cu, never In1/In2+                let real = |l: &&&str| b.copper.is_empty() || b.copper.iter().any(|c| c == **l);+                let on: Vec<String> = if kind == "thru_hole" { LAYERS.iter().filter(real).map(|s| s.to_string()).collect() } else { LAYERS.iter().filter(real).filter(|l| lay.iter().any(|x| x == *l || x == "*.Cu")).map(|s| s.to_string()).collect() };                 let mut area = sw * sh;                 for l in &on {                     let mut shapes: Vec<Vec<(f64, f64)>> = Vec::new();@@ -143,3 +173,56 @@ fn stadium_poly(x: f64, y: f64, w: f64, h: f64, deg: f64) -> Vec<(f64, f64)> {     let ang = if w >= h { deg } else { deg + 90.0 };     pts.into_iter().map(|(px, py)| { let (qx, qy) = rot(px, -py, ang); (x + qx, y - qy) }).collect() }++#[cfg(test)] mod layer_tests {+    use super::*;+    // issue 10 (senthilkumaranms): a plated pad on a two-layer board is on F.Cu and B.Cu only+    fn fixture(layers: &str, stackup: &str) -> Board {+        let txt = format!(r#"(kicad_pcb (version 20260206) (generator pcbnew)+ (general (thickness 1.6)) (layers {layers}) {stackup}+ (gr_rect (start 0 0) (end 10 10) (stroke (width 0.05) (type default)) (fill none) (layer "Edge.Cuts"))+ (footprint "Connector" (layer "F.Cu") (at 2 5)+  (property "Reference" "J1" (at 0 0) (layer "F.SilkS"))+  (pad "1" thru_hole circle (at 0 0) (size 2 2) (drill 0.8) (layers "*.Cu" "*.Mask") (net "3V3")))+ (segment (start 2 5) (end 8 5) (width 1) (layer "F.Cu") (net "3V3")))"#);+        let p = std::env::temp_dir().join(format!("adom-fields-layers-{}.kicad_pcb", layers.len() + stackup.len()));+        std::fs::write(&p, txt).unwrap(); let b = Board::load(p.to_str().unwrap()).unwrap(); let _ = std::fs::remove_file(&p); b+    }+    #[test] fn two_layer_pads_stay_on_real_copper() {+        let b = fixture(r#"(0 "F.Cu" signal) (2 "B.Cu" signal)"#, "");+        assert_eq!(b.pads[0].layers, vec!["F.Cu".to_string(), "B.Cu".to_string()]);+        let s = b.stack_mm.unwrap(); assert_eq!(s.len(), 1); assert!((s[0] - 1.53).abs() < 1e-6);+    }+    #[test] fn four_layer_pads_and_saved_stackup() {+        let st = r#"(setup (stackup (layer "F.Cu" (type "copper") (thickness 0.035)) (layer "dielectric 1" (type "prepreg") (thickness 0.21)) (layer "In1.Cu" (type "copper") (thickness 0.0152)) (layer "dielectric 2" (type "core") (thickness 1.065)) (layer "In2.Cu" (type "copper") (thickness 0.0152)) (layer "dielectric 3" (type "prepreg") (thickness 0.21)) (layer "B.Cu" (type "copper") (thickness 0.035))))"#;+        let b = fixture(r#"(0 "F.Cu" signal) (4 "In1.Cu" signal) (6 "In2.Cu" signal) (2 "B.Cu" signal)"#, st);+        assert_eq!(b.pads[0].layers.len(), 4);+        assert_eq!(b.stack_mm, Some(vec![0.21, 1.065, 0.21]));+    }+}++/// The copper layers in physical order (F.Cu, In1.Cu .. In<n>.Cu, B.Cu, contiguous) or an error naming what is wrong.+pub fn check_copper(copper: &[String], declared: &[String]) -> Result<(), String> {+    let extra: Vec<&String> = declared.iter().filter(|n| n.ends_with(".Cu") && !LAYERS.contains(&n.as_str())).collect();+    if !extra.is_empty() { return Err(format!("this board has copper layers past six ({}): boards up to six copper layers are supported", extra.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", "))); }+    if copper.is_empty() { return Ok(()); }+    let inner: Vec<usize> = copper.iter().filter_map(|c| c.strip_prefix("In").and_then(|x| x.strip_suffix(".Cu")).and_then(|x| x.parse().ok())).collect();+    if !copper.iter().any(|c| c == "F.Cu") || !copper.iter().any(|c| c == "B.Cu") || inner.iter().enumerate().any(|(i, n)| *n != i + 1) || copper.len() % 2 != 0 { return Err(format!("the copper layers {} are not a stack this solve supports: F.Cu, In1.Cu .. In<n>.Cu in order, B.Cu, an even count", copper.join(", "))); }+    Ok(())+}++#[cfg(test)] mod stack_tests {+    use super::*;+    fn v(x: &[&str]) -> Vec<String> { x.iter().map(|s| s.to_string()).collect() }+    // issue 11: six layers in order pass, a gap or an odd count fails, more than six is named+    #[test] fn copper_stacks() {+        assert!(check_copper(&v(&["F.Cu", "In1.Cu", "In2.Cu", "In3.Cu", "In4.Cu", "B.Cu"]), &v(&["F.Cu", "B.Cu", "In1.Cu", "In2.Cu", "In3.Cu", "In4.Cu"])).is_ok());+        assert!(check_copper(&v(&["F.Cu", "In2.Cu", "B.Cu"]), &[]).is_err());+        assert!(check_copper(&v(&["F.Cu", "In1.Cu", "B.Cu"]), &[]).is_err());+        assert!(check_copper(&v(&["F.Cu", "B.Cu"]), &v(&["F.Cu", "In5.Cu", "B.Cu"])).is_err());+    }+    #[test] fn four_layer_gaps_spread_over_slots() {+        let s = crate::fields::spread(&[0.2, 1.065, 0.21], &v(&["F.Cu", "In1.Cu", "In2.Cu", "B.Cu"]));+        assert_eq!(s.len(), 5); assert!((s[0] - 0.2).abs() < 1e-12 && (s[1] - 1.065).abs() < 1e-12 && (s[2] - 0.07).abs() < 1e-12 && (s[4] - 0.07).abs() < 1e-12);+    }+}

@@ -110,22 +110,58 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va     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 gid = gnd.as_ref().and_then(|g| f.net_names.iter().position(|x| x == g)).map(|i| i as u16);     let mut refs_out = Vec::new();-    if let (Some(g), true) = (gid, real.len() >= 2) {-        let (k0, k1) = (real[0], real[1]);-        let mut per: std::collections::BTreeMap<u16, (usize, usize, f64, f64)> = Default::default();-        for i in 0..n { let id = f.net_ids[k0][i]; if id == u16::MAX || id == g { continue; } let name = &f.net_names[id as usize]; if !(f.flow.contains_key(name) || spec.switching.contains_key(name)) { continue; } let e = per.entry(id).or_default(); if f.net_ids[k1][i] == g { e.0 += 1; } else { e.1 += 1; e.2 += f.x0 + ((i % w) as f64 + 0.5) * f.d; e.3 += f.y0 + ((i / w) as f64 + 0.5) * f.d; } }-        for (id, (on, off, sx, sy)) in per {-            let name = f.net_names[id as usize].clone(); let pct = off as f64 / (on + off).max(1) as f64 * 100.0; let mm2 = off as f64 * f.d * f.d;-            let switching = spec.switching.contains_key(&name) || is_switch_name(&name);-            refs_out.push(json!({"net": name, "unreferencedPct": (pct * 10.0).round() / 10.0, "unreferencedMm2": (mm2 * 10.0).round() / 10.0}));-            if (switching && pct > 5.0) || pct > 20.0 { let at = [sx / off.max(1) as f64, sy / off.max(1) as f64]; issues.push(issue(if switching { "medium" } else { "low" }, "no-reference", format!("{}: {:.0} % of its top copper ({:.1} mm²) has no {} under it", name, pct, mm2, gnd.clone().unwrap_or_default()), Some(at), Some(&name), None, format!("Pour {} on {} under {} around ({:.1}, {:.1}), or route it over solid ground, so its return current does not detour.", gnd.clone().unwrap_or_default(), LAYERS[k1], name, at[0], at[1]), json!({"type": "pour", "net": gnd, "layer": LAYERS[k1], "under": name, "at": at}))); }+    // what each net's copper sits over (issue 9): on each layer, the nearest real copper layers; ground there is a return+    // path, a supply plane is not (the return rides it through bypass capacitors), nothing at all is a void. Every net+    // but ground and the rails is checked; switching nodes, clocks, signal pairs and sensitive nets are medium.+    if let Some(g) = gid {+        let gids: Vec<u16> = f.net_names.iter().enumerate().filter(|(_, x)| is_ground(x)).map(|(i, _)| i as u16).collect();+        let important = |name: &str| spec.switching.contains_key(name) || is_switch_name(name) || spec.clocks.contains_key(name) || spec.sensitiveNets.iter().any(|x| x == name) || spec.signals.differential_pairs.iter().any(|p| p.positive == name || p.negative == name);+        let mut per: std::collections::BTreeMap<u16, (usize, usize, usize, f64, f64, std::collections::BTreeMap<String, usize>, Vec<String>)> = Default::default();+        // a net's own pads and via rings sit in the planes' clearance holes: those cells are not its route+        let mut own: std::collections::BTreeMap<String, Vec<(f64, f64, f64)>> = Default::default();+        for p in &b.pads { own.entry(p.net.clone()).or_default().push((p.x, p.y, (p.area / std::f64::consts::PI).sqrt() + 0.35)); }+        for v in &b.vias { own.entry(v.net.clone()).or_default().push((v.x, v.y, v.size / 2.0 + 0.35)); }+        for (ri, &k) in real.iter().enumerate() {+            let nbrs: Vec<usize> = [ri.checked_sub(1), Some(ri + 1)].into_iter().flatten().filter_map(|j| real.get(j).copied()).collect();+            for i in 0..n {+                let id = f.net_ids[k][i]; if id == u16::MAX || gids.contains(&id) { continue; }+                let name = &f.net_names[id as usize]; if rail(name).is_some() && !spec.switching.contains_key(name) { continue; }+                let (cx, cy) = (f.x0 + ((i % w) as f64 + 0.5) * f.d, f.y0 + ((i / w) as f64 + 0.5) * f.d);+                if own.get(name).map_or(false, |v| v.iter().any(|(x, y, r)| (cx - x).hypot(cy - y) <= *r)) { continue; }+                let e = per.entry(id).or_insert((0, 0, 0, 0.0, 0.0, Default::default(), Vec::new()));+                let under: Vec<u16> = nbrs.iter().map(|&o| f.net_ids[o][i]).collect();+                if under.iter().any(|u| gids.contains(u)) { e.0 += 1; }+                else if let Some(sup) = under.iter().find(|u| **u != u16::MAX && rail(&f.net_names[**u as usize]).is_some()) { e.1 += 1; *e.5.entry(f.net_names[*sup as usize].clone()).or_default() += 1; e.3 += f.x0 + ((i % w) as f64 + 0.5) * f.d; e.4 += f.y0 + ((i / w) as f64 + 0.5) * f.d; if !e.6.contains(&LAYERS[k].to_string()) { e.6.push(LAYERS[k].to_string()); } }+                else { e.2 += 1; e.3 += f.x0 + ((i % w) as f64 + 0.5) * f.d; e.4 += f.y0 + ((i / w) as f64 + 0.5) * f.d; if !e.6.contains(&LAYERS[k].to_string()) { e.6.push(LAYERS[k].to_string()); } }+            }+        }+        let _ = g;+        for (id, (on, sup, void, sx, sy, sups, lays)) in per {+            let name = f.net_names[id as usize].clone(); let tot = (on + sup + void).max(1); let bad = sup + void;+            let mm = bad as f64 * f.d;   // cells along a trace about one cell wide: millimetres of route+            let pct = bad as f64 / tot as f64 * 100.0;+            let sup_name = sups.iter().max_by_key(|x| x.1).map(|x| x.0.clone());+            refs_out.push(json!({"net": name, "unreferencedPct": (pct * 10.0).round() / 10.0, "unreferencedMm2": ((bad as f64 * f.d * f.d) * 10.0).round() / 10.0, "overSupplyMm": (sup as f64 * f.d * 10.0).round() / 10.0, "overVoidMm": (void as f64 * f.d * 10.0).round() / 10.0, "supplyPlane": sup_name, "layers": lays}));+            let imp = important(&name);+            // a poured net is copper area, not a route: say so, and flag it only when it matters (a switching or signal net)+            let poured = b.polys.iter().any(|p| p.net == name) || b.pours.iter().any(|p| p.net == name);+            let size = if poured { format!("{:.0} mm² of its copper", bad as f64 * f.d * f.d) } else { format!("about {:.0} mm of it", mm) };+            if (imp && (mm > 2.0 || poured)) || (!poured && mm > 15.0) {+                let at = [sx / bad.max(1) as f64, sy / bad.max(1) as f64];+                let what = match (&sup_name, sup >= void) { (Some(sp), true) => format!("{}: {} runs over the {} plane, not ground ({}), so its return current rides {} through the bypass capacitors", name, size, sp, lays.join(", "), sp), _ => format!("{}: {} runs over no plane at all ({}): its return current has no path under it", name, size, lays.join(", ")) };+                issues.push(issue(if imp { "medium" } else { "low" }, "no-reference", what, Some(at), Some(&name), None, format!("Route {} over solid ground: move it to the layer next to the ground plane, or pour ground under it; where it must change layers, put a ground via within 1 mm of the signal via.", name), json!({"type": "reroute", "net": name, "over": f.net_names.iter().find(|x| is_ground(x)), "why": "return path", "at": [r2(at[0]), r2(at[1])], "overSupplyMm": r2(sup as f64 * f.d), "overVoidMm": r2(void as f64 * f.d)})));+            }         }+        refs_out.sort_by(|a, z| z["unreferencedMm2"].as_f64().partial_cmp(&a["unreferencedMm2"].as_f64()).unwrap());     }     out["reference"] = json!(refs_out);     // ---- ground: offset, islands, stitching, connectors to the outside -----------------------------------     if let (Some(gname), Some(g)) = (gnd.clone(), gid) {         let mut gout = json!({"net": gname});-        if let Some(nf) = f.flow.get(&gname) {+        // a ground solve that did not converge has no offset worth reporting (issue 9)+        let g_ok = f.nets.iter().find(|x| x.net == gname).map_or(true, |x| x.converged);+        if !g_ok { gout["offsetNote"] = json!("the ground current solve did not converge: no offset reported"); }+        if let Some(nf) = f.flow.get(&gname).filter(|_| g_ok) {             let (mut lo, mut hi, mut at_hi) = (f64::MAX, f64::MIN, [0.0, 0.0]);             for k in 0..LAYERS.len() { for i in 0..n { if nf.on[k].v[i] == 0.0 { continue; } let v = (nf.v_ext - nf.v[k].v[i] as f64).max(f64::MIN); if v < lo { lo = v; } if v > hi { hi = v; at_hi = [f.x0 + ((i % w) as f64 + 0.5) * f.d, f.y0 + ((i / w) as f64 + 0.5) * f.d]; } } }             let span = (hi - lo).max(0.0);@@ -134,6 +170,16 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va             if span * 1e3 > budget { issues.push(issue("medium", "ground-offset", format!("{}: {:.1} mV across the ground copper (budget {:.0} mV)", gname, span * 1e3, budget), Some(at_hi), Some(&gname), None, format!("Widen the ground path near ({:.1}, {:.1}) or add ground vias to the other layer there, so the return current has a lower-resistance way home.", at_hi[0], at_hi[1]), json!({"type": "add-vias", "net": gname, "at": at_hi, "why": "ground offset"}))); }             let ext: Vec<&crate::flow::Terminal> = { let mut v: Vec<&crate::flow::Terminal> = nf.terminals.iter().filter(|t| t.side == "ext").collect(); v.dedup_by(|a, z| a.reference == z.reference); v };             gout["toOutside"] = json!(ext.iter().map(|t| t.reference.clone()).collect::<Vec<_>>());+            // the loop that matters on a receiver: a power or data cable's ground and the antenna's (issue 9)+            {+                let conns: Vec<String> = { let mut v: Vec<String> = b.pads.iter().filter(|p| p.reference.starts_with('J') || (p.reference.starts_with('P') && !p.reference.starts_with("PS"))).map(|p| p.reference.clone()).collect(); v.sort(); v.dedup(); v };+                let ant: Vec<&String> = conns.iter().filter(|r| b.pads.iter().any(|p| p.reference == **r && spec.sensitiveNets.iter().any(|s| *s == p.net))).collect();+                for aj in ant { let ap = b.pads.iter().find(|p| p.reference == *aj).unwrap();+                    for cj in conns.iter().filter(|r| *r != aj && b.pads.iter().any(|p| p.reference == **r && rail(&p.net).map_or(false, |v| v > 0.0))) { let cp = b.pads.iter().find(|p| p.reference == *cj).unwrap(); let dist = (ap.x - cp.x).hypot(ap.y - cp.y);+                        let data = b.pads.iter().any(|p| p.reference == *cj && rail(&p.net).is_none() && !is_ground(&p.net) && !p.net.is_empty() && !p.net.starts_with("unconnected-"));+                        issues.push(issue("medium", "antenna-ground-loop", format!("{} brings a cable's ground onto the board {:.0} mm from the antenna connector {}: common-mode noise from that cable crosses the ground plane into the antenna's shield, which is part of the antenna", cj, dist, aj), Some([(ap.x + cp.x) / 2.0, (ap.y + cp.y) / 2.0]), Some(&gname), Some(cj), format!("Choke the cable at {}: a common-mode choke on its data lines{}, a ferrite on its supply, and its ground tied to the plane right at the connector; keep the antenna's ground return short and away from the {} return path.", cj, if data { "" } else { " (if it carries any)" }, cj), json!({"type": "add-part", "what": "common-mode choke and ferrite", "at": cj, "why": "cable common mode into the antenna ground", "antenna": aj, "distanceMm": r2(dist)}))); }+                }+            }             if ext.len() > 1 { let (a, z) = (ext[0], ext[ext.len() - 1]); issues.push(issue("low", "ground-loop-risk", format!("{} connectors carry {} off the board ({}): cables that meet off the board close a loop", ext.len(), gname, ext.iter().map(|t| t.reference.clone()).collect::<Vec<_>>().join(", ")), Some([(a.x + z.x) / 2.0, (a.y + z.y) / 2.0]), Some(&gname), None, "Return each cable's ground on its own connector and route paired wires together (twisted or adjacent), or tie the grounds at one point.".into(), json!({"type": "review", "what": "ground cabling", "connectors": ext.iter().map(|t| t.reference.clone()).collect::<Vec<_>>()}))); }         }         // islands: ground copper with no via or pin to the main body@@ -151,8 +197,15 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va             for (a, at) in &isl { issues.push(issue("low", "ground-island", format!("{}: a {:.1} mm² island of ground copper with no via or pin to the rest", gname, a), Some(*at), Some(&gname), None, format!("Add a ground via in the island at ({:.1}, {:.1}) to tie it to the plane, or remove it: floating copper acts as an antenna.", at[0], at[1]), json!({"type": "add-vias", "net": gname, "at": at, "count": 1, "why": "tie a floating island"}))); }         }         // the stitching fence along the board edge: lambda/20 at the highest frequency of interest-        let fmax = spec.emcFmaxHz.unwrap_or(1e9); let er = 4.3; let lambda = 299.792458 / (fmax / 1e9) / ((er + 1.0) / 2.0f64).sqrt(); let pitch = lambda / 20.0; let reach = pitch / 2.0;-        let gv: Vec<(f64, f64)> = b.vias.iter().filter(|v| v.net == gname).map(|v| (v.x, v.y)).collect();+        // the fence's top frequency: the spec's, else the board's own strongest tones (a converter's edge to 1 GHz; a+        // crystal or LC oscillator to its 5th harmonic, a logic clock to 1 GHz), else 1 GHz (issue 9)+        let fmax = spec.emcFmaxHz.unwrap_or_else(|| {+            if !spec.switching.is_empty() || spec.clocks.is_empty() { return 1e9; }+            spec.clocks.iter().map(|(net, c)| { let sine = b.pads.iter().any(|p| p.net == *net && (p.reference.starts_with('Y') || p.reference.starts_with('X'))) || !b.pads.iter().any(|p| p.net == *net && p.reference.starts_with('U')); if sine { 5.0 * c.top_hz() } else { 1e9 } }).fold(0.0, f64::max).min(1e9)+        });+        let er = crate::fields::gap_between(spec, b, 0, LAYERS.len() - 1).1; let lambda = 299.792458 / (fmax / 1e9) / ((er + 1.0) / 2.0f64).sqrt(); let pitch = lambda / 20.0; let reach = pitch / 2.0;+        // fence posts: ground vias, and plated through-hole ground pads (machine pins, mounting holes: issue 9)+        let gv: Vec<(f64, f64)> = b.vias.iter().filter(|v| v.net == gname).map(|v| (v.x, v.y)).chain(b.pads.iter().filter(|p| p.net == gname && p.layers.len() >= 2).map(|p| (p.x, p.y))).collect();         let (bw, bh) = (b.width(), b.height()); let per = 2.0 * (bw + bh); let step = 0.4; let mut s = 0.0; let mut gaps: Vec<Vec<(f64, f64)>> = Vec::new(); let mut run: Vec<(f64, f64)> = Vec::new(); let (mut cov, mut tot) = (0usize, 0usize);         while s < per { let (x, y) = if s < bw { (b.x0 + s, b.y0) } else if s < bw + bh { (b.x0 + bw, b.y0 + s - bw) } else if s < 2.0 * bw + bh { (b.x0 + bw - (s - bw - bh), b.y0 + bh) } else { (b.x0, b.y0 + bh - (s - 2.0 * bw - bh)) };             let ok = gv.iter().any(|v| (v.0 - x).hypot(v.1 - y) <= reach + 1.0); tot += 1; if ok { cov += 1; if run.len() > 1 { gaps.push(std::mem::take(&mut run)); } run.clear(); } else { run.push((x, y)); } s += step; }@@ -189,6 +242,31 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va         }     }     out["decoupling"] = json!(dec);+    // ---- discrete stage feeds (issue 9): a rail through a series resistor or inductor into a net that feeds a+    // transistor stage; its bypass capacitors to ground, the filter corner, and the caps' self-resonance+    let mut feeds = Vec::new();+    if let Some(gname) = gnd.clone() {+        let parse_ohm = |val: &str| -> Option<f64> { let u = val.to_ascii_uppercase().replace("OHM", "").replace('Ω', ""); let t = u.trim(); if let Some(i) = t.find(|c: char| c == 'K' || c == 'M' || c == 'R') { let m = match &t[i..i + 1] { "K" => 1e3, "M" => 1e6, _ => 1.0 }; format!("{}.{}", &t[..i], &t[i + 1..]).trim_end_matches('.').parse::<f64>().ok().map(|v| v * m) } else { t.parse().ok() } };+        for r in refs.iter().filter(|r| r.starts_with('R') || r.starts_with('L') || r.starts_with("FB")) {+            let ns = nets_of(r); if ns.len() != 2 { continue; }+            let (rl, feed) = match (rail(&ns[0]).filter(|v| *v > 0.0), rail(&ns[1]).filter(|v| *v > 0.0)) { (Some(_), None) => (ns[0].clone(), ns[1].clone()), (None, Some(_)) => (ns[1].clone(), ns[0].clone()), _ => continue };+            if is_ground(&feed) || feed.starts_with("unconnected-") { continue; }+            let val = b.values.get(r).cloned().unwrap_or_default();+            let ser = if r.starts_with('R') { match parse_ohm(&val) { Some(o) if o <= 470.0 => o, _ => continue } } else { 1.0 };+            // it feeds a stage: a transistor on this net, or an inductor from it to a transistor+            let stage = refs.iter().find(|q| q.starts_with('Q') && (nets_of(q).contains(&feed) || refs.iter().any(|l| l.starts_with('L') && nets_of(l).contains(&feed) && nets_of(l).iter().any(|n| nets_of(q).contains(n) && *n != feed)))).cloned();+            let Some(stage) = stage else { continue };+            let caps: Vec<(String, f64)> = refs.iter().filter(|c| c.starts_with('C') && nets_of(c).contains(&feed) && nets_of(c).contains(&gname)).filter_map(|c| b.values.get(c).and_then(|v| parse_value(v, 'F')).map(|v| (c.clone(), v))).collect();+            let ctot: f64 = caps.iter().map(|c| c.1).sum();+            let fc = if ctot > 0.0 && r.starts_with('R') { Some(1.0 / (2.0 * std::f64::consts::PI * ser * ctot)) } else { None };+            let srf: Vec<Value> = caps.iter().map(|(c, v)| { let span = { let pv = pads_of(c, &feed); let pg = pads_of(c, &gname); match (pv.first(), pg.first()) { (Some(a), Some(z)) => (a.x - z.x).hypot(a.y - z.y), _ => 1.0 } }; let esl = (0.15 + 0.3 * span + 0.5) * 1e-9; json!({"cap": c, "uF": (v * 1e9).round() / 1e3, "srfMHz": ((1.0 / (2.0 * std::f64::consts::PI * (v * esl).sqrt())) / 1e4).round() / 100.0}) }).collect();+            let at = pads_of(r, &feed).first().map(|p| [r2(p.x), r2(p.y)]);+            feeds.push(json!({"feed": feed, "rail": rl, "series": r, "seriesValue": val, "stage": stage, "caps": srf, "cornerHz": fc.map(|x| x.round())}));+            if caps.is_empty() { issues.push(issue("medium", "stage-feed-unbypassed", format!("{} feeds {} from {} through {} ({}) with no capacitor to {} on it: the stage's signal rides the rail into every other stage on {}", feed, stage, rl, r, val, gname, rl), at, Some(&feed), Some(r), format!("Add a 100 nF plus a small high-frequency ceramic (1 nF for an IF stage, 100 pF for a VHF stage) from {} to {} at {}'s end, each with its own ground via.", feed, gname, stage), json!({"type": "add-part", "what": "capacitor", "value": "100nF", "also": "1nF or 100pF for the stage frequency", "between": [feed, gname], "near": stage, "maxDistMm": 2.0, "why": "stage feed bypass"}))); }+        }+    }+    feeds.sort_by(|a, z| a["rail"].as_str().cmp(&z["rail"].as_str()));+    out["stageFeeds"] = json!(feeds);     // ---- ESD: each connector pin to the outside, protected or not ----------------------------------------     let mut esd = Vec::new();     if let Some(gname) = gnd.clone() {@@ -201,7 +279,8 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va                 let prot = protector(&p.net);                 let sig = rail(&p.net).is_none();                 esd.push(json!({"connector": jref, "pin": p.pad, "net": p.net, "at": [r2(p.x), r2(p.y)], "protectedBy": prot, "signal": sig}));-                if prot.is_none() { issues.push(issue("low", "esd-unprotected", format!("{} pin {} ({}): no protection diode from {} to {}", jref, p.pad, p.net, p.net, gname), Some([p.x, p.y]), Some(&p.net), Some(jref), format!("If {} faces the outside world, add a TVS{} from {} to {} within 3 mm of the pin, before any chip.", jref, if sig { " (low capacitance, for a signal)" } else { " rated above the rail" }, p.net, gname), json!({"type": "add-part", "what": "TVS diode", "between": [p.net.clone(), gname.clone()], "nearPin": format!("{}.{}", jref, p.pad), "maxDistMm": 3.0, "signal": sig}))); }+                let rf = spec.sensitiveNets.iter().any(|x| *x == p.net);+                if prot.is_none() { issues.push(issue("low", "esd-unprotected", format!("{} pin {} ({}): no protection diode from {} to {}", jref, p.pad, p.net, p.net, gname), Some([p.x, p.y]), Some(&p.net), Some(jref), if rf { format!("{} is an RF input: protect it with a part of 0.5 pF or less at the band's top frequency (about 3 dB loss budget into 50 Ω), placed within 3 mm of {} and before the first stage; check its junction for intermodulation with strong stations, or use a gas discharge tube or a shunt inductor to ground where the band allows.", p.net, jref) } else { format!("If {} faces the outside world, add a TVS{} from {} to {} within 3 mm of the pin, before any chip.", jref, if sig { " (low capacitance, for a signal)" } else { " rated above the rail" }, p.net, gname) }, json!({"type": "add-part", "what": "TVS diode", "between": [p.net.clone(), gname.clone()], "nearPin": format!("{}.{}", jref, p.pad), "maxDistMm": 3.0, "signal": sig}))); }             }         }     }

@@ -34,19 +34,32 @@ pub struct Spec {     /// the design review's budgets: ground offset (mV, 10), IR drop per rail (% of the rail, 1), the highest EMC frequency (Hz, 1 GHz)     #[serde(default)] pub groundOffsetMv: Option<f64>, #[serde(default)] pub dropPct: Option<f64>, #[serde(default)] pub emcFmaxHz: Option<f64>,     /// named clocks (net: Hz), for the resonance and crosstalk checks; the coupled-noise budget on a quiet net (mV, 50)-    #[serde(default)] pub clocks: BTreeMap<String, f64>, #[serde(default)] pub crosstalkMv: Option<f64>,+    /// each clock or oscillator: a frequency (Hz), or {hz | minHz + maxHz (a tuned LO), harmonics, amplitudeV}+    #[serde(default)] pub clocks: BTreeMap<String, Clock>, #[serde(default)] pub crosstalkMv: Option<f64>,+    /// a coupled-noise budget per victim net (mV), over crosstalkMv: an RF or IF input's is microvolts+    #[serde(default)] pub victimBudgetsMv: BTreeMap<String, f64>,+    /// the receive bands for the frequency plan: {name: {minHz, maxHz, ifHz (its image is the band + 2 IF), lowSideLo}}+    #[serde(default)] pub bands: BTreeMap<String, Band>,+    /// nets a stray tone must not reach (an antenna port, an IF input): circuit paths to them from each oscillator are reported+    #[serde(default)] pub sensitiveNets: Vec<String>,     /// the power-delivery check per rail: target impedance or tolerance and step, band, source, load pin     #[serde(default)] pub pdn: BTreeMap<String, crate::pdn::RailCfg>,     /// a folder of measured capacitor curves (Murata SimSurfing JSON: C-DC bias, |Z|, R) keyed by MPN; else ADOM_FIELDS_CAP_CURVES     #[serde(default)] pub capCurves: Option<String>,+    /// the dielectric's εr when the board's stackup does not say (4.3)+    #[serde(default)] pub epsilonR: Option<f64>,+    /// set by analyze: εr per slot gap (from the board's stackup), the real gaps as given, and the real copper layers+    #[serde(skip)] pub er_slots: Option<Vec<f64>>, #[serde(skip)] pub real_gaps: Vec<f64>, #[serde(skip)] pub real_copper: Vec<String>, } fn d35() -> f64 { 35.0 } fn d60() -> f64 { 60.0 } #[derive(Deserialize, Clone)] pub struct Load { pub amps: f64, #[serde(default)] pub maxRiseC: Option<f64> }-#[derive(Deserialize, Clone)] pub struct Hot { pub watts: f64, pub tabNet: String }+/// a part's dissipation: through its exposed tab's net (tabNet), or, for a leaded part with no tab, through all its leads,+/// shared by pad area (issue 8)+#[derive(Deserialize, Clone)] pub struct Hot { pub watts: f64, #[serde(default)] pub tabNet: String }  #[derive(Serialize, Clone)]-pub struct NetResult { pub net: String, pub amps: f64, pub layers: Vec<String>, pub peakJ: f64, pub peakAt: [f64; 2], pub peakLayer: String, pub copperMm2: f64, pub jouleW: f64, pub vias: usize, pub iterations: usize }+pub struct NetResult { pub residual: f64, pub converged: bool, pub net: String, pub amps: f64, pub layers: Vec<String>, pub peakJ: f64, pub peakAt: [f64; 2], pub peakLayer: String, pub copperMm2: f64, pub jouleW: f64, pub vias: usize, pub iterations: usize } #[derive(Serialize, Clone)] pub struct ChipResult { pub reference: String, pub watts: f64, pub tabNet: String, pub x: f64, pub y: f64, pub riseC: f64, pub riseMovingC: f64, pub planeW: f64, pub viaW: f64, pub vias: usize, pub otherViaW: f64, pub otherVias: usize, pub dielW: f64, pub airW: f64, pub viasWanted: usize } #[derive(Serialize, Clone)]@@ -169,8 +182,21 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu             if !pinned { let (a, r, c) = sp[0]; sys.leak[a][r * w + c] = 1e3; pinned = true; pinned_at = Some(a * n + r * w + c); }         }         if hs == 0 || hk == 0 { log(&format!("{net}: terminals not on copper (sources {hs}, sinks {hk}), skipped")); continue; }-        let (v, it, res) = sys.solve(&rhs, 1e-7, 6000);-        log(&format!("{net}: {} A, {} layer(s), {it} iterations, residual {res:.1e}", load.amps, nl));+        // copper pieces with terminal current but no path to the pinned spot float on the tiny leak and stall the solve+        // (issue 9: GND 6000 iterations at 1.7e-1): give each such piece its own reference+        let mut islands = 0usize;+        {+            let nn = sys.n(); let mut par: Vec<usize> = (0..nn).collect();+            fn find(p: &mut Vec<usize>, mut x: usize) -> usize { while p[x] != x { p[x] = p[p[x]]; x = p[x]; } x }+            let mut uni = |p: &mut Vec<usize>, a: usize, b: usize| { let (ra, rb) = (find(p, a), find(p, b)); if ra != rb { p[ra] = rb; } };+            for k in 0..sys.nl { for r in 0..h { for c in 0..w - 1 { if sys.gx[k][r * (w - 1) + c] > 0.0 { uni(&mut par, k * n + r * w + c, k * n + r * w + c + 1); } } } for r in 0..h - 1 { for c in 0..w { if sys.gy[k][r * w + c] > 0.0 { uni(&mut par, k * n + r * w + c, k * n + (r + 1) * w + c); } } } }+            for k in 0..sys.nl.saturating_sub(1) { for i in 0..n { if sys.gz[k][i] > 0.0 { uni(&mut par, k * n + i, (k + 1) * n + i); } } }+            for &(a, b, g) in &sys.edges.clone() { if g > 0.0 { uni(&mut par, a, b); } }+            if let Some(pa) = pinned_at { let root = find(&mut par, pa); let mut done: std::collections::BTreeSet<usize> = Default::default(); done.insert(root);+                for &sp in ext_spots.iter().chain(chip_spots.iter()) { let rt = find(&mut par, sp); if done.insert(rt) { let (a, i) = (sp / n, sp % n); if a < sys.nl { sys.leak[a][i] = 1e3; islands += 1; } } } }+        }+        let (v, it, res) = sys.solve(&rhs, 1e-7, 20000);+        log(&format!("{net}: {} A, {} layer(s), {it} iterations, residual {res:.1e}{}{}", load.amps, nl, if islands > 0 { format!(", {islands} copper piece(s) with terminals but no path to the rest, each referenced on its own") } else { String::new() }, if res > 1e-4 { " NOT CONVERGED" } else { "" }));         let mut grids: Vec<Grid> = LAYERS.iter().map(|_| Grid::new(w, h)).collect();         let (mut peak, mut peak_at, mut peak_layer) = (0.0f64, [0.0, 0.0], String::new());         let mut joule = 0.0;@@ -226,7 +252,7 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu         let mean = |s: &[usize]| { let r: Vec<f64> = s.iter().filter(|i| reach[**i]).map(|i| v[*i]).collect(); if r.is_empty() { 0.0 } else { r.iter().sum::<f64>() / r.len() as f64 } };         nf.v_ext = mean(&ext_spots); nf.v_chip = mean(&chip_spots); nf.terminals = terminals; nf.amps = load.amps;         flow.insert(net.clone(), nf);-        nets.push(NetResult { net: net.clone(), amps: load.amps, layers: live.iter().map(|k| LAYERS[*k].to_string()).collect(), peakJ: (peak * 10.0).round() / 10.0, peakAt: peak_at, peakLayer: peak_layer, copperMm2: (copper * 10.0).round() / 10.0, jouleW: (joule * 1000.0).round() / 1000.0, vias: nvias, iterations: it });+        nets.push(NetResult { residual: res, converged: res <= 1e-4, net: net.clone(), amps: load.amps, layers: live.iter().map(|k| LAYERS[*k].to_string()).collect(), peakJ: (peak * 10.0).round() / 10.0, peakAt: peak_at, peakLayer: peak_layer, copperMm2: (copper * 10.0).round() / 10.0, jouleW: (joule * 1000.0).round() / 1000.0, vias: nvias, iterations: it });         j_net.insert(net.clone(), grids);     }     let joule_total: f64 = nets.iter().map(|x| x.jouleW).sum();@@ -251,8 +277,8 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu     } }     // ---- heat: four layers, the dielectric and the vias between them, the air on the faces --------     let nl = LAYERS.len();-    let t_diel: Vec<f64> = if spec.stackupMm.len() == 3 { spec.stackupMm.clone() } else { vec![0.2, 1.065, 0.2] };-    let share = [t_diel[0] / 2.0, t_diel[0] / 2.0 + t_diel[1] / 2.0, t_diel[1] / 2.0 + t_diel[2] / 2.0, t_diel[2] / 2.0];+    let t_diel: Vec<f64> = slot_gaps(spec);+    let share: Vec<f64> = (0..LAYERS.len()).map(|k| (if k > 0 { t_diel[k - 1] / 2.0 } else { 0.0 }) + (if k + 1 < LAYERS.len() { t_diel[k] / 2.0 } else { 0.0 })).collect();     let build = |h_air: f64| {         let mut sys = System::new(nl, h, w);         for k in 0..nl {@@ -275,16 +301,19 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu     for k in 0..nl { for i in 0..n {q_rhs[k*n+i] += p_joule[k].v[i] as f64;} }     let mut chip_pos: Vec<(String, f64, f64, f64, String)> = Vec::new();     for (reference, hot) in &spec.hot {-        let cells: Vec<(f64, f64)> = b.pads.iter().filter(|p| p.reference == *reference && p.net == hot.tabNet).map(|p| (p.x, p.y)).collect();-        if cells.is_empty() { log(&format!("{reference}: no pad on {} (tab net), its watts are not placed", hot.tabNet)); continue; }-        let per = hot.watts / cells.len() as f64;-        for (x, y) in &cells {+        let leads = hot.tabNet.is_empty();+        let pads: Vec<&crate::board::Pad> = b.pads.iter().filter(|p| p.reference == *reference && (leads || p.net == hot.tabNet)).collect();+        let cells: Vec<(f64, f64)> = pads.iter().map(|p| (p.x, p.y)).collect();+        if cells.is_empty() { log(&format!("{reference}: {}, its watts are not placed", if leads { "no pads".to_string() } else { format!("no pad on {} (tab net)", hot.tabNet) })); continue; }+        let area_sum: f64 = pads.iter().map(|p| p.area.max(1e-6)).sum();+        for (pi, (x, y)) in cells.iter().enumerate() {+            let per = hot.watts * pads[pi].area.max(1e-6) / area_sum;             let Some((r0, c0)) = cell(*x, *y) else { continue };             let rad = (1.2 / d) as isize; let mut spots = Vec::new();             for dr in -rad..=rad { for dc in -rad..=rad { let (r, c) = (r0 as isize + dr, c0 as isize + dc); if r >= 0 && c >= 0 && (r as usize) < h && (c as usize) < w && dr * dr + dc * dc <= rad * rad { spots.push((r as usize, c as usize)); } } }             for (r, c) in &spots { q_rhs[r * w + c] += per / spots.len() as f64; }         }-        chip_pos.push((reference.clone(), cells[0].0, cells[0].1, hot.watts, hot.tabNet.clone()));+        chip_pos.push((reference.clone(), cells[0].0, cells[0].1, hot.watts, if leads { "leads".to_string() } else { hot.tabNet.clone() }));     }     let tab_total: f64 = spec.hot.values().map(|h| h.watts).sum();     let (sys_still, sink_meshes) = build(H_STILL);@@ -368,13 +397,13 @@ pub fn summary(f: &Fields, b: &Board, spec: &Spec, textures: &[String]) -> Value     areas.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));     let pour_nets: Vec<Value> = areas.into_iter().map(|(n, a)| json!({"net": n, "copperMm2": (a * 10.0).round() / 10.0})).collect();     json!({-        "board": {"name": spec.board, "x0": b.x0, "y0": b.y0, "widthMm": b.width(), "heightMm": b.height(), "layers": LAYERS, "copperUm": spec.copperUm, "dielectricMm":if spec.stackupMm.len()==3 {spec.stackupMm.clone()} else {vec![0.2,1.065,0.2]}, "copperUmByLayer":LAYERS.iter().map(|l|((*l).to_string(),spec.copperUmByLayer.get(*l).copied().unwrap_or(spec.copperUm))).collect::<BTreeMap<_,_>>(), "thicknessMm": if spec.stackupMm.len()==3 {spec.stackupMm.iter().sum::<f64>()} else {1.465} + LAYERS.iter().map(|l|spec.copperUmByLayer.get(*l).copied().unwrap_or(spec.copperUm)/1000.0).sum::<f64>(), "cellMm": f.d, "cols": f.w, "rows": f.h},+        "board": {"name": spec.board, "x0": b.x0, "y0": b.y0, "widthMm": b.width(), "heightMm": b.height(), "layers": LAYERS, "copperUm": spec.copperUm, "dielectricMm":if spec.real_gaps.is_empty() {slot_gaps(spec)} else {spec.real_gaps.clone()}, "slotDielectricMm": slot_gaps(spec), "copperLayers": if spec.real_copper.is_empty() { LAYERS.iter().map(|l| l.to_string()).collect::<Vec<_>>() } else { spec.real_copper.clone() }, "copperUmByLayer":LAYERS.iter().map(|l|((*l).to_string(),spec.copperUmByLayer.get(*l).copied().unwrap_or(spec.copperUm))).collect::<BTreeMap<_,_>>(), "thicknessMm": slot_gaps(spec).iter().sum::<f64>() + (if spec.real_copper.is_empty() { LAYERS.iter().map(|l| l.to_string()).collect::<Vec<_>>() } else { spec.real_copper.clone() }).iter().map(|l|spec.copperUmByLayer.get(l).copied().unwrap_or(spec.copperUm)/1000.0).sum::<f64>(), "cellMm": f.d, "cols": f.w, "rows": f.h},         "nets": nets, "chips": chips, "issues": f.issues,         "signals": f.signals, "heatsinks": f.heatsinks, "thermalConvergence":{"stillResidual":f.heat_residual,"movingResidual":f.heat_moving_residual},         "vias": b.vias.iter().map(|v| json!({"net": v.net, "x": v.x, "y": v.y, "size": v.size, "drill": v.drill})).collect::<Vec<_>>(),         "pads": b.pads.iter().filter(|p| spec.hot.contains_key(&p.reference) || spec.loads.contains_key(&p.net)).map(|p| json!({"ref": p.reference, "pad": p.pad, "net": p.net, "x": p.x, "y": p.y})).collect::<Vec<_>>(),         "scales": {"jMax": f.j_all.iter().map(|g| g.max()).fold(0.0, f32::max), "qMax": f.q.iter().map(|g| g.max()).fold(0.0, f32::max), "tMax": tmax, "tMovingMax": f.t_moving.iter().map(|g| g.max()).fold(0.0, f32::max)},-        "heat": {"tabW": f.tab_total, "jouleW": f.joule_total, "peakRiseC": tmax, "peakRiseMovingC": f.t_moving.iter().map(|g| g.max()).fold(0.0, f32::max), "budgetC": spec.hotMaxRiseC, "stillAirWPerM2K": H_STILL * 1e6, "movingAirWPerM2K": H_MOVING * 1e6},+        "heat": {"sourcesModelled": spec.hot.len(), "status": if spec.hot.is_empty() { "no heat sources modelled: the temperature is only the copper's own I²R loss, not a thermal pass for any part (give each dissipating part in spec hot: watts, and tabNet if it has an exposed tab, else its watts go through all its leads)" } else { "parts modelled" }, "tabW": f.tab_total, "jouleW": f.joule_total, "peakRiseC": tmax, "peakRiseMovingC": f.t_moving.iter().map(|g| g.max()).fold(0.0, f32::max), "budgetC": spec.hotMaxRiseC, "stillAirWPerM2K": H_STILL * 1e6, "movingAirWPerM2K": H_MOVING * 1e6},         "textures": textures,         "partValues": b.values,         "pourNets": pour_nets,@@ -398,3 +427,36 @@ pub fn summary(f: &Fields, b: &Board, spec: &Spec, textures: &[String]) -> Value         assert!(cooled.chips[0].riseMovingC<cooled.chips[0].riseC);     } }++/// The dielectric between two copper layers (LAYERS indices): its thickness (the spec's stackupMm, which the board's own+/// stackup fills when the spec has none) and its εr (the board's stackup, else the spec's epsilonR, else 4.3).+pub fn gap_between(spec: &Spec, _b: &crate::board::Board, ka: usize, kb: usize) -> (f64, f64) {+    let (lo, hi) = (ka.min(kb), ka.max(kb)); if lo == hi { return (0.0, spec.epsilonR.unwrap_or(4.3)); }+    let st = slot_gaps(spec);+    let h: f64 = st[lo..hi].iter().sum();+    let er = match &spec.er_slots { Some(e) => { let w: f64 = (lo..hi).map(|i| e[i] * st[i]).sum(); w / h } None => spec.epsilonR.unwrap_or(4.3) };+    (h, er)+}+/// The dielectric in each of the five slot gaps (between the six copper slots), as analyze normalised it.+pub fn slot_gaps(spec: &Spec) -> Vec<f64> { if spec.stackupMm.len() == LAYERS.len() - 1 { spec.stackupMm.clone() } else { spread(&[0.2, 1.065, 0.2], &["F.Cu".into(), "In1.Cu".into(), "In2.Cu".into(), "B.Cu".into()]) } }+/// Real gaps between consecutive real copper layers, spread over the slots between them (empty slots carry only dielectric).+pub fn spread(gaps: &[f64], copper: &[String]) -> Vec<f64> {+    let idx: Vec<usize> = copper.iter().filter_map(|c| LAYERS.iter().position(|l| *l == c)).collect();+    let mut out = vec![0.0; LAYERS.len() - 1];+    for (g, w) in gaps.iter().zip(idx.windows(2)) { let span = (w[1] - w[0]).max(1); for k in w[0]..w[1] { out[k] = g / span as f64; } }+    out+}++#[derive(Deserialize, Clone, Debug)]+#[serde(untagged)]+pub enum Clock { Hz(f64), Cfg { #[serde(default)] hz: Option<f64>, #[serde(default)] minHz: Option<f64>, #[serde(default)] maxHz: Option<f64>, #[serde(default)] harmonics: Option<usize>, #[serde(default)] amplitudeV: Option<f64> } }+impl Clock {+    pub fn lo_hz(&self) -> f64 { match self { Clock::Hz(h) => *h, Clock::Cfg { hz, minHz, maxHz, .. } => minHz.or(*hz).or(*maxHz).unwrap_or(0.0) } }+    pub fn top_hz(&self) -> f64 { match self { Clock::Hz(h) => *h, Clock::Cfg { hz, minHz, maxHz, .. } => maxHz.or(*hz).or(*minHz).unwrap_or(0.0) } }+    pub fn mid_hz(&self) -> f64 { (self.lo_hz() + self.top_hz()) / 2.0 }+    pub fn swept(&self) -> bool { self.top_hz() > self.lo_hz() * 1.001 }+    pub fn harmonics(&self) -> Option<usize> { match self { Clock::Cfg { harmonics, .. } => *harmonics, _ => None } }+    pub fn amplitude(&self) -> Option<f64> { match self { Clock::Cfg { amplitudeV, .. } => *amplitudeV, _ => None } }+}+#[derive(Deserialize, Clone, Debug)]+pub struct Band { pub minHz: f64, pub maxHz: f64, #[serde(default)] pub ifHz: Option<f64>, #[serde(default)] pub lowSideLo: bool }

@@ -56,19 +56,21 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va     let rail = |nm: &str| spec.voltages.get(nm).copied().or_else(|| rail_from_name(nm));     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 gid = f.net_names.iter().position(|x| is_ground(x)).map(|i| i as u16);-    let er: f64 = 4.3;-    // the strong tones: switching harmonics (trapezoid envelope within 40 dB of the fundamental) and named clocks-    let mut tones: Vec<(f64, String)> = Vec::new();-    for (net, sw) in &spec.switching { let fs = sw.freqHz.unwrap_or(500e3); let tr = sw.riseNs.unwrap_or(8.0) * 1e-9; let knee = 1.0 / (std::f64::consts::PI * tr); let top = (knee * 10.0).min(spec.emcFmaxHz.unwrap_or(1e9)); let mut k = 1.0; while k * fs <= top { tones.push((k * fs, format!("{net} harmonic {}", k as u64))); k += if k * fs < 100e6 { 1.0 } else { (k * 0.01).max(1.0).floor() }; } }-    // a crystal's pins, or an LC oscillator no chip drives, swing nearly as a sine: only the first five harmonics count;-    // a logic clock's run on-    for (net, hz) in &spec.clocks { let xtal = b.pads.iter().any(|p| p.net == *net && (p.reference.starts_with('Y') || p.reference.starts_with('X'))) || !b.pads.iter().any(|p| p.net == *net && p.reference.starts_with('U')); let top = if xtal { 5.0 * hz } else { spec.emcFmaxHz.unwrap_or(1e9) * 2.0 }; let mut k = 1.0; while k * hz <= top * 1.0001 { tones.push((k * hz, format!("{net} {} harmonic {}", if xtal { "oscillator" } else { "clock" }, k as u64))); k += 1.0; } }+    // the strong tones, each a frequency range (a tuned LO sweeps): switching harmonics (trapezoid envelope within 40 dB+    // of the fundamental) and the named clocks: a crystal's pins, or an LC oscillator no chip drives, swing nearly as a+    // sine, so only the first five harmonics count as strong; a logic clock's run on (or the spec's harmonics)+    let sine_net = |net: &str| b.pads.iter().any(|p| p.net == net && (p.reference.starts_with('Y') || p.reference.starts_with('X'))) || !b.pads.iter().any(|p| p.net == net && p.reference.starts_with('U'));+    let mut tones: Vec<(f64, f64, String)> = Vec::new();+    for (net, sw) in &spec.switching { let fs = sw.freqHz.unwrap_or(500e3); let tr = sw.riseNs.unwrap_or(8.0) * 1e-9; let knee = 1.0 / (std::f64::consts::PI * tr); let top = (knee * 10.0).min(spec.emcFmaxHz.unwrap_or(1e9)); let mut k = 1.0; while k * fs <= top { tones.push((k * fs, k * fs, format!("{net} harmonic {}", k as u64))); k += if k * fs < 100e6 { 1.0 } else { (k * 0.01).max(1.0).floor() }; } }+    for (net, c) in &spec.clocks { let sine = sine_net(net); let nh = c.harmonics().unwrap_or(if sine { 5 } else { ((spec.emcFmaxHz.unwrap_or(1e9) * 2.0) / c.top_hz().max(1.0)) as usize }).min(4000); for k in 1..=nh.max(1) { let kf = k as f64; tones.push((kf * c.lo_hz(), kf * c.top_hz(), format!("{net} {} harmonic {k}", if sine { "oscillator" } else { "clock" }))); } }+    let hz_txt = |a: f64, z: f64| -> String { let one = |x: f64| if x >= 1e9 { format!("{:.2} GHz", x / 1e9) } else if x >= 1e6 { format!("{:.1} MHz", x / 1e6) } else { format!("{:.0} kHz", x / 1e3) }; if (z - a).abs() < a * 1e-3 { one(a) } else { format!("{}–{}", one(a), one(z)) } };     let mut out = json!({});     // ---- cavities --------------------------------------------------------------------------------------------     let mut cavities = Vec::new();-    if let (Some(g), true) = (gid, real.len() >= 2) {-        let (k0, k1) = (real[0], real[1]);-        let hmm = { 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) } };+    // every pour facing ground on the next copper layer, in either direction (issue 9: not just the first two layers)+    let layer_pairs: Vec<(usize, usize)> = real.windows(2).flat_map(|w| [(w[0], w[1]), (w[1], w[0])]).collect();+    if let Some(g) = gid { for (k0, k1) in layer_pairs {+        let (hmm, er) = crate::fields::gap_between(spec, b, k0, k1);         let mut pairs: std::collections::BTreeMap<u16, usize> = Default::default();         for i in 0..n { let a = f.net_ids[k0][i]; if a != u16::MAX && a != g && f.net_ids[k1][i] == g { *pairs.entry(a).or_default() += 1; } }         for (id, cnt) in pairs {@@ -92,60 +94,116 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va                 let k = lam.sqrt() / hc; let fr = C_MM * k / (2.0 * std::f64::consts::PI * er.sqrt());                 let (mut amax, mut at) = (0.0, 0usize); for (j, v) in vec.iter().enumerate() { if v.abs() > amax { amax = v.abs(); at = j; } }                 let atxy = [f.x0 + ((cells[at] % cw) as f64 + 0.5) * hc, f.y0 + ((cells[at] / cw) as f64 + 0.5) * hc];-                let near = tones.iter().filter(|t| (t.0 - fr).abs() / fr < 0.05).min_by(|a, z| (a.0 - fr).abs().partial_cmp(&(z.0 - fr).abs()).unwrap());-                ms.push(json!({"fHz": fr.round(), "antinode": [r2(atxy[0]), r2(atxy[1])], "near": near.map(|t| t.1.clone())}));-                if let Some(t) = near { issues.push(Issue { severity: "medium".into(), kind: "cavity-resonance".into(), what: format!("{} over {}: a plane mode at {:.0} MHz sits within 5 % of the {} ({:.0} MHz)", name, f.net_names[g as usize], fr / 1e6, t.1, t.0 / 1e6), at: Some([r2(atxy[0]), r2(atxy[1])]), layer: Some(LAYERS[k0].into()), net: Some(name.clone()), reference: None, fix: format!("Damp it where it rings loudest, ({:.1}, {:.1}): a 1 to 10 nF capacitor from {} to ground there, or ground vias through the pour.", atxy[0], atxy[1], name), action: Some(json!({"type": "add-part", "what": "capacitor", "value": "4.7nF", "between": [name, f.net_names[g as usize]], "at": [r2(atxy[0]), r2(atxy[1])], "why": "damp a plane resonance"})) }); }+                let near = tones.iter().filter(|t| fr >= t.0 * 0.95 && fr <= t.1 * 1.05).min_by(|a, z| ((a.0 + a.1) / 2.0 - fr).abs().partial_cmp(&((z.0 + z.1) / 2.0 - fr).abs()).unwrap());+                ms.push(json!({"fHz": fr.round(), "antinode": [r2(atxy[0]), r2(atxy[1])], "near": near.map(|t| t.2.clone())}));+                if let Some(t) = near { issues.push(Issue { severity: "medium".into(), kind: "cavity-resonance".into(), what: format!("{} on {} over {} on {}: a plane mode at {:.0} MHz sits within 5 % of the {} ({})", name, LAYERS[k0], f.net_names[g as usize], LAYERS[k1], fr / 1e6, t.2, hz_txt(t.0, t.1)), at: Some([r2(atxy[0]), r2(atxy[1])]), layer: Some(LAYERS[k0].into()), net: Some(name.clone()), reference: None, fix: format!("Damp it where it rings loudest, ({:.1}, {:.1}): a 1 to 10 nF capacitor from {} to ground there, or ground vias through the pour.", atxy[0], atxy[1], name), action: Some(json!({"type": "add-part", "what": "capacitor", "value": "4.7nF", "between": [name, f.net_names[g as usize]], "at": [r2(atxy[0]), r2(atxy[1])], "why": "damp a plane resonance"})) }); }             }             // the shapes over the cavity's own bounding box, three decimals: the app animates them             let (r0, r1) = (cells.iter().map(|c| c / cw).min().unwrap(), cells.iter().map(|c| c / cw).max().unwrap()); let (c0, c1) = (cells.iter().map(|c| c % cw).min().unwrap(), cells.iter().map(|c| c % cw).max().unwrap()); let (bw, bh) = (c1 - c0 + 1, r1 - r0 + 1);             let shapes: Vec<Vec<f64>> = modes.iter().skip(1).take(3).map(|(_, v)| { let mx = v.iter().fold(0.0f64, |a, b| a.max(b.abs())).max(1e-12); let mut sub = vec![0.0f64; bw * bh]; for (j, c) in cells.iter().enumerate() { sub[(c / cw - r0) * bw + (c % cw - c0)] = (v[j] / mx * 1000.0).round() / 1000.0; } sub }).collect();             let mask_sub: Vec<u8> = (0..bw * bh).map(|i| { let c = (r0 + i / bw) * cw + c0 + i % bw; if comp[c] == best.0 { 1 } else { 0 } }).collect();-            cavities.push(json!({"net": name, "over": f.net_names[g as usize], "areaMm2": r2(cnt as f64 * f.d * f.d), "gapMm": hmm, "grid": {"cols": bw, "rows": bh, "cellMm": hc, "x0": f.x0 + c0 as f64 * hc, "y0": f.y0 + r0 as f64 * hc, "mask": mask_sub}, "modes": ms, "shapes": shapes}));+            cavities.push(json!({"net": name, "layer": LAYERS[k0], "overLayer": LAYERS[k1], "er": r2(er), "over": f.net_names[g as usize], "areaMm2": r2(cnt as f64 * f.d * f.d), "gapMm": hmm, "grid": {"cols": bw, "rows": bh, "cellMm": hc, "x0": f.x0 + c0 as f64 * hc, "y0": f.y0 + r0 as f64 * hc, "mask": mask_sub}, "modes": ms, "shapes": shapes}));         }     }+    }     out["cavities"] = json!(cavities);     // ---- crosstalk -----------------------------------------------------------------------------------------------    let aggressors: Vec<(String, f64)> = spec.switching.iter().map(|(k, s)| (k.clone(), s.highV - s.lowV)).chain(f.net_names.iter().filter(|nm| is_switch_name(nm) && !spec.switching.contains_key(*nm)).map(|nm| (nm.clone(), f.net_names.iter().filter_map(|x| rail(x)).fold(0.0, f64::max)))).chain(spec.clocks.keys().map(|k| (k.clone(), rail("VCC").unwrap_or(3.3)))).collect();+    // aggressors: a switching node is a step of its swing; a clock or oscillator is a sine at its amplitude (the spec's,+    // else 1 V for a crystal or LC oscillator, the logic rail for a chip-driven clock) and its mid frequency+    struct Agg { net: String, amp: f64, hz: Option<f64> }+    let logic_v = rail("+3V3").or_else(|| rail("VCC")).unwrap_or(3.3);+    let mut aggressors: Vec<Agg> = spec.switching.iter().map(|(k, s)| Agg { net: k.clone(), amp: s.highV - s.lowV, hz: None }).collect();+    for nm in f.net_names.iter().filter(|nm| is_switch_name(nm) && !spec.switching.contains_key(*nm)) { aggressors.push(Agg { net: nm.clone(), amp: f.net_names.iter().filter_map(|x| rail(x)).fold(0.0, f64::max), hz: None }); }+    for (k, c) in &spec.clocks { aggressors.push(Agg { net: k.clone(), amp: c.amplitude().unwrap_or(if sine_net(k) { 1.0 } else { logic_v }), hz: Some(c.mid_hz()) }); }     let mut xt = Vec::new();     let budget = spec.crosstalkMv.unwrap_or(50.0);     let thick = |k: usize| spec.copperUmByLayer.get(LAYERS[k]).copied().unwrap_or(spec.copperUm) / 1000.0;-    for (agg, dv) in &aggressors {+    // the nearest real copper layer to k: the plane a victim on k sits over+    let plane_gap = |k: usize| -> (f64, f64) { let i = real.iter().position(|x| *x == k).unwrap_or(0); let nb: Vec<usize> = [i.checked_sub(1), Some(i + 1)].into_iter().flatten().filter_map(|j| real.get(j).copied()).collect(); nb.iter().map(|&o| crate::fields::gap_between(spec, b, k, o)).min_by(|a, z| a.0.partial_cmp(&z.0).unwrap()).unwrap_or((1.465, 4.3)) };+    // a net's shunt to AC ground: the capacitors and resistors from it to ground or any rail (rails are AC ground)+    let shunt = |net: &str| -> (f64, f64) { let mut cs = 0.0; let mut g = 0.0; let mut refs: Vec<&str> = b.pads.iter().filter(|p| p.net == net).map(|p| p.reference.as_str()).collect(); refs.sort(); refs.dedup();+        for r in refs { let ns: Vec<&str> = b.pads.iter().filter(|p| p.reference == r).map(|p| p.net.as_str()).collect(); if ns.len() != 2 { continue; } let other = if ns[0] == net { ns[1] } else { ns[0] }; if !(is_ground(other) || rail(other).is_some()) { continue; }+            let val = b.values.get(r).map(String::as_str).unwrap_or("");+            if r.starts_with('C') { if let Some(c) = crate::emc::parse_value(val, 'F') { cs += c; } }+            else if r.starts_with('R') { let u = val.to_ascii_uppercase().replace("OHM", ""); let t = u.trim(); let ohm = if let Some(i) = t.find(|c: char| c == 'K' || c == 'M' || c == 'R') { let m = match &t[i..i + 1] { "K" => 1e3, "M" => 1e6, _ => 1.0 }; format!("{}.{}", &t[..i], &t[i + 1..]).trim_end_matches('.').parse::<f64>().unwrap_or(0.0) * m } else { t.parse::<f64>().unwrap_or(0.0) }; if ohm > 0.0 { g += 1.0 / ohm; } } }+        (cs, g) };+    for ag in &aggressors {+        let agg = &ag.net; let dv = ag.amp;         let Some(aid) = f.net_names.iter().position(|x| x == agg) else { continue }; let aid = aid as u16;+        let is_clock = ag.hz.is_some();+        // one discrete part away is the aggressor's own circuit (a bootstrap capacitor, an oscillator's crystal or+        // transistor): coupled through that part far more than through stray copper; its circuit paths are reported below+        let disc = |r: &str| r.starts_with('C') || (is_clock && !r.starts_with('U') && !r.starts_with('J') && !r.starts_with("TP"));+        let one: std::collections::BTreeSet<String> = { let mut out = std::collections::BTreeSet::new(); for p in b.pads.iter().filter(|p| p.net == *agg && disc(&p.reference)) { for q in b.pads.iter().filter(|q| q.reference == p.reference && q.net != *agg) { out.insert(q.net.clone()); } } out };         for (vid, vname) in f.net_names.iter().enumerate() {-            let vid = vid as u16; if vid == aid || Some(vid) == gid || f.flow.contains_key(vname) || rail(vname).is_some() || aggressors.iter().any(|a| a.0 == *vname) { continue; }-            // a net joined to the aggressor through a capacitor rides on it on purpose (a bootstrap): not a victim-            // and for a clock or an oscillator, a net sharing any discrete part with it (its crystal, its transistor,-            // its bias resistor) is the oscillator's own circuit, coupled by design; a chip's other pins still count-            let is_clock = spec.clocks.contains_key(agg);-            let rides = { let disc = |r: &str| r.starts_with('C') || (is_clock && !r.starts_with('U') && !r.starts_with('J') && !r.starts_with("TP"));-                // the nets one discrete part away from a net (never through a rail or ground)-                let hop = |from: &str| -> std::collections::BTreeSet<String> { let mut out = std::collections::BTreeSet::new(); for p in b.pads.iter().filter(|p| p.net == from && disc(&p.reference)) { for q in b.pads.iter().filter(|q| q.reference == p.reference && q.net != from) { out.insert(q.net.clone()); } } out };-                let one = hop(agg);-                one.contains(vname.as_str()) || (is_clock && one.iter().filter(|n| rail(n).is_none() && !is_ground(n)).any(|n| hop(n).contains(vname.as_str()))) };-            if rides { continue; }-            // side coupling on each layer: victim cells within 1 mm of the aggressor, summed as C per length at that spacing-            let (mut cm, mut closest, mut at, mut run) = (0.0f64, f64::MAX, [0.0, 0.0], 0usize); let mut varea = 0.0;-            let rad = (1.0 / f.d).ceil() as i64;-            for &k in &real { for i in 0..n {-                if f.net_ids[k][i] != vid { continue; } varea += f.d * f.d;+            let vid = vid as u16; if vid == aid || Some(vid) == gid || f.flow.contains_key(vname) || rail(vname).is_some() || aggressors.iter().any(|a| a.net == *vname) || one.contains(vname.as_str()) { continue; }+            // side coupling within 3 mm on each layer; a plane h below shields it, roughly as 1 / (1 + (s / 2h)²)+            let (mut cm, mut closest, mut at, mut run) = (0.0f64, f64::MAX, [0.0, 0.0], 0usize); let mut cg_cu = 0.0;+            let rad = (3.0 / f.d).ceil() as i64;+            for &k in &real { let (hk, erk) = plane_gap(k); for i in 0..n {+                if f.net_ids[k][i] != vid { continue; } cg_cu += E0 * erk * f.d * f.d / hk.max(0.05);                 let (r, c) = ((i / w) as i64, (i % w) as i64); let mut dmin = f64::MAX;                 for dr in -rad..=rad { for dc in -rad..=rad { let (rr, cc) = (r + dr, c + dc); if rr < 0 || cc < 0 || rr >= h as i64 || cc >= w as i64 { continue; } if f.net_ids[k][rr as usize * w + cc as usize] == aid { dmin = dmin.min(((dr * dr + dc * dc) as f64).sqrt() * f.d); } } }-                if dmin < f64::MAX { let s_ = dmin.max(0.05); let eff = (er + 1.0) / 2.0; cm += E0 * eff * (thick(k) / s_ + 0.6 * (1.0 + f.d / s_).ln()) * f.d; run += 1; if dmin < closest { closest = dmin; at = [f.x0 + (c as f64 + 0.5) * f.d, f.y0 + (r as f64 + 0.5) * f.d]; } }+                if dmin <= 3.0 { let s_ = dmin.max(0.05); let eff = (erk + 1.0) / 2.0; let shield = 1.0 / (1.0 + (s_ / (2.0 * hk)).powi(2)); cm += E0 * eff * (thick(k) / s_ + 0.6 * (1.0 + f.d / s_).ln()) * f.d * shield; if dmin <= 1.0 { run += 1; } if dmin < closest { closest = dmin; at = [f.x0 + (c as f64 + 0.5) * f.d, f.y0 + (r as f64 + 0.5) * f.d]; } }             } }-            // overlap with the aggressor on the next layer-            let mut over = 0.0; if real.len() >= 2 { for i in 0..n { if (f.net_ids[real[0]][i] == vid && f.net_ids[real[1]][i] == aid) || (f.net_ids[real[1]][i] == vid && f.net_ids[real[0]][i] == aid) { over += f.d * f.d; } } }-            let hgap = if spec.stackupMm.len() == 3 { spec.stackupMm.iter().sum::<f64>() } else { 1.465 };-            cm += E0 * er * over / hgap;+            // overlap with the aggressor on each adjacent copper layer, at that pair's gap and εr+            let mut over = 0.0; for wpair in real.windows(2) { let (ga, gb) = (wpair[0], wpair[1]); let (hg, eg) = crate::fields::gap_between(spec, b, ga, gb); let mut o = 0.0; for i in 0..n { if (f.net_ids[ga][i] == vid && f.net_ids[gb][i] == aid) || (f.net_ids[gb][i] == vid && f.net_ids[ga][i] == aid) { o += f.d * f.d; } } over += o; cm += E0 * eg * o / hg; }             if cm <= 0.0 { continue; }-            let cg = E0 * er * varea / hgap + 3e-12;   // the victim to ground: its copper over the plane, plus about 3 pF of pins-            let mv = dv * cm / (cm + cg) * 1e3;-            xt.push(json!({"aggressor": agg, "victim": vname, "cmPf": r2(cm * 1e12), "closestMm": if closest < f64::MAX { r2(closest) } else { -1.0 }, "runMm": r2(run as f64 * f.d), "overlapMm2": r2(over), "coupledMv": r2(mv), "at": [r2(at[0]), r2(at[1])]}));-            if mv > budget { issues.push(Issue { severity: if mv > 4.0 * budget { "medium".into() } else { "low".into() }, kind: "crosstalk".into(), what: format!("{} picks up about {:.0} mV from each {} edge ({:.2} pF, closest {:.2} mm, {:.1} mm run)", vname, mv, agg, cm * 1e12, closest, run as f64 * f.d), at: Some([r2(at[0]), r2(at[1])]), layer: None, net: Some(vname.clone()), reference: None, fix: format!("Route {} at least {:.1} mm from {} (three times the spacing), or run a ground guard between them, and keep {} off the copper under {}.", vname, (closest * 3.0).max(1.0), agg, vname, agg), action: Some(json!({"type": "reroute", "net": vname, "awayFrom": agg, "minSpacingMm": r2((closest * 3.0).max(1.0)), "at": [r2(at[0]), r2(at[1])], "or": "ground guard between"})) }); }+            // the victim to ground: its copper over its nearest plane, about 3 pF of pins, and the parts on it (issue 9)+            let (cpart, gpart) = shunt(vname);+            let cg = cg_cu + 3e-12 + cpart;+            let v = match ag.hz { None => dv * cm / (cm + cg), Some(hz) => { let wv = 2.0 * std::f64::consts::PI * hz; dv * wv * cm / ((wv * (cm + cg)).powi(2) + gpart * gpart).sqrt() } };+            let mv = v * 1e3;+            let vb = spec.victimBudgetsMv.get(vname).copied().unwrap_or(budget);+            xt.push(json!({"aggressor": agg, "victim": vname, "kind": if is_clock { "sine" } else { "step" }, "atHz": ag.hz, "amplitudeV": dv, "cmPf": (cm * 1e15).round() / 1e3, "victimPf": r2(cg * 1e12), "victimShuntOhm": if gpart > 0.0 { json!(r2(1.0 / gpart)) } else { Value::Null }, "closestMm": if closest < f64::MAX { r2(closest) } else { -1.0 }, "runMm": r2(run as f64 * f.d), "overlapMm2": r2(over), "coupledMv": (mv * 1e4).round() / 1e4, "coupledUv": (mv * 1e3 * 10.0).round() / 10.0, "budgetMv": vb, "at": [r2(at[0]), r2(at[1])]}));+            if mv > vb {+                let amt = if mv >= 1.0 { format!("{:.0} mV", mv) } else { format!("{:.0} µV", mv * 1e3) };+                let what = if is_clock { format!("{} picks up about {} of {} ({:.0} MHz) through {:.0} fF (closest {:.2} mm; {:.0} pF to ground on the victim)", vname, amt, agg, ag.hz.unwrap_or(0.0) / 1e6, cm * 1e15, closest, cg * 1e12) } else { format!("{} picks up about {} from each {} edge ({:.2} pF, closest {:.2} mm, {:.1} mm run)", vname, amt, agg, cm * 1e12, closest, run as f64 * f.d) };+                issues.push(Issue { severity: if mv > 4.0 * vb { "medium".into() } else { "low".into() }, kind: "crosstalk".into(), what, at: Some([r2(at[0]), r2(at[1])]), layer: None, net: Some(vname.clone()), reference: None, fix: format!("Route {} at least {:.1} mm from {} (three times the spacing), or run a ground guard between them, and keep {} off the copper under {}.", vname, (closest * 3.0).max(1.0), agg, vname, agg), action: Some(json!({"type": "reroute", "net": vname, "awayFrom": agg, "minSpacingMm": r2((closest * 3.0).max(1.0)), "at": [r2(at[0]), r2(at[1])], "or": "ground guard between"})) });+            }         }     }     xt.sort_by(|a, z| z["coupledMv"].as_f64().partial_cmp(&a["coupledMv"].as_f64()).unwrap());     out["crosstalk"] = json!(xt);-    out["tones"] = json!(tones.iter().take(40).map(|t| json!({"fHz": t.0, "what": t.1})).collect::<Vec<_>>());+    out["budgetMv"] = json!(budget);+    out["victimBudgetsMv"] = json!(spec.victimBudgetsMv);+    // ---- the frequency plan: a tone or harmonic inside a receive band or its image (issue 9) --------------------------+    let mut plan = Vec::new();+    for (bn, bd) in &spec.bands {+        let image = bd.ifHz.map(|fi| if bd.lowSideLo { (bd.minHz - 2.0 * fi, bd.maxHz - 2.0 * fi) } else { (bd.minHz + 2.0 * fi, bd.maxHz + 2.0 * fi) });+        for (net, c) in &spec.clocks {+            // every harmonic up to the band, weak ones included: a receiver hears microvolts+            let nh = ((bd.maxHz.max(image.map_or(0.0, |x| x.1)) / c.lo_hz().max(1.0)).floor() as usize).min(c.harmonics().unwrap_or(400).max(1) * 1000).min(400);+            for k in 1..=nh.max(1) {+                if k == 1 && c.swept() { continue; }   // a tuned LO sits beside its own band by design: its leakage is a circuit path+                let (a, z) = (k as f64 * c.lo_hz(), k as f64 * c.top_hz());+                for (what, lo, hi) in [("band", bd.minHz, bd.maxHz)].into_iter().chain(image.map(|x| ("image band", x.0, x.1))) {+                    if z >= lo && a <= hi {+                        let sev = if k <= 5 { "medium" } else { "low" };+                        plan.push(json!({"tone": net, "harmonic": k, "fromHz": a, "toHz": z, "band": bn, "where": what, "bandHz": [lo, hi]}));+                        issues.push(Issue { severity: sev.into(), kind: "tone-in-band".into(), what: format!("harmonic {} of {} ({}) lands in the {} {} ({})", k, net, hz_txt(a, z), bn, what, hz_txt(lo, hi)), at: None, layer: None, net: Some(net.clone()), reference: None, fix: format!("Keep {} and its traces away from the {} front end and shield or filter it, or move its frequency so no harmonic falls in {} ({}).", net, bn, hz_txt(lo, hi), what), action: Some(json!({"type": "review", "net": net, "why": "a tone in a receive band", "harmonic": k, "band": bn, "where": what})) });+                    }+                }+            }+        }+    }+    out["frequencyPlan"] = json!(plan);+    // ---- circuit paths: from each oscillator through the parts to each sensitive net (issue 9: report, don't hide) -----+    let mut paths = Vec::new();+    for (net, _) in &spec.clocks { for target in &spec.sensitiveNets {+        // breadth-first through two-terminal and transistor parts, never through a rail or ground, at most 8 parts+        let mut prev: std::collections::BTreeMap<String, (String, String)> = Default::default(); let mut q = std::collections::VecDeque::new(); q.push_back((net.clone(), 0usize)); prev.insert(net.clone(), (String::new(), String::new()));+        let mut found = false;+        while let Some((cur, d)) = q.pop_front() { if cur == *target { found = true; break; } if d >= 8 { continue; }+            let mut refs: Vec<&str> = b.pads.iter().filter(|p| p.net == cur && !p.reference.starts_with('U') && !p.reference.starts_with('J') && !p.reference.starts_with("TP")).map(|p| p.reference.as_str()).collect(); refs.sort(); refs.dedup();+            for r in refs { for p in b.pads.iter().filter(|p| p.reference == r && p.net != cur) { if is_ground(&p.net) || rail(&p.net).is_some() || p.net.is_empty() || prev.contains_key(&p.net) { continue; } prev.insert(p.net.clone(), (cur.clone(), r.to_string())); q.push_back((p.net.clone(), d + 1)); } } }+        if found { let mut hops = Vec::new(); let mut cur = target.clone(); while let Some((p, r)) = prev.get(&cur).cloned() { if p.is_empty() { break; } hops.push(json!({"part": r, "value": b.values.get(&r), "from": p, "to": cur})); cur = p; } hops.reverse();+            let txt = hops.iter().map(|h| format!("{} {}", h["part"].as_str().unwrap_or(""), h["value"].as_str().unwrap_or(""))).collect::<Vec<_>>().join(" → ");+            issues.push(Issue { severity: "low".into(), kind: "circuit-path".into(), what: format!("{} reaches {} through {} part(s): {}", net, target, hops.len(), txt), at: None, layer: None, net: Some(target.clone()), reference: None, fix: format!("Simulate this path (ngspice AC with the stages' small-signal models) for the level of {} at {}; add isolation (a buffer, a lower-value coupling capacitor, a shield) if it is over the target.", net, target), action: Some(json!({"type": "review", "why": "circuit path from an oscillator to a sensitive net", "from": net, "to": target, "hops": hops})) });+            paths.push(json!({"from": net, "to": target, "hops": hops})); }+    } }+    out["circuitPaths"] = json!(paths);+    out["tones"] = json!(tones.iter().take(40).map(|t| json!({"fHz": t.0, "toHz": t.1, "what": t.2})).collect::<Vec<_>>());     let _ = b; out }