react-cheminfo 0.3.0 → 0.4.0

package/src/orbital/core/atomicGrid.ts

@@ -16,7 +16,11 @@ import type { AtomicOrbital } from './atomicOrbitals.ts';
 import { hydrogenicParametersOf } from './atomicOrbitals.ts';
 import type { GridBox, OrbitalEvaluator, OrbitalGrid } from './grid.ts';
 import { evaluateGrid } from './grid.ts';
-import { createRadialFunction, enclosingRadius } from './hydrogenic.ts';
+import {
+  createRadialFunction,
+  enclosingRadius,
+  radialNodeRadii,
+} from './hydrogenic.ts';
 
 /** How finely, and how far out, an orbital is sampled. */
 export interface AtomicGridOptions {
@@ -105,9 +109,57 @@ export function atomicGridBox(
   };
 }
 
+/** How finely one orbital may be sampled, whatever its shape asks for. */
+export interface ResolutionLimits {
+  /** Samples per edge no orbital drops below. */
+  floor: number;
+  /** Samples per edge no orbital exceeds. */
+  cap: number;
+}
+
+/**
+ * How finely this particular orbital has to be sampled.
+ *
+ * One resolution for a whole periodic table draws the nested orbitals badly.
+ * The box is sized by the outermost lobe, but a `4p` also has to separate two
+ * inner shells packed against the nucleus, and at 56 samples per edge xenon's
+ * innermost 4p lobe spans **6.6 voxels** while the outer one spans 41 — the
+ * inner shells come out as lumps and the outer surface visibly faceted. What
+ * sets the requirement is therefore the ratio between the box and the smallest
+ * feature in it, not the orbital's size, which is why a nodeless orbital
+ * (every `1s`, `2p`, `3d`, `4f`) stays on the floor and costs nothing extra.
+ *
+ * The cap is not a budget cheat: the innermost lobe of caesium's `7s` would
+ * need 858 samples per edge, and no uniform grid the browser can afford
+ * resolves it. Those orbitals are drawn as well as the cap allows.
+ * @param orbital - The orbital to draw.
+ * @param limits - See {@link ResolutionLimits}.
+ * @returns Samples along each edge of the cube.
+ */
+export function atomicGridResolution(
+  orbital: AtomicOrbital,
+  limits: ResolutionLimits,
+): number {
+  const { floor, cap } = limits;
+  const parameters = hydrogenicParametersOf(orbital);
+  const innermost = radialNodeRadii(parameters)[0];
+  if (innermost === undefined || !(innermost > 0)) return Math.min(floor, cap);
+  const half = atomicGridBox(orbital).size.x / 2;
+  // The samples span the box edge to edge, so `resolution - 1` of them cover
+  // it: a lobe of radius r gets `r (resolution - 1) / half` across its diameter.
+  const needed = Math.ceil((INNER_LOBE_SAMPLES * half) / innermost) + 1;
+  return Math.min(cap, Math.max(floor, needed));
+}
+
 /** Samples per edge; the cost is the cube of it. */
 const DEFAULT_RESOLUTION = 56;
 
+/**
+ * Samples the innermost radial lobe is asked to span, edge to edge. Below
+ * about eight, marching cubes turns a sphere into a faceted blob.
+ */
+const INNER_LOBE_SAMPLES = 12;
+
 /** A tail past this holds too little density to change the surface. */
 const DEFAULT_ENCLOSED_FRACTION = 0.985;
 

package/src/orbital/core/index.ts

@@ -1,30 +1,20 @@
-export type { AtomicGridOptions } from './atomicGrid.ts';
-export {
-  atomicGridBox,
-  createAtomicOrbitalEvaluator,
-  sampleAtomicOrbital,
-} from './atomicGrid.ts';
+export type { ResolutionLimits } from './atomicGrid.ts';
+export { atomicGridResolution } from './atomicGrid.ts';
 export type { AtomicOrbital, AtomicOrbitalOptions } from './atomicOrbitals.ts';
 export {
   atomicOrbitalsOf,
   defaultOrbitalId,
   findAtomicOrbital,
   hydrogenicParametersOf,
-  orbitalId,
 } from './atomicOrbitals.ts';
 export type { Vec3 } from './constants.ts';
-export {
-  BOHR_IN_ANGSTROM,
-  ENCLOSED_WEIGHT,
-  RYDBERG_ELECTRONVOLTS,
-} from './constants.ts';
+export { BOHR_IN_ANGSTROM, RYDBERG_ELECTRONVOLTS } from './constants.ts';
 export type { Subshell, SubshellOccupancy } from './electronConfiguration.ts';
 export {
   ELEMENT_ANOMALIES,
   HIGHEST_ATOMIC_NUMBER,
   MADELUNG_ORDER,
   NOBLE_GASES,
-  assertAtomicNumber,
   aufbauConfigurationOf,
   configurationOf,
   coreAtomicNumber,
@@ -33,10 +23,11 @@ export {
   isAnomalous,
   subshellCapacity,
   subshellLabel,
-  superscript,
 } from './electronConfiguration.ts';
 export type { GridBox, OrbitalEvaluator, OrbitalGrid } from './grid.ts';
 export { evaluateGrid, gridIndex } from './grid.ts';
+export type { OrbitalContour } from './isovalue.ts';
+export { enclosedReach, isocontourCutoff, orbitalContour } from './isovalue.ts';
 export type { HydrogenicParameters } from './hydrogenic.ts';
 export {
   createRadialFunction,
@@ -67,6 +58,6 @@ export type {
   AtomicSampleResult,
   AtomicSampler,
 } from './sample.ts';
-export { runAtomicSample, sampleInProcess } from './sample.ts';
+export { runAtomicSample } from './sample.ts';
 export type { Screening } from './screening.ts';
-export { groupRank, slaterScreening } from './screening.ts';
+export { slaterScreening } from './screening.ts';

package/src/orbital/core/isovalue.ts

@@ -0,0 +1,146 @@
+/**
+ * Choosing the value a signed wavefunction's isosurface is drawn at.
+ *
+ * The surface is named by how much of the electron it holds, not by an
+ * amplitude: `ENCLOSED_WEIGHT` of `∫|ψ|² dV` inside it and the tail
+ * outside. On a uniform grid that is a weighted quantile of the samples, and
+ * the isovalue is the `|ψ|` at which the quantile falls.
+ *
+ * molstar ships `computeOrbitalIsocontourValues` for the same job, and it
+ * cannot be used here. It abandons any field whose mean `ψ²` is under an
+ * absolute `1e-5` and returns no isovalue at all — a guard against degenerate
+ * data that instead reads the amplitude *scale*. Amplitudes are Å^(-3/2), so a
+ * diffuse orbital is normalised straight into that range and draws nothing:
+ * caesium's 6s reaches 13 Å, and 2588 of the 7460 orbitals lcao.cheminfo.org
+ * offers came back blank. A quantile has no scale of its own and cannot.
+ *
+ * Every pass below touches each of the million-odd samples, so all of them are
+ * indexed loops: `for…of` over a `Float32Array` measures 6.7× slower.
+ */
+
+import { ENCLOSED_WEIGHT } from './constants.ts';
+import type { OrbitalGrid } from './grid.ts';
+
+/**
+ * The `|ψ|` whose surface encloses a given share of the sampled electron.
+ * @param data - The sampled amplitudes.
+ * @param enclosedWeight - Share of `∑ψ²` to hold inside, between 0 and 1.
+ * @returns The isovalue, or 0 when the field is empty — a nodeless orbital
+ * sampled where it has no amplitude at all.
+ * @throws {Error} When `enclosedWeight` is outside `(0, 1)`.
+ */
+export function isocontourCutoff(
+  data: Float32Array,
+  enclosedWeight: number = ENCLOSED_WEIGHT,
+): number {
+  if (!(enclosedWeight > 0) || enclosedWeight >= 1) {
+    throw new RangeError('the enclosed weight must be in (0, 1)');
+  }
+  let total = 0;
+  let peak = 0;
+  for (let index = data.length - 1; index >= 0; index--) {
+    const value = data[index] as number;
+    const weight = value * value;
+    total += weight;
+    if (weight > peak) peak = weight;
+  }
+  if (!(total > 0)) return 0;
+
+  // Bins are logarithmic because a wavefunction spans decades between its peak
+  // and its tail while the isovalue sits far below the peak: linear bins would
+  // drop every sample that decides the answer into the first one.
+  const bins = new Float64Array(BIN_COUNT);
+  const peakLogarithm = Math.log2(peak);
+  for (let index = data.length - 1; index >= 0; index--) {
+    const value = data[index] as number;
+    const weight = value * value;
+    if (weight === 0) continue;
+    const bin = Math.floor(
+      (peakLogarithm - Math.log2(weight)) * BINS_PER_OCTAVE,
+    );
+    const clamped = bin < 0 ? 0 : Math.min(bin, BIN_COUNT - 1);
+    bins[clamped] = (bins[clamped] as number) + weight;
+  }
+
+  const target = total * enclosedWeight;
+  let running = 0;
+  for (let bin = 0; bin < BIN_COUNT; bin++) {
+    running += bins[bin] as number;
+    // Everything above this bin's lower edge is what has just been counted.
+    if (running >= target) {
+      return Math.sqrt(peak * 2 ** (-(bin + 1) / BINS_PER_OCTAVE));
+    }
+  }
+  return 0;
+}
+
+/**
+ * How far from the centre of the box the drawn surface actually reaches.
+ *
+ * Molstar sizes a volume representation's bounding sphere from the whole
+ * sampled box, which is deliberately larger than the isosurface inside it, so a
+ * camera framing that sphere leaves the orbital a quarter of the frame wide.
+ * Measuring the samples that are really enclosed gives the camera the extent it
+ * has to fill.
+ * @param field - The sampled field.
+ * @param cutoff - The isovalue the surfaces are drawn at.
+ * @returns The reach in ångström, or 0 when nothing is enclosed.
+ */
+export function enclosedReach(field: OrbitalGrid, cutoff: number): number {
+  if (!(cutoff > 0)) return 0;
+  const { data, dimensions, origin, spacing } = field;
+  const [countX, countY, countZ] = dimensions;
+  const centreX = origin.x + ((countX - 1) * spacing) / 2;
+  const centreY = origin.y + ((countY - 1) * spacing) / 2;
+  const centreZ = origin.z + ((countZ - 1) * spacing) / 2;
+  let furthest = 0;
+  let index = 0;
+  for (let indexX = 0; indexX < countX; indexX++) {
+    const dx = origin.x + indexX * spacing - centreX;
+    for (let indexY = 0; indexY < countY; indexY++) {
+      const dy = origin.y + indexY * spacing - centreY;
+      for (let indexZ = 0; indexZ < countZ; indexZ++) {
+        const value = data[index++] as number;
+        if (value < cutoff && value > -cutoff) continue;
+        const dz = origin.z + indexZ * spacing - centreZ;
+        const squared = dx * dx + dy * dy + dz * dz;
+        if (squared > furthest) furthest = squared;
+      }
+    }
+  }
+  return Math.sqrt(furthest);
+}
+
+/** Which isovalue each phase is drawn at, and how far the pair reaches. */
+export interface OrbitalContour {
+  /** `|ψ|` on the surface; 0 when there is nothing to draw. */
+  cutoff: number;
+  /** Distance from the centre of the box to the outermost enclosed sample. */
+  reach: number;
+}
+
+/**
+ * The isovalue and the extent of one sampled orbital's surface pair.
+ *
+ * Both phases come from one cutoff, so they can never disagree about where the
+ * node between them is.
+ * @param field - The sampled field.
+ * @param enclosedWeight - Share of `∑ψ²` to hold inside.
+ * @returns See {@link OrbitalContour}.
+ */
+export function orbitalContour(
+  field: OrbitalGrid,
+  enclosedWeight: number = ENCLOSED_WEIGHT,
+): OrbitalContour {
+  const cutoff = isocontourCutoff(field.data, enclosedWeight);
+  return { cutoff, reach: enclosedReach(field, cutoff) };
+}
+
+/**
+ * Bins per doubling of `ψ²`, so the isovalue lands within 2.2% in `|ψ|`.
+ * Finer than the grid spacing can resolve on the surface it produces.
+ */
+const BINS_PER_OCTAVE = 16;
+
+/** 128 octaves of `ψ²`, far past the dynamic range of a sampled orbital. */
+const BIN_COUNT = 2048;

package/src/orbital/core/sample.ts

@@ -11,8 +11,8 @@
  * `sample` prop; one that does not gets the in-process version for free.
  */
 
-import type { AtomicGridOptions } from './atomicGrid.ts';
-import { sampleAtomicOrbital } from './atomicGrid.ts';
+import type { AtomicGridOptions, ResolutionLimits } from './atomicGrid.ts';
+import { atomicGridResolution, sampleAtomicOrbital } from './atomicGrid.ts';
 import {
   atomicOrbitalsOf,
   findAtomicOrbital,
@@ -20,6 +20,8 @@ import {
 } from './atomicOrbitals.ts';
 import type { OrbitalGrid } from './grid.ts';
 import { radialNodeRadii } from './hydrogenic.ts';
+import type { OrbitalContour } from './isovalue.ts';
+import { orbitalContour } from './isovalue.ts';
 
 /** Which orbital to sample, and how finely. */
 export interface AtomicSampleRequest {
@@ -29,15 +31,27 @@ export interface AtomicSampleRequest {
   orbitalId: string;
   /**
    * Samples along each edge of the cube. The cost is the cube of this.
+   *
+   * A number fixes the resolution. {@link ResolutionLimits} lets the orbital's
+   * own shape pick one between the two, which is what a nested orbital needs —
+   * see {@link atomicGridResolution}.
    * @default 56
    */
-  resolution?: number;
+  resolution?: number | ResolutionLimits;
 }
 
 /** What one sampling job produces. */
 export interface AtomicSampleResult {
   /** The signed field, ready for an isosurface. */
   grid: OrbitalGrid;
+  /**
+   * The isovalue both phases are drawn at, and how far the pair reaches.
+   *
+   * Measured here rather than beside the renderer: both passes are O(samples),
+   * and at the resolutions a nested orbital asks for that is over a million of
+   * them on whichever thread runs this.
+   */
+  contour: OrbitalContour;
   /** Radii of the orbital's radial nodes, ångström, ascending. */
   nodeRadii: number[];
 }
@@ -65,9 +79,15 @@ export function runAtomicSample(
     );
   }
   const options: AtomicGridOptions = {};
-  if (resolution !== undefined) options.resolution = resolution;
+  if (typeof resolution === 'number') {
+    options.resolution = resolution;
+  } else if (resolution !== undefined) {
+    options.resolution = atomicGridResolution(orbital, resolution);
+  }
+  const grid = sampleAtomicOrbital(orbital, options);
   return {
-    grid: sampleAtomicOrbital(orbital, options),
+    grid,
+    contour: orbitalContour(grid),
     nodeRadii: radialNodeRadii(hydrogenicParametersOf(orbital)),
   };
 }

package/src/orbital/ui/AtomicOrbitalCanvas.tsx

@@ -9,6 +9,7 @@
 import type { CSSProperties, ReactElement } from 'react';
 import { useEffect, useRef, useState } from 'react';
 
+import type { ResolutionLimits } from '../core/atomicGrid.ts';
 import type { PhasePalette } from '../core/palette.ts';
 import { PHASE_PALETTES } from '../core/palette.ts';
 import type { AtomicSampler } from '../core/sample.ts';
@@ -30,9 +31,13 @@ export interface AtomicOrbitalCanvasProps {
   palette?: PhasePalette;
   /**
    * Samples along each edge of the cube; the cost is the cube of it.
+   *
+   * A number fixes it. A {@link ResolutionLimits} pair lets each orbital's own
+   * shape pick a resolution between the two, which is what the orbitals with
+   * inner shells packed against the nucleus need.
    * @default 56
    */
-  resolution?: number;
+  resolution?: number | ResolutionLimits;
   /**
    * Whether the scene turns on its own, which is what makes a still screenshot
    * of a 3D shape readable.
@@ -83,7 +88,7 @@ export function AtomicOrbitalCanvas(
 
   // What the canvas is being asked to show. Comparing it with what it *is*
   // showing gives the progress note without a state write on every prop change.
-  const wanted = `${atomicNumber}|${orbitalId}|${resolution}|${palette.id}`;
+  const wanted = `${atomicNumber}|${orbitalId}|${resolutionKey(resolution)}|${palette.id}`;
   const busy = drawn !== wanted;
 
   // Callbacks are read through refs so a caller passing an inline arrow does
@@ -120,7 +125,7 @@ export function AtomicOrbitalCanvas(
       .then(async (result) => {
         if (cancelled) return;
         callbacks.current.onNodeRadii?.(result.nodeRadii);
-        const reach = await viewer.showOrbital(result.grid, {
+        const reach = await viewer.showOrbital(result.grid, result.contour, {
           positiveColour: palette.positive,
           negativeColour: palette.negative,
         });
@@ -152,6 +157,17 @@ export function AtomicOrbitalCanvas(
 /** Samples per edge; 56 resolves the radial node of a 3s in about 25 ms. */
 const DEFAULT_RESOLUTION = 56;
 
+/**
+ * A stable identity for either shape the resolution prop can take.
+ * @param resolution - A fixed sample count, or the limits it may vary between.
+ * @returns A string that changes exactly when the sampling would.
+ */
+function resolutionKey(resolution: number | ResolutionLimits): string {
+  return typeof resolution === 'number'
+    ? String(resolution)
+    : `${resolution.floor}-${resolution.cap}`;
+}
+
 /**
  * A square, centred stage: an atomic orbital is as tall as it is wide, so a
  * square wastes the least of the frame and keeps the lobes the same size when

package/src/orbital/ui/AtomicOrbitalViewer.tsx

@@ -18,6 +18,7 @@
 import type { CSSProperties, ReactElement, ReactNode } from 'react';
 import { Suspense, lazy, useState } from 'react';
 
+import type { ResolutionLimits } from '../core/atomicGrid.ts';
 import type { PhasePalette } from '../core/palette.ts';
 import type { AtomicSampler } from '../core/sample.ts';
 
@@ -44,9 +45,12 @@ export interface AtomicOrbitalViewerProps {
   palette?: PhasePalette;
   /**
    * Samples along each edge of the cube; the cost is the cube of it.
+   *
+   * A number fixes it. A {@link ResolutionLimits} pair lets each orbital's own
+   * shape pick a resolution between the two.
    * @default 56
    */
-  resolution?: number;
+  resolution?: number | ResolutionLimits;
   /**
    * Whether the scene turns on its own.
    * @default false

package/src/orbital/ui/renderVolume.ts

@@ -14,7 +14,6 @@
  * them wholesale.
  */
 
-import { computeOrbitalIsocontourValues } from 'molstar/lib/extensions/alpha-orbitals/orbitals.js';
 import type { Volume } from 'molstar/lib/mol-model/volume.js';
 import type { PluginContext } from 'molstar/lib/mol-plugin/context.js';
 import { createVolumeRepresentationParams } from 'molstar/lib/mol-plugin-state/helpers/volume-representation-params.js';
@@ -22,10 +21,10 @@ import type { Representation } from 'molstar/lib/mol-repr/representation.js';
 import { Theme } from 'molstar/lib/mol-theme/theme.js';
 import { Color } from 'molstar/lib/mol-util/color/color.js';
 
-import { ENCLOSED_WEIGHT } from '../core/constants.ts';
 import type { OrbitalGrid } from '../core/grid.ts';
+import type { OrbitalContour } from '../core/isovalue.ts';
 
-import { DISPLAY_REACH, surfaceReach, toVolume } from './volumeField.ts';
+import { DISPLAY_REACH, toVolume } from './volumeField.ts';
 
 /** Colours and opacity of one signed isosurface pair. */
 export interface VolumeStyle {
@@ -40,8 +39,8 @@ export interface VolumeStyle {
    */
   negativeColour?: string;
   /**
-   * Isovalue as a multiple of the one enclosing `ENCLOSED_WEIGHT` of the
-   * orbital's weight. Larger means a tighter, smaller surface.
+   * Isovalue as a multiple of the contour's own cutoff. Larger means a
+   * tighter, smaller surface.
    * @default 1
    */
   relativeIsovalue?: number;
@@ -56,6 +55,8 @@ export interface VolumeStyle {
  * Replace the isosurface pair drawn from a sampled field.
  * @param plugin - The molstar context.
  * @param field - The field, as `sampleAtomicOrbital` produced it.
+ * @param contour - The isovalue and reach measured on that field, as
+ * `runAtomicSample` returned them.
  * @param style - See {@link VolumeStyle}.
  * @returns How far the drawn surface reaches from the centre of the box,
  * ångström — what a camera has to frame to fill the viewport with it.
@@ -64,6 +65,7 @@ export interface VolumeStyle {
 export async function renderSampledVolume(
   plugin: PluginContext,
   field: OrbitalGrid,
+  contour: OrbitalContour,
   style: VolumeStyle = {},
 ): Promise<number> {
   const canvas3d = plugin.canvas3d;
@@ -78,25 +80,30 @@ export async function renderSampledVolume(
   } = style;
   clearSampledVolume(plugin);
 
-  const isovalues = computeOrbitalIsocontourValues(field.data, ENCLOSED_WEIGHT);
+  const { cutoff, reach } = contour;
   // Molstar's camera clamps both its target distance and its near plane, so it
   // cannot get close to a small object: uranium's 4f reaches 0.35 Å and would
   // stay a dot in the corner whatever the camera is asked to frame. Every
   // orbital is therefore drawn at one canonical size, and the true extent is
   // reported as ⟨r⟩ and on the radial plot instead of by the picture's scale.
-  const reach = surfaceReach(field, isovalues);
   const volume = toVolume(field, reach > 0 ? DISPLAY_REACH / reach : 1);
   // A nodeless orbital — every 1s — has no negative lobe at all, and asking for
   // its isosurface would draw an empty mesh at value 0.
   const surfaces = await Promise.all([
-    maybeSurface(plugin, volume, isovalues.positive, relativeIsovalue, {
-      colour: positiveColour,
-      alpha,
-    }),
-    maybeSurface(plugin, volume, isovalues.negative, relativeIsovalue, {
-      colour: negativeColour,
-      alpha,
-    }),
+    maybeSurface(
+      plugin,
+      volume,
+      field.max >= cutoff ? cutoff : undefined,
+      relativeIsovalue,
+      { colour: positiveColour, alpha },
+    ),
+    maybeSurface(
+      plugin,
+      volume,
+      field.min <= -cutoff ? -cutoff : undefined,
+      relativeIsovalue,
+      { colour: negativeColour, alpha },
+    ),
   ]);
   const drawn = surfaces.filter(
     (surface): surface is Representation.Any => surface !== null,
@@ -163,7 +170,13 @@ async function createSurface(
       isoValue: { kind: 'absolute', absoluteValue: isovalue },
       alpha,
       xrayShaded: true,
-      tryUseGpu: true,
+      // Molstar's GPU marching cubes pits the outer lobe of a diffuse orbital
+      // with voxel-sized dimples — caesium's 6s and every 7s, 6d and 7p above
+      // it — and quantises the field to 255 steps on upload unless told
+      // otherwise, which terraces xenon's 4p. The surface is a thin shell
+      // whatever the box holds, so the CPU path costs 13–44 ms and returns
+      // 27 k vertices even on the 152³ grid the highest quality asks for.
+      tryUseGpu: false,
     },
     color: 'uniform',
     colorParams: { value: Color.fromHexStyle(colour) },

package/src/orbital/ui/viewer.ts

@@ -20,6 +20,7 @@ import { DefaultPluginSpec as defaultPluginSpec } from 'molstar/lib/mol-plugin/s
 import { Color } from 'molstar/lib/mol-util/color/color.js';
 
 import type { OrbitalGrid } from '../core/grid.ts';
+import type { OrbitalContour } from '../core/isovalue.ts';
 
 import { DEFAULT_CAMERA_DURATION, frameOrbital, setSpin } from './camera.ts';
 import type { VolumeStyle } from './renderVolume.ts';
@@ -89,15 +90,19 @@ export class OrbitalViewer {
   /**
    * Replace the isosurface pair with one drawn from a sampled field.
    * @param field - The sampled wavefunction, in ångström.
+   * @param contour - The isovalue and reach measured on that field.
    * @param style - See {@link VolumeStyle}.
    * @returns How far the drawn surface reaches, in scene units, for the camera
    * to frame; `undefined` once the viewer has been disposed.
    */
   showOrbital(
     field: OrbitalGrid,
+    contour: OrbitalContour,
     style?: VolumeStyle,
   ): Promise<number | undefined> {
-    return this.#run((plugin) => renderSampledVolume(plugin, field, style));
+    return this.#run((plugin) =>
+      renderSampledVolume(plugin, field, contour, style),
+    );
   }
 
   /**

package/src/orbital/ui/volumeField.ts

@@ -1,9 +1,11 @@
 /**
  * Turning a field the caller sampled into the `Volume` molstar's isosurface
- * renderer wants, and measuring how far the surface inside it actually reaches.
+ * renderer wants.
  *
- * Both halves are arithmetic over the samples, which is why they are here
- * rather than in `renderVolume.ts` — that module is about representations.
+ * It is arithmetic over the samples, which is why it is here rather than in
+ * `renderVolume.ts` — that module is about representations. How far the
+ * surface inside the box reaches is measured in `core/isovalue.ts`, beside the
+ * isovalue it is measured against.
  */
 
 import { Mat4, Tensor, Vec3 } from 'molstar/lib/mol-math/linear-algebra.js';
@@ -24,52 +26,6 @@ const { Space: createTensorSpace, Data1: asTensorData } = Tensor;
  */
 export const DISPLAY_REACH = 12;
 
-/**
- * How far from the centre of the box the drawn surface actually reaches.
- *
- * Molstar sizes a volume representation's bounding sphere from the whole
- * sampled box, which is deliberately much larger than the isosurface inside it,
- * so a camera framing that sphere leaves the orbital a quarter of the frame
- * wide. Measuring the samples that are actually enclosed gives the camera the
- * real extent, and does it here because this is where the isovalue is known.
- * @param field - The sampled field.
- * @param isovalues - The two isovalues the surfaces were drawn at.
- * @param isovalues.negative - Isovalue the negative lobe was drawn at, if any.
- * @param isovalues.positive - Isovalue the positive lobe was drawn at, if any.
- * @returns The reach in ångström, or 0 when nothing was drawn.
- */
-export function surfaceReach(
-  field: OrbitalGrid,
-  isovalues: { negative?: number | undefined; positive?: number | undefined },
-): number {
-  const cutoff = Math.min(
-    Math.abs(isovalues.positive ?? Infinity),
-    Math.abs(isovalues.negative ?? Infinity),
-  );
-  if (!Number.isFinite(cutoff) || cutoff <= 0) return 0;
-  const { data, dimensions, origin, spacing } = field;
-  const [countX, countY, countZ] = dimensions;
-  const centreX = origin.x + ((countX - 1) * spacing) / 2;
-  const centreY = origin.y + ((countY - 1) * spacing) / 2;
-  const centreZ = origin.z + ((countZ - 1) * spacing) / 2;
-  let furthest = 0;
-  let index = 0;
-  for (let indexX = 0; indexX < countX; indexX++) {
-    const dx = origin.x + indexX * spacing - centreX;
-    for (let indexY = 0; indexY < countY; indexY++) {
-      const dy = origin.y + indexY * spacing - centreY;
-      for (let indexZ = 0; indexZ < countZ; indexZ++) {
-        const value = data[index++] as number;
-        if (value < cutoff && value > -cutoff) continue;
-        const dz = origin.z + indexZ * spacing - centreZ;
-        const squared = dx * dx + dy * dy + dz * dz;
-        if (squared > furthest) furthest = squared;
-      }
-    }
-  }
-  return Math.sqrt(furthest);
-}
-
 /**
  * Wrap a sampled field in molstar's `Volume`.
  *