Adom Fields

@@ -77,6 +77,12 @@ pub struct Spec {     /// the current solve's iteration budget per net (PR 5); the convergence target is unchanged     #[serde(default = "d20000")] pub dcMaxIterations: usize,     /// set by analyze: εr per slot gap (from the board's stackup), the real gaps as given, and the real copper layers+    /// solve the current again with copper's resistance at the solved temperature (crate: two passes; +0.393 %/°C)+    #[serde(default)] pub electroThermal: Option<bool>,+    /// a heating transient: {durationS, steps (24), powerScale (1: every heat source × this during the pulse), fromSteady (false: from cold)}+    #[serde(default)] pub transient: Option<Transient>,+    /// the previous pass's temperature rise per layer slot, for the electro-thermal pass+    #[serde(skip)] pub cu_rise: Option<Vec<Grid>>,     #[serde(skip)] pub er_slots: Option<Vec<f64>>, #[serde(skip)] pub real_gaps: Vec<f64>, #[serde(skip)] pub real_copper: Vec<String>, } fn d20000() -> usize { 20000 }@@ -109,6 +115,10 @@ pub struct Fields {     pub t_moving: Vec<Grid>,     pub nets: Vec<NetResult>, pub chips: Vec<ChipResult>, pub issues: Vec<Issue>,     pub joule_total: f64, pub tab_total: f64,+    /// the Joule loss per cell and layer slot, W (for the electro-thermal estimate)+    pub joule_map: Vec<Grid>,+    /// the heating transient (spec transient)+    pub transient: Value,     pub heatsinks: Vec<Value>,     pub package_cooling: Vec<Value>,     /// the solid bodies' summary (fields.json `solids`) and their cells for the viewer (solids.json)@@ -150,8 +160,11 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu         let mut sys = System::new(nl, h, w);         for (a, k) in live.iter().enumerate() {             let f = &fr[*k];-            for r in 0..h { for c in 0..w - 1 { sys.gx[a][r * (w - 1) + c] = SIGMA * t_cu[*k] * harm(f.at(r, c) as f64, f.at(r, c + 1) as f64); } }-            for r in 0..h - 1 { for c in 0..w { sys.gy[a][r * w + c] = SIGMA * t_cu[*k] * harm(f.at(r, c) as f64, f.at(r + 1, c) as f64); } }+            // copper's conductivity at its solved temperature on the electro-thermal pass (20 °C reference, 0.393 %/°C)+            let amb = spec.ambientC.unwrap_or(25.0);+            let sg = |i: usize| -> f64 { match &spec.cu_rise { Some(t) => SIGMA / (1.0 + 0.00393 * (amb + t[*k].v[i] as f64 - 20.0)), None => SIGMA } };+            for r in 0..h { for c in 0..w - 1 { let i = r * w + c; sys.gx[a][r * (w - 1) + c] = 0.5 * (sg(i) + sg(i + 1)) * t_cu[*k] * harm(f.at(r, c) as f64, f.at(r, c + 1) as f64); } }+            for r in 0..h - 1 { for c in 0..w { let i = r * w + c; sys.gy[a][r * w + c] = 0.5 * (sg(i) + sg(i + w)) * t_cu[*k] * harm(f.at(r, c) as f64, f.at(r + 1, c) as f64); } }             for i in 0..n { sys.leak[a][i] = if f.v[i] > 0.0 { 1e-9 } else { 1.0 }; }         }         // every via and plated through-hole pad barrel on this net joins its live layers, each span by its real length@@ -346,8 +359,9 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu                     let mag = (cx[i] * cx[i] + cy[i] * cy[i]).sqrt();                     let jj = mag / (d * fi.max(0.25) * t_cu[*k]);                     grids[*k].v[i] = jj as f32;-                    joule += jj * jj / SIGMA * fi * d * d * t_cu[*k];-                    p_joule[*k].v[i] += (jj * jj / SIGMA * fi * d * d * t_cu[*k]) as f32;+                    let sig = match &spec.cu_rise { Some(t) => SIGMA / (1.0 + 0.00393 * (spec.ambientC.unwrap_or(25.0) + t[*k].v[i] as f64 - 20.0)), None => SIGMA };+                    joule += jj * jj / sig * fi * d * d * t_cu[*k];+                    p_joule[*k].v[i] += (jj * jj / sig * fi * d * d * t_cu[*k]) as f32;                 }             }             // the reported peak is the modeled maximum, before the display clip (PR 8: a narrow hot spot over the limit@@ -445,6 +459,37 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu     for (p, nodes) in spec.packageCooling.iter().zip(&packages_still) { q_rhs[nodes.junction] = spec.hot.get(&p.reference).map_or(0.0, |h| h.watts); }     let (tv, it, res) = sys_still.solve(&q_rhs, 1e-7, 8000);     log(&format!("heat, still air: {it} iterations, residual {res:.1e}"));+    // ---- a heating transient (spec transient): every node's heat capacity, implicit Euler on geometric time steps --------+    let transient = match &spec.transient { None => Value::Null, Some(tr) => {+        let (cu_c, fr_c) = (3.45e-3, 1.85e-3); // J/(mm³ K): copper, FR4+        let nb = nl * n; let mut cap = vec![0.0f64; sys_still.n()];+        for k in 0..nl { for i in 0..n { cap[k * n + i] = (frac[k].v[i] as f64 * t_cu[k] * cu_c + share[k] * fr_c) * d * d; } }+        for c in cap.iter_mut().skip(nb) { *c = 0.05; } // lumped package and heatsink-block nodes: a small default (J/K)+        if let (Some(sd), Some(a)) = (&spec.solids, &solid_still) { for c in &a.cells { let k = sd.bodies[c.1].conductivity_w_mk; let rc = if k > 300.0 { 3.45e-3 } else if k >= 180.0 { 2.42e-3 } else if k >= 100.0 { 1.66e-3 } else if k >= 20.0 { 2.4e-3 } else { 1.7e-3 }; cap[c.0] = (c.2[3] - c.2[0]) * (c.2[4] - c.2[1]) * (c.2[5] - c.2[2]) * rc; } }+        let steps = tr.steps.unwrap_or(24).clamp(4, 200); let scale = tr.powerScale.unwrap_or(1.0);+        let t_end = tr.durationS.max(1e-3); let t0 = (t_end / 1e4).max(1e-4); let ratio = (t_end / t0).powf(1.0 / (steps as f64 - 1.0));+        let mut temp = if tr.fromSteady == Some(true) { tv.clone() } else { vec![0.0; sys_still.n()] };+        let (mut tprev, mut rows) = (0.0f64, Vec::new());+        let chip_cells: Vec<(String, usize)> = chip_pos.iter().filter_map(|(rf, x, y, _, _)| cell(*x, *y).map(|(r, c)| (rf.clone(), r * w + c))).collect();+        for s in 0..steps {+            let tnow = t0 * ratio.powi(s as i32); let dt = (tnow - tprev).max(1e-6); tprev = tnow;+            let mut sy = sys_still.clone();+            for k in 0..nl { for i in 0..n { sy.leak[k][i] += cap[k * n + i] / dt; } }+            for j in nb..sy.n() { sy.extra_leak[j - nb] += cap[j] / dt; }+            let rhs: Vec<f64> = (0..sy.n()).map(|j| q_rhs[j] * scale + cap[j] / dt * temp[j]).collect();+            let (tt, _, _) = sy.solve(&rhs, 1e-7, 4000); temp = tt;+            let board_peak = (0..nb).map(|j| temp[j]).fold(0.0f64, f64::max);+            let mut chips_t = serde_json::Map::new();+            for (rf, i) in &chip_cells { let mut v = temp[*i]; for (p, nd) in spec.packageCooling.iter().zip(&packages_still) { if p.reference == *rf { v = v.max(temp[nd.junction]); } } if let (Some(sd), Some(a)) = (&spec.solids, &solid_still) { for c in &a.cells { if sd.bodies[c.1].heat_of.as_deref() == Some(rf.as_str()) { v = v.max(temp[c.0]); } } } chips_t.insert(rf.clone(), json!((v * 10.0).round() / 10.0)); }+            rows.push(json!({"tS": (tnow * 1e5).round() / 1e5, "boardPeakC": (board_peak * 10.0).round() / 10.0, "chips": chips_t}));+        }+        // each part's time to 63 % of where the pulse takes it (its thermal time constant, as seen from this pulse)+        // each part's thermal time constant: the time to 63 % of its steady-state rise at this power (null: beyond the window)+        let steady_of = |rf: &str, i: usize| -> f64 { let mut v = tv[i]; for (p, nd) in spec.packageCooling.iter().zip(&packages_still) { if p.reference == rf { v = v.max(tv[nd.junction]); } } if let (Some(sd), Some(a)) = (&spec.solids, &solid_still) { for c in &a.cells { if sd.bodies[c.1].heat_of.as_deref() == Some(rf) { v = v.max(tv[c.0]); } } } v * scale };+        let tau: serde_json::Map<String, Value> = chip_cells.iter().map(|(rf, i)| { let target = 0.632 * steady_of(rf, *i); let t63 = rows.iter().find(|r| r["chips"][rf].as_f64().unwrap_or(0.0) >= target).and_then(|r| r["tS"].as_f64()); (rf.clone(), json!({"t63S": t63, "steadyC": (steady_of(rf, *i) * 10.0).round() / 10.0})) }).collect();+        log(&format!("heat transient: {steps} steps to {t_end} s at {scale}× power"));+        json!({"durationS": t_end, "powerScale": scale, "fromSteady": tr.fromSteady == Some(true), "model": "implicit Euler on the still-air heat system; copper 3.45 and FR4 1.85 J/cm³K, solid bodies by material, lumped package nodes 0.05 J/K", "steps": rows, "t63S": tau})+    } };     let (sys_mov, _, packages_moving, solid_moving) = build(1.0);     let (tm, it2, res2) = sys_mov.solve(&q_rhs, 1e-7, 8000);     log(&format!("heat, moving air: {it2} iterations"));@@ -560,7 +605,7 @@ pub fn analyze(b: &Board, spec: &Spec, pitch: f64, neck: f64, log: &mut dyn FnMu         }     }     let _ = (tab_total, joule_total);-    Fields { package_cooling, solids, solids_cells, fan, flow, net_ids, net_names, signals:crate::signals::analyze(b,&ras,&spec.signals,&spec.copperUmByLayer,spec.copperUm), heatsinks, heat_residual:res, heat_moving_residual:res2, d, h, w, x0: b.x0, y0: b.y0, frac, j_net, cu_net, j_all, q, t, t_moving, nets, chips, issues, joule_total: (joule_total * 1000.0).round() / 1000.0, tab_total }+    Fields { transient, joule_map: p_joule.clone(), package_cooling, solids, solids_cells, fan, flow, net_ids, net_names, signals:crate::signals::analyze(b,&ras,&spec.signals,&spec.copperUmByLayer,spec.copperUm), heatsinks, heat_residual:res, heat_moving_residual:res2, d, h, w, x0: b.x0, y0: b.y0, frac, j_net, cu_net, j_all, q, t, t_moving, nets, chips, issues, joule_total: (joule_total * 1000.0).round() / 1000.0, tab_total } }  /// The summary the app and the page read.@@ -581,7 +626,7 @@ pub fn summary(f: &Fields, b: &Board, spec: &Spec, textures: &[String]) -> Value         "barrelCoupling": {"model": "distributed-plated-wall", "platingUm": 25, "drillVoidsRemoved": true, "quadrature": "uniform-perimeter-32-samples-per-cell-minimum-128", "unresolvedWall": "nearest cells with copper on both faces (fallback: true on the connection)"},         "peakJDefinition": {"statistic": "unclipped-cell-maximum", "minimumCopperFraction": 0.25, "displayPercentile": 0.995, "rounded": false},         "terminalAssignments": spec.loads.iter().map(|(net, load)| (net.clone(), json!({"mode": if load.terminals.is_some() {"explicit"} else {"heuristic"}, "pins": load.terminals}))).collect::<BTreeMap<_,_>>(),-        "signals": f.signals, "heatsinks": f.heatsinks, "packageCooling": f.package_cooling, "solids": f.solids, "thermalConvergence":{"stillResidual":f.heat_residual,"movingResidual":f.heat_moving_residual},+        "signals": f.signals, "heatsinks": f.heatsinks, "packageCooling": f.package_cooling, "solids": f.solids, "transient": f.transient, "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)},@@ -640,6 +685,7 @@ impl Clock {     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 Transient { pub durationS: f64, #[serde(default)] pub steps: Option<usize>, #[serde(default)] pub powerScale: Option<f64>, #[serde(default)] pub fromSteady: Option<bool> } #[derive(Deserialize, Default, Clone)] pub struct RfCfg { #[serde(default)] pub cbcPf: Option<f64>, #[serde(default)] pub cbePf: Option<f64>, #[serde(default)] pub antennaOhm: Option<f64>, #[serde(default)] pub loLeakLimitDbm: Option<f64>, #[serde(default)] pub stageIsolationDb: Option<f64>, #[serde(default)] pub usbHighSpeed: Option<bool>, #[serde(default)] pub limiter: Option<bool>, #[serde(default)] pub noSolderMask: Option<bool> } #[derive(Deserialize, Clone, Debug)] pub struct Band { pub minHz: f64, pub maxHz: f64, #[serde(default)] pub ifHz: Option<f64>, #[serde(default)] pub lowSideLo: bool }