[fix.fields.rho.D8+] the box was sized for the default contour and the slider walks below it

Ivan sent a zoomed screenshot: flat cut faces on the blue and red lobes.

I had a plausible story ready — the DB serves cubes on METHOD currency, not
producer currency, so yesterday's cubes computed before this morning's
adaptive-box fix would still be served under an unchanged 'gasteiger' label.
Good story. I pulled the oldest cached cube and measured it instead of acting
on it: wall 3.75 kcal/mol against a 10.00 contour. It closes cleanly. The story
was wrong and would have had me invalidating a cache for nothing.

THE REAL CAUSE is a hole I opened this morning. The backend grows the box until
the contour closes — at the FIXED contour. The UI slider then multiplies that
contour by 10^[-1,1]. So the box is sized for 10 kcal/mol and the slider can
ask for 1.0, which is below the 3.75 the field still has at the box wall, and
the surface exits through the side and is drawn as a flat face.

Computed exactly: truncation begins at slider -0.43. THE BOTTOM 29% OF THE
SLIDER PRODUCED CUT-OFF LOBES. Not an edge case — a third of the control.

The adaptive box was the right idea aimed one value too high. It now sizes for
the LOWEST contour the slider can reach (iso x 0.1). Classical fields cost
~0.1 s so this is free; measured after the change, pad grows 4 -> 6-10 A and
the wall lands under the floor contour on both fields for both molecules, so
the whole slider range closes.

The quantum grid belongs to pyscf's cubegen and cannot be grown the same way,
so those report instead: the readout recomputes closure against the CURRENT
slider position rather than the value the box was sized for, and says "OPEN
SURFACE — field reaches X at the box edge, so the lobes are cut off."

CACHE: I deleted the 22 mep rows by hand. The geometry of the cube changed
while its METHOD label did not, and the servable view keys on method — which
is correct for its purpose (an edit to a log line must not empty the cache) but
has no category for "same method, different output geometry". Worth raising
with the session that owns that view; grid parameters belong in servability.

warm-fields.sh: precompute every field for every bundled molecule THROUGH THE
APP. The durable cache is keyed on sha256(molfile) and the app's molfile is
reconstructed by mol* from scene loci, so warming with molfiles I generate from
SMILES writes rows the app will never hit. Driving the real UI makes every key
a key the app will ask for, by construction.

Author: ivanicu

backend/field_server.py

@@ -699,6 +699,17 @@ def grid_spacing_meta(lo, hi, dims, requested: float) -> dict:
     'mep_qm': 10.0,     # kcal/mol, converted to Ha/e for the cube
     'mlp': 0.25,        # Crippen/Fauchere units
 }
+# The UI slider multiplies the contour by 10^[-1,1]. The box must therefore be
+# sized for the LOWEST contour the slider can reach, not for the default one —
+# otherwise the bottom of the slider walks the contour below the box's wall and
+# the surface exits through the side, drawn as a flat face. Measured on 1CBS:
+# wall 3.75 against a default contour of 10, so truncation began at slider
+# -0.43 and the bottom 29% of the range produced cut-off lobes.
+#
+# Classical fields cost ~0.1 s, so sizing for the floor is free. The quantum
+# grid belongs to pyscf's cubegen and cannot be grown this way, so those report
+# the wall instead and the UI says the surface is open.
+ISO_SLIDER_FLOOR = 0.1
 PAD_START = 4.0
 PAD_MAX = 12.0
 PAD_STEP = 2.0
@@ -738,7 +749,7 @@ def field_mep(mol: Chem.Mol, spacing=0.4, pad=4.0):
         raise ValueError('all Gasteiger charges are zero — classical MEP would '
                          'be an empty picture; use mep_qm')
 
-    iso = FIXED_ISO['mep']
+    iso = FIXED_ISO['mep'] * ISO_SLIDER_FLOOR
 
     def evaluate(pad_a: float):
         lo = coords.min(axis=0) - pad_a
@@ -784,7 +795,8 @@ def evaluate(pad_a: float):
         'model_caveat': ('Gasteiger point charges: no lone-pair or sigma-hole '
                          'anisotropy, and ~0.4x the QM molecular dipole. A '
                          'qualitative map, not an interaction energy.'),
-        'iso_fixed': iso,
+        'iso_fixed': FIXED_ISO['mep'],
+        'iso_sized_for': round(iso, 4),
         'pad_used_angstrom': round(pad_used, 1),
         'wall_max': round(wall_max(v), 3),
         # False means the surface still runs off the edge of the grid and is
@@ -811,7 +823,7 @@ def field_mlp(mol: Chem.Mol, spacing=0.4, pad=4.0):
         raise ValueError('Crippen contributions undefined for this molecule')
     syms, coords = mol_atoms(mol)
 
-    iso = FIXED_ISO['mlp']
+    iso = FIXED_ISO['mlp'] * ISO_SLIDER_FLOOR
 
     def evaluate(pad_a: float):
         lo = coords.min(axis=0) - pad_a
@@ -844,7 +856,8 @@ def evaluate(pad_a: float):
         'total_logp': float(f.sum()),
         'dims': dims.tolist(), **grid_spacing_meta(lo, hi, dims, spacing),
         'vmin': float(v.min()), 'vmax': float(v.max()),
-        'iso_fixed': iso,
+        'iso_fixed': FIXED_ISO['mlp'],
+        'iso_sized_for': round(iso, 4),
         'pad_used_angstrom': round(pad_used, 1),
         'wall_max': round(wall_max(v), 4),
         'contour_closes_in_box': bool(clear),

scripts/warm-fields.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+# Precompute and CACHE every field for every bundled molecule, then screenshot.
+#
+#   scripts/warm-fields.sh [outdir]
+#
+# Ivan needs this for an interview: nothing may be slow or fail live.
+#
+# THE TRAP THIS FILE EXISTS TO AVOID. The durable cache is keyed on
+# sha256(molfile), and the molfile the app sends is reconstructed by mol* from
+# scene loci — not one I can generate from a SMILES. Warming the cache with my
+# own molfiles produces perfectly good rows that the app will never hit,
+# because the hashes differ. So the warmer drives the REAL APP: every cache key
+# it writes is a key the app will ask for, by construction.
+#
+# One browser session per MOLECULE (not per field): booting mol* costs ~20 s and
+# clicking six fields afterwards costs nothing, so per-field boots would have
+# multiplied the boot cost by six for no benefit.
+#
+# Both caches are warmed by one pass. The browser cache dies with the tab; the
+# DB cache is the one that matters tomorrow, and `[db] cached ...` in the
+# daemon log is the evidence it landed.
+set -u
+
+ROOT=/home/ivan/dirac
+OUT=${1:-/tmp/claude-1000/-home-ivan/ff9c7c07-88fe-4345-a0cc-59d17b42683e/scratchpad/warm}
+STAGE=$OUT/_app
+PORT=1347
+# Every bundled fixture. Most carry no small-molecule ligand and will report so
+# — that is a RESULT, not a failure, and the warmer records which is which so
+# nobody discovers it live in front of an interviewer.
+MOLECULES=${MOLECULES:-"1CBS 1XKK 4HHB 1EMA 1CRN 1GRM 1BNA 1TUP 2POR 7QPD"}
+# QM first. If the run is cut short, the expensive things are already cached and
+# the sub-second classical ones can be recomputed live without anyone noticing.
+FIELDS=${FIELDS:-"mep_qm homo lumo density mep mlp"}
+
+mkdir -p "$OUT"
+rm -rf "$STAGE"; cp -r "$ROOT/build/dirac" "$STAGE"
+( cd "$STAGE" && python3 -m http.server $PORT --bind 127.0.0.1 >/dev/null 2>&1 & echo $! > "$OUT/.srv" )
+sleep 1
+
+for MOL in $MOLECULES; do
+cat > "$STAGE/index.html.driver" <<EOF
+<script>
+(function () {
+  var MOL = '$MOL', FIELDS = '$FIELDS'.split(' ');
+  var txt = function (s) { var e = document.querySelector(s); return e ? e.textContent.trim() : ''; };
+  function wait(ms) { return new Promise(function (r) { setTimeout(r, ms); }); }
+  var log = [];
+  (async function () {
+    await wait(9000);
+    var sel = document.getElementById('molecule');
+    for (var i = 0; i < sel.options.length; i++) {
+      if (sel.options[i].textContent.indexOf(MOL) >= 0) {
+        sel.selectedIndex = i;
+        sel.dispatchEvent(new Event('change', { bubbles: true }));
+        break;
+      }
+    }
+    await wait(13000);
+    document.querySelector('[data-jump="fields"]').click();
+    await wait(1200);
+
+    var summary = txt('#fields-summary');
+    if (/no ligand/i.test(summary)) {
+      log.push('NO LIGAND — nothing to precompute');
+    } else {
+      for (var f = 0; f < FIELDS.length; f++) {
+        var btn = document.querySelector('.field-btn[data-field="' + FIELDS[f] + '"]');
+        if (!btn) { log.push(FIELDS[f] + ':no-button'); continue; }
+        for (var w = 0; w < 30 && btn.disabled; w++) await wait(1000);
+        if (btn.disabled) { log.push(FIELDS[f] + ':still-disabled'); continue; }
+        btn.click();
+        var done = false;
+        for (var k = 0; k < 240; k++) {
+          await wait(1000);
+          var st = txt('#field-status');
+          if (/rendered/i.test(st)) { log.push(FIELDS[f] + ':OK'); done = true; break; }
+          if (/refus|unreach|cannot|exceed|budget|not quotable/i.test(st)) {
+            log.push(FIELDS[f] + ':REFUSED(' + st.slice(0, 60) + ')'); done = true; break;
+          }
+        }
+        if (!done) log.push(FIELDS[f] + ':TIMEOUT');
+      }
+      // The physics panel too — same molecule, same session, both daemons warm.
+      var pt = document.querySelector('[data-jump="physics"]');
+      if (pt) {
+        pt.click(); await wait(900);
+        var tors = document.getElementById('phys-run-torsion');
+        if (tors && !tors.disabled) {
+          tors.click();
+          for (var a = 0; a < 90; a++) { await wait(1000);
+            if (/rotors scanned|unreach|refus|cannot/i.test(txt('#phys-torsion-status'))) break; }
+          log.push('torsion:' + txt('#phys-torsion-status').slice(0, 40));
+        }
+        var surf = document.getElementById('phys-run-surface');
+        if (surf && !surf.disabled) {
+          surf.click();
+          for (var b = 0; b < 300; b++) { await wait(1000);
+            if (/electrostatics for|unreach|refus|cannot|exceed/i.test(txt('#phys-surface-status'))) break; }
+          log.push('sigma:' + txt('#phys-surface-status').slice(0, 40));
+        }
+        document.querySelector('[data-jump="fields"]').click();
+        await wait(800);
+      }
+    }
+    await wait(1500);
+    var bar = document.createElement('div');
+    bar.style.cssText = 'position:fixed;left:0;right:0;bottom:0;z-index:99999;'
+      + 'font:10px ui-monospace,monospace;padding:5px 9px;background:#111;color:#0f0';
+    bar.textContent = MOL + ' | ' + summary + ' | ' + log.join('  ');
+    document.body.appendChild(bar);
+    document.title = 'WARM_DONE';
+    window.__warm = log;
+  })();
+})();
+</script>
+EOF
+  cat "$ROOT/build/dirac/index.html" "$STAGE/index.html.driver" > "$STAGE/index.html"
+  echo "warming $MOL ..."
+  timeout 900 google-chrome --headless=new --enable-unsafe-swiftshader \
+      --use-angle=swiftshader --window-size=1600,1000 \
+      --virtual-time-budget=800000 \
+      --screenshot="$OUT/warm_$MOL.png" \
+      "http://127.0.0.1:$PORT/index.html" >/dev/null 2>&1
+  echo "  -> $OUT/warm_$MOL.png"
+done
+
+kill "$(cat "$OUT/.srv")" 2>/dev/null
+rm -f "$OUT/.srv" "$STAGE/index.html.driver"
+echo
+echo "DB rows now cached (the ones that survive a restart):"
+psql -U ivan -d dirac -tAc \
+  "select kind, basis, count(*) from app.field_cube group by 1,2 order by 1,2" 2>/dev/null \
+  || echo "  (psql unavailable — check the daemon log for '[db] cached')"

src/app.frontend.facets.molstar-rdkit.editable/facets/field-wells/index.ts

@@ -445,8 +445,15 @@ function updateIsoReadout() {
     let note = '';
     // Whether the surface actually closes is a fact about this picture, and it
     // is the one the crate bug turned on. Stated, not inferred from the shape.
-    if (lastMeta && lastMeta.contour_closes_in_box === false) {
-        note = ` · open surface (field is ${lastMeta.wall_max ?? '?'} at the box edge)`;
+    // Recomputed against the CURRENT slider position, not the value the
+    // backend sized the box for. The slider multiplies the contour by
+    // 10^[-1,1], so a box that closes at the default can still be exited at
+    // the low end — that is where the cut-off lobes came from.
+    const wall = lastMeta?.wall_max;
+    const open = typeof wall === 'number' && currentIso() <= wall;
+    if (open) {
+        note = ` · OPEN SURFACE — field reaches ${wall} at the box edge, `
+             + `so the lobes are cut off. Raise the isovalue.`;
     } else if (lastMeta && lastMeta.single_signed) {
         note = ' · field is single-signed — no negative lobe exists';
     }