Adom Fields

@@ -27,7 +27,12 @@ fn issue(sev: &str, kind: &str, what: String, at: Option<[f64; 2]>, net: Option<  /// A resistor value in ohms from its Value text: "3m", "3mR", "0R003", "0.003", "0", "10k", "4R7" pub fn ohms(s: &str) -> Option<f64> {-    let t = s.trim().replace(['Ω', ' '], "").replace("ohm", "").replace("Ohm", "");+    // the Value often carries a rating or a size after the resistance ("3m 1W", "3mR 1%", "10k 0402", "3.0 0.75W"):+    // drop rating tokens, then take the first token, joined with the next when that is a bare unit ("3 mΩ")+    let rating = |w: &str| { let l = w.to_ascii_lowercase(); l.ends_with('w') || l.ends_with('v') || l.ends_with('%') || l.contains("ppm") };+    let toks: Vec<&str> = s.split_whitespace().filter(|w| !rating(w)).collect();+    let first = match toks.as_slice() { [] => return None, [a, u, ..] if u.chars().all(|c| c.is_alphabetic()) => format!("{a}{u}"), [a, ..] => a.to_string() };+    let t = first.replace('Ω', "").replace("ohm", "").replace("Ohm", "");     let t = t.split(['/', '_', ',']).next().unwrap_or("").to_string();     if t.is_empty() { return None; }     // a multiplier or R in place of the decimal point: 4R7, 0R003, 4k7, 3m3@@ -41,14 +46,16 @@ pub fn ohms(s: &str) -> Option<f64> {  /// The parts that join two nets with almost no impedance, for following an inductor's path: resistors of 1 Ω or less /// (current shunts, 0 Ω links), ferrite beads, and 2-pad net ties and jumpers.-fn series(b: &Board, r: &str) -> bool {+fn series(b: &Board, spec: &Spec, r: &str) -> bool {+    if spec.converter.as_ref().is_some_and(|c| c.series.iter().any(|x| x == r)) { return true; }     let v = b.values.get(r).map(String::as_str).unwrap_or("");     (r.starts_with('R') && ohms(v).is_some_and(|x| x <= 1.0)) || r.starts_with("FB") || r.starts_with("NT") || r.starts_with("JP") || (r.starts_with('L') && v.to_ascii_lowercase().contains("ferrite")) }  pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> 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 Value::Null };+    let grounds: Vec<String> = f.net_names.iter().filter(|n| is_ground(n)).cloned().collect();+    if grounds.is_empty() { return Value::Null; }     let pads_of = |r: &str, n: &str| -> Vec<&Pad> { b.pads.iter().filter(|p| p.reference == r && p.net == n).collect() };     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 refs: Vec<String> = { let mut v: Vec<String> = b.pads.iter().map(|p| p.reference.clone()).collect(); v.sort(); v.dedup(); v };@@ -61,7 +68,7 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va     // the nets a node reaches through series parts (two hops), and the parts on the way     let through = |start: &str| -> (Vec<String>, Vec<String>) {         let (mut nets, mut parts) = (vec![start.to_string()], Vec::new());-        for _ in 0..2 { let cur = nets.clone(); for n in &cur { for r in refs.iter().filter(|r| series(b, r) && nets_of(r).len() == 2 && nets_of(r).contains(n)) { for m in nets_of(r) { if !nets.contains(&m) && m != gnd { nets.push(m); if !parts.contains(r) { parts.push(r.clone()); } } } } } }+        for _ in 0..2 { let cur = nets.clone(); for n in &cur { for r in refs.iter().filter(|r| series(b, spec, r) && nets_of(r).len() == 2 && nets_of(r).contains(n)) { for m in nets_of(r) { if !nets.contains(&m) && !grounds.contains(&m) { nets.push(m); if !parts.contains(r) { parts.push(r.clone()); } } } } } }         (nets, parts)     };     // the inductor: named, else an L (not a ferrite) with a pad on a node or on a net the node reaches through series parts@@ -69,7 +76,7 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va     let mut found: Option<(String, String, String, Vec<String>)> = None; // (inductor, node, its far net, series parts)     for n in &nodes {         let (reach, parts) = through(n);-        let cand: Vec<&String> = match &named { Some(l) => refs.iter().filter(|r| *r == l).collect(), None => refs.iter().filter(|r| r.starts_with('L') && !series(b, r) && nets_of(r).len() == 2).collect() };+        let cand: Vec<&String> = match &named { Some(l) => refs.iter().filter(|r| *r == l).collect(), None => refs.iter().filter(|r| r.starts_with('L') && !series(b, spec, r) && nets_of(r).len() == 2).collect() };         if let Some(l) = cand.into_iter().find(|r| nets_of(r).iter().any(|x| reach.contains(x))) {             let ln = nets_of(l); let near_side = ln.iter().find(|x| reach.contains(*x)).cloned().unwrap(); let far = ln.into_iter().find(|x| *x != near_side).unwrap_or_default();             let used: Vec<String> = parts.into_iter().filter(|p| { let pn = nets_of(p); pn.contains(&near_side) || (near_side != *n && pn.contains(n)) }).collect();@@ -84,13 +91,23 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va     let leg = |n: &str| -> Vec<String> { spec.sources.get(n).cloned().filter(|v| !v.is_empty()).unwrap_or_else(|| refs.iter().filter(|r| (r.starts_with('Q') || r.starts_with('U')) && nets_of(r).contains(&n.to_string())).cloned().collect()) };     let leg_a = leg(&node_a); if leg_a.is_empty() { return unsupported(format!("no switch on {node_a}: give spec sources.{node_a}")); }     // a leg's rail: the highest-voltage net its parts reach besides the node and ground-    let leg_rail = |parts: &[String], node: &str| -> Option<String> { let mut c: Vec<String> = parts.iter().flat_map(|p| nets_of(p)).filter(|n| n != node && *n != gnd && rail(n).is_some()).collect(); c.sort(); c.dedup(); c.sort_by(|a, z| rail(z).partial_cmp(&rail(a)).unwrap()); c.into_iter().next() };+    let leg_rail = |parts: &[String], node: &str| -> Option<String> { let mut c: Vec<String> = parts.iter().flat_map(|p| nets_of(p)).filter(|n| n != node && !grounds.contains(n) && rail(n).is_some()).collect(); c.sort(); c.dedup(); c.sort_by(|a, z| rail(z).partial_cmp(&rail(a)).unwrap()); c.into_iter().next() };     let Some(in_net) = leg_rail(&leg_a, &node_a) else { return unsupported(format!("{}'s parts reach no rail with a known voltage: give its input in spec voltages", node_a)) };     let (topology, leg_b, out_net) = match &node_b {         Some(nb) => { let lb = leg(nb); let Some(o) = leg_rail(&lb, nb) else { return unsupported(format!("{nb}'s parts reach no rail with a known voltage: give the output in spec voltages")) }; ("buck-boost (4-switch)", lb, o) }         None => { // a buck's output: the inductor's far net, or the rail it reaches through series parts             let (reach, _) = through(&far); let o = if rail(&far).is_some() { far.clone() } else { reach.into_iter().find(|n| rail(n).is_some()).unwrap_or(far.clone()) }; ("buck", vec![], o) }     };+    // the power ground (issue 24): the spec's, else the ground net the switch legs return to (a low-side switch's+    // source), ties broken by the capacitors from the input and output to it; else the first ground net+    let leg_parts: Vec<String> = leg_a.iter().chain(leg_b.iter()).cloned().collect();+    let score = |g: &String| -> (usize, usize) { (leg_parts.iter().map(|p| pads_of(p, g).len()).sum(), refs.iter().filter(|r| r.starts_with('C') && { let n = nets_of(r); n.contains(g) && (n.contains(&in_net) || n.contains(&out_net)) }).count()) };+    let named_gnd = spec.converter.as_ref().and_then(|c| c.ground.clone());+    let (gnd, gnd_from) = match &named_gnd {+        Some(g) => (g.clone(), "spec converter.ground"),+        None => { let best = grounds.iter().max_by_key(|g| score(g)).cloned().unwrap(); if score(&best).0 > 0 { (best, "switch legs") } else if score(&best).1 > 0 { (best, "input and output capacitors") } else { (grounds[0].clone(), "first ground net") } }+    };+    if !f.net_names.contains(&gnd) { return unsupported(format!("spec converter.ground {gnd} is not a net on this board")); }     if node_b.is_none() && rail(&out_net).is_none() { return unsupported(format!("{lref}'s far side, {out_net}, has no known voltage: if {out_net} is a second switch node (a 4-switch buck-boost), add it to spec switching with its switches in spec sources; otherwise give the output's voltage in spec voltages")); }     let (Some(l), Some(vin), Some(vout)) = (b.values.get(&lref).and_then(|v| parse_value(v, 'H')), rail(&in_net), rail(&out_net)) else { return unsupported(format!("{lref}'s inductance, {in_net}'s or {out_net}'s voltage is unknown (part Value, spec voltages)")) };     let Some(iout) = spec.loads.get(&out_net).map(|x| x.amps) else { return unsupported(format!("no load on {out_net}: give spec loads.{out_net}")) };@@ -175,7 +192,7 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va             "emissions": em.as_ref().map(|(m, fr, sets)| json!({"worstMarginDb": (m * 10.0).round() / 10.0, "atMHz": (fr / 1e6).round(), "limit": format!("{label}, 3 m"), "model": "Ott differential-mode loop; no cables", "allLimits": sets}))});         if top.is_none() {             top = Some(json!({"topology": topology, "switchNodes": if let Some(nb) = &node_b { json!([node_a, nb]) } else { json!([node_a]) }, "seriesParts": via.iter().map(|r| json!({"ref": r, "value": b.values.get(r)})).collect::<Vec<_>>(),-                "inCaps": capj(&cin_m), "outCaps": capj(&cout_m), "switchNet": m.node, "switch": m.leg.first(), "switches": m.leg, "inductor": lref, "inNet": in_net, "outNet": out_net, "vin": m.vin, "vout": vout, "iout": iout, "fswHz": fsw, "riseNs": tr * 1e9,+                "ground": gnd, "groundFrom": gnd_from, "groundNets": grounds, "inCaps": capj(&cin_m), "outCaps": capj(&cout_m), "switchNet": m.node, "switch": m.leg.first(), "switches": m.leg, "inductor": lref, "inNet": in_net, "outNet": out_net, "vin": m.vin, "vout": vout, "iout": iout, "fswHz": fsw, "riseNs": tr * 1e9,                 "duty": m.duty, "rippleA": m.di, "rippleRatio": ratio, "lUh": l * 1e6, "cinUf": ccin * 1e6, "coutUf": ccout * 1e6, "rippleInMv": m.rip_in * 1e3, "rippleOutMv": m.rip_out * 1e3, "inputPulsed": m.caps_in,                 "hotLoops": rec["hotLoops"].clone(), "hotLoop": rec["hotLoop"].clone(), "idealMm2": rec["idealMm2"].clone(), "emissions": rec["emissions"].clone()}));         }@@ -188,7 +205,7 @@ pub fn review(f: &Fields, b: &Board, spec: &Spec, issues: &mut Vec<Issue>) -> Va #[cfg(test)] mod tests {     use super::*;     #[test] fn resistor_values() {-        for (s, v) in [("3m", 0.003), ("3mR", 0.003), ("0R003", 0.003), ("0.003", 0.003), ("0", 0.0), ("10k", 10e3), ("4R7", 4.7), ("4k7", 4700.0), ("100", 100.0), ("3 mΩ", 0.003)] { assert!((ohms(s).unwrap() - v).abs() < 1e-12, "{s}"); }+        for (s, v) in [("3m", 0.003), ("3mR", 0.003), ("0R003", 0.003), ("0.003", 0.003), ("0", 0.0), ("10k", 10e3), ("4R7", 4.7), ("4k7", 4700.0), ("100", 100.0), ("3 mΩ", 0.003), ("3m 1W", 0.003), ("3mR 1%", 0.003), ("0R003 1W", 0.003), ("3.0 0.75W", 3.0), ("10k 0402", 10e3), ("0.003 1/2W", 0.003), ("10k 1% 50ppm", 10e3)] { assert!((ohms(s).unwrap() - v).abs() < 1e-12, "{s}"); }         assert!(ohms("DNP").is_none());     } }