Fix dedup large-domain math, add --host flag, add multi-rank assembly tests

#3: Remove max(0,...) clamp from _dedup decimals formula so that
large-extent domains (>1e12) use negative decimal rounding (numpy
np.round supports this) instead of collapsing all coordinates to 0.

#6: Add TestMultiRankAssembly with two synthetic tests:
- two_rank_1d_dedup: verifies ghost-cell overlap is removed and
  the assembled variable array has the correct 4-cell result
- large_extent_dedup: exercises the negative-decimals code path
  (scale=1e7) to confirm deduplication works at large domain extents

#8: Add --host argument (default 127.0.0.1) to the interactive Dash
server so users can bind to 0.0.0.0 for direct HPC access without SSH
tunneling. Only show the SSH tunnel hint when host is localhost.

Addresses Claude Code review findings on PR #1233.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: sbryngelson

toolchain/mfc/cli/commands.py

@@ -1031,6 +1031,12 @@
             default=8050,
             metavar="PORT",
         ),
+        Argument(
+            name="host",
+            help="Host address for the interactive web server (default: 127.0.0.1).",
+            default="127.0.0.1",
+            metavar="HOST",
+        ),
         Argument(
             name="tui",
             help="Launch an interactive terminal UI (1D/2D only). Works over SSH with no browser.",

toolchain/mfc/viz/interactive.py

@@ -206,6 +206,7 @@ def run_interactive(  # pylint: disable=too-many-locals,too-many-statements
         steps: List[int],
         read_func: Callable,
         port: int = 8050,
+        host: str = '127.0.0.1',
 ):
     """Launch the interactive Dash visualization server."""
     app = Dash(
@@ -613,7 +614,8 @@ def _tf(arr): return arr
 
     # ------------------------------------------------------------------
     cons.print(f'\n[bold green]Interactive viz server:[/bold green] '
-               f'[bold]http://localhost:{port}[/bold]')
-    cons.print(f'[dim]SSH tunnel:  ssh -L {port}:localhost:{port} <hostname>[/dim]')
+               f'[bold]http://{host}:{port}[/bold]')
+    if host in ('127.0.0.1', 'localhost'):
+        cons.print(f'[dim]SSH tunnel:  ssh -L {port}:localhost:{port} <hostname>[/dim]')
     cons.print('[dim]Ctrl+C to stop.[/dim]\n')
-    app.run(debug=False, port=port, host='127.0.0.1')
+    app.run(debug=False, port=port, host=host)

toolchain/mfc/viz/reader.py

@@ -318,10 +318,12 @@ def assemble_from_proc_data(  # pylint: disable=too-many-locals,too-many-stateme
     # Build unique sorted global coordinate arrays (handles ghost overlap).
     # Use scale-aware rounding: 12 significant digits relative to the domain
     # extent, so precision is preserved for both micro-scale and large domains.
+    # np.round supports negative decimals (rounds to tens, hundreds, etc.),
+    # which is correct for large-extent domains (e.g. extent > 1e12).
     def _dedup(arr):
         extent = arr.max() - arr.min()
         if extent > 0:
-            decimals = max(0, int(np.ceil(-np.log10(extent))) + 12)
+            decimals = int(np.ceil(-np.log10(extent))) + 12
         else:
             decimals = 12
         return np.unique(np.round(arr, decimals)), decimals

toolchain/mfc/viz/test_viz.py

@@ -531,5 +531,66 @@ def test_render_2d_log_scale(self):
             os.unlink(out)
 
 
+# ---------------------------------------------------------------------------
+# Tests: multi-rank assembly (ghost-cell deduplication)
+# ---------------------------------------------------------------------------
+
+class TestMultiRankAssembly(unittest.TestCase):
+    """Test assemble_from_proc_data with synthetic multi-processor data."""
+
+    def _make_proc(self, x_cb, pres):
+        """Build a minimal 1D ProcessorData from boundary coordinates."""
+        import numpy as np
+        from .reader import ProcessorData
+        return ProcessorData(
+            m=len(x_cb) - 1,
+            n=0,
+            p=0,
+            x_cb=np.array(x_cb, dtype=np.float64),
+            y_cb=np.array([0.0]),
+            z_cb=np.array([0.0]),
+            variables={'pres': np.array(pres, dtype=np.float64)},
+        )
+
+    def test_two_rank_1d_dedup(self):
+        """Two processors with one overlapping ghost cell assemble correctly."""
+        import numpy as np
+        from .reader import assemble_from_proc_data
+        # Domain: 4 cells with centers at 0.125, 0.375, 0.625, 0.875
+        # Proc 0 sees cells 0-2 (center 0.625 is ghost from proc 1)
+        # Proc 1 sees cells 1-3 (center 0.375 is ghost from proc 0)
+        p0 = self._make_proc([0.00, 0.25, 0.50, 0.75],
+                             [1.0, 2.0, 3.0])   # centers: 0.125, 0.375, 0.625
+        p1 = self._make_proc([0.25, 0.50, 0.75, 1.00],
+                             [2.0, 3.0, 4.0])   # centers: 0.375, 0.625, 0.875
+
+        result = assemble_from_proc_data([(0, p0), (1, p1)])
+
+        self.assertEqual(result.ndim, 1)
+        self.assertEqual(len(result.x_cc), 4)
+        np.testing.assert_allclose(result.x_cc, [0.125, 0.375, 0.625, 0.875])
+        np.testing.assert_allclose(result.variables['pres'], [1.0, 2.0, 3.0, 4.0])
+
+    def test_large_extent_dedup(self):
+        """Deduplication works correctly for large-extent domains (>1e6)."""
+        import numpy as np
+        from .reader import assemble_from_proc_data
+        # Scale up by 1e7 to exercise the negative-decimals code path
+        scale = 1e7
+        p0 = self._make_proc(
+            [0.00 * scale, 0.25 * scale, 0.50 * scale, 0.75 * scale],
+            [1.0, 2.0, 3.0],
+        )
+        p1 = self._make_proc(
+            [0.25 * scale, 0.50 * scale, 0.75 * scale, 1.00 * scale],
+            [2.0, 3.0, 4.0],
+        )
+        result = assemble_from_proc_data([(0, p0), (1, p1)])
+        self.assertEqual(len(result.x_cc), 4)
+        np.testing.assert_allclose(
+            result.variables['pres'], [1.0, 2.0, 3.0, 4.0]
+        )
+
+
 if __name__ == "__main__":
     unittest.main()

toolchain/mfc/viz/viz.py

@@ -259,9 +259,11 @@ def read_step(step):
     if interactive:
         from .interactive import run_interactive  # pylint: disable=import-outside-toplevel
         port = ARG('port')
+        host = ARG('host')
         # Default to first available variable if --var was not specified
         init_var = varname if varname in avail else (avail[0] if avail else None)
-        run_interactive(init_var, requested_steps, read_step, port=int(port))
+        run_interactive(init_var, requested_steps, read_step,
+                        port=int(port), host=str(host))
         return
 
     # Validate colormap before any rendering