Surf dems2 (#294)

* Expand surface sweep reporting and analysis

* Improve surface sweep plotting and docs

* Refactor surface sweep reporting: unified matplotlib plots, multi-shard merge, PDF report, FSS threshold fit

- Kill hand-rolled SVG plot writers; use matplotlib for both SVG and PDF via unified figure builders
- Split 340-line main() into focused helpers (resolve_backends, duration schedule, config banner, sweep loop, post-analysis)
- Add fit-quality warnings (fit_rms >= fit_epsilon), gate threshold fits on >=3 distances
- Fix _estimate_threshold to use per-round rate crossing (was using projected-over-d-rounds which underestimates)
- Add multi-shard merge via merge_sweep_shards(): accumulate shots across runs, re-fit from merged points
- Add JSON-only replay: --render-plots regenerates all plots from saved JSON without rerunning simulation
- Add multi-page PDF report (--save-report-pdf / --report-pdf) with styled cover, section dividers, appendix
- Wire in Wang-Harrington-Preskill FSS threshold fit from pecos.analysis.threshold_curve (arXiv:quant-ph/0207088)
- Annotate per-round plots with below-threshold power-law exponents and threshold markers with uncertainty bands
- Per-basis curves now use log-log axes; consistent color palette across all plot types
- Fix dashboard rebuild ordering in surface_sweep_report.py
- Add 28 unit tests covering fit math, merge semantics, JSON round-trip, PDF generation, plot ordering

* Fix grug-scout review issues: heterogeneous merge safety, strict zips, type clarity

* Fix clippy map_unwrap_or in pecos-random time_seed

* Apply clippy 1.95 auto-fixes across workspace

* Reformat after clippy 1.95 auto-fixes

* Fix remaining clippy 1.95 lints: checked_div, while_let_loop, sort_by_key, counter_loop

* Update lockfiles

Author: ciaranra

Cargo.lock

@@ -50,7 +50,7 @@ pub fn download_cached(info: &DownloadInfo) -> Result<Vec<u8>> {
     log::info!("Downloading {} (will be cached)", info.name);
 
     let client = reqwest::blocking::Client::builder()
-        .timeout(std::time::Duration::from_secs(300))
+        .timeout(std::time::Duration::from_mins(5))
         .connect_timeout(std::time::Duration::from_secs(30))
         .build()
         .map_err(|e| Error::Http(e.to_string()))?;

crates/pecos-build/src/download.rs

@@ -191,7 +191,7 @@ fn download_and_verify_with_retry(url: &str, dest: &PathBuf, archive_name: &str)
         }
 
         // Check for empty downloads (CDN/rate limit issues)
-        let file_size = fs::metadata(dest).map(|m| m.len()).unwrap_or(0);
+        let file_size = fs::metadata(dest).map_or(0, |m| m.len());
         if file_size == 0 {
             if attempt < MAX_RETRIES {
                 eprintln!("Download returned empty file (possible CDN issue)");

crates/pecos-build/src/llvm/installer.rs

@@ -168,8 +168,7 @@ fn is_tool_available(tool: &str) -> bool {
     Command::new(tool)
         .args(["--version"])
         .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false)
+        .is_ok_and(|o| o.status.success())
 }
 
 /// Run a cargo command and return success status

crates/pecos-cli/src/cli/rust_cmd.rs

@@ -377,7 +377,7 @@ fn run_list() -> Result<()> {
         let installed_lib = dist_dir.join(&lib_filename);
 
         if installed_lib.exists() {
-            let size = installed_lib.metadata().map(|m| m.len()).unwrap_or(0);
+            let size = installed_lib.metadata().map_or(0, |m| m.len());
             println!(" (installed, {size} bytes)");
         } else {
             println!(" (not installed)");

crates/pecos-cli/src/cli/selene_cmd.rs

@@ -1303,13 +1303,13 @@ impl CircuitDiagram {
             let fill_hex = t.fill.strip_prefix('#').unwrap_or(&t.fill);
             let stroke_hex = t.stroke.strip_prefix('#').unwrap_or(&t.stroke);
             let text_hex = t.text.strip_prefix('#').unwrap_or(&t.text);
-            writeln!(out, "  \\definecolor{{{name}Fill}}{{HTML}}{{{fill_hex}}}",).unwrap();
+            writeln!(out, "  \\definecolor{{{name}Fill}}{{HTML}}{{{fill_hex}}}").unwrap();
             writeln!(
                 out,
                 "  \\definecolor{{{name}Stroke}}{{HTML}}{{{stroke_hex}}}",
             )
             .unwrap();
-            writeln!(out, "  \\definecolor{{{name}Text}}{{HTML}}{{{text_hex}}}",).unwrap();
+            writeln!(out, "  \\definecolor{{{name}Text}}{{HTML}}{{{text_hex}}}").unwrap();
         }
 
         // Styles.
@@ -1537,7 +1537,7 @@ impl CircuitDiagram {
 
                 match cell {
                     DiagramCell::Wire => {
-                        writeln!(out, "    {node_id} [label=\"\", shape=point, width=0.01];",)
+                        writeln!(out, "    {node_id} [label=\"\", shape=point, width=0.01];")
                             .unwrap();
                     }
                     DiagramCell::Gate(s, family) => {
@@ -1569,7 +1569,7 @@ impl CircuitDiagram {
                         .unwrap();
                     }
                     DiagramCell::Crossing | DiagramCell::Connector => {
-                        writeln!(out, "    {node_id} [label=\"\", shape=point, width=0.05];",)
+                        writeln!(out, "    {node_id} [label=\"\", shape=point, width=0.05];")
                             .unwrap();
                     }
                     DiagramCell::LabeledConnector(s) => {

crates/pecos-core/src/circuit_diagram.rs

@@ -211,9 +211,9 @@ pub fn dump_batch_raw(data: &[u8]) -> String {
                                 qubits_offset + gate_header.num_qubits as usize * size_of::<u32>();
 
                             match gate_header.gate_type {
-                                32 => {
+                                32
                                     // RZ
-                                    if params_offset + size_of::<f64>() <= payload.len() {
+                                    if params_offset + size_of::<f64>() <= payload.len() => {
                                         let theta = f64::from_le_bytes([
                                             payload[params_offset],
                                             payload[params_offset + 1],
@@ -227,10 +227,9 @@ pub fn dump_batch_raw(data: &[u8]) -> String {
 
                                         writeln!(output, "    Theta: {theta}").unwrap();
                                     }
-                                }
-                                36 => {
+                                36
                                     // R1XY
-                                    if params_offset + 2 * size_of::<f64>() <= payload.len() {
+                                    if params_offset + 2 * size_of::<f64>() <= payload.len() => {
                                         let phi = f64::from_le_bytes([
                                             payload[params_offset],
                                             payload[params_offset + 1],
@@ -256,7 +255,6 @@ pub fn dump_batch_raw(data: &[u8]) -> String {
                                         writeln!(output, "    Phi: {phi}").unwrap();
                                         writeln!(output, "    Theta: {theta}").unwrap();
                                     }
-                                }
                                 _ => {}
                             }
                         }

crates/pecos-engines/src/byte_message/debug.rs

@@ -196,9 +196,8 @@ impl SimBuilder {
     /// Use automatic worker count based on available CPUs
     #[must_use]
     pub fn auto_workers(mut self) -> Self {
-        self.config.workers = std::thread::available_parallelism()
-            .map(std::num::NonZero::get)
-            .unwrap_or(4);
+        self.config.workers =
+            std::thread::available_parallelism().map_or(4, std::num::NonZero::get);
         self
     }
 

crates/pecos-engines/src/sim_builder.rs

@@ -117,7 +117,7 @@ fn compare_messages(msg1: &ByteMessage, msg2: &ByteMessage) -> bool {
     let results_left = msg1.outcomes().unwrap_or_default();
     let results_right = msg2.outcomes().unwrap_or_default();
     if quantum_ops_left != quantum_ops_right {
-        eprintln!("Quantum operations differ: {quantum_ops_left:?} vs {quantum_ops_right:?}",);
+        eprintln!("Quantum operations differ: {quantum_ops_left:?} vs {quantum_ops_right:?}");
         return false;
     }
     if results_left != results_right {

crates/pecos-engines/tests/noise_determinism.rs

@@ -2351,7 +2351,7 @@ mod tests {
             .expect("Failed to generate commands");
         // Empty circuits should produce empty or minimal messages
         let is_empty = msg.is_empty().unwrap_or(true);
-        let has_no_ops = msg.quantum_ops().map(|ops| ops.is_empty()).unwrap_or(true);
+        let has_no_ops = msg.quantum_ops().map_or(true, |ops| ops.is_empty());
         assert!(is_empty || has_no_ops);
     }