nwchemrx.desc: MASSES must precede the entries that read it (#126)

Follow-up to making the monitor's iteration deterministic.  Auditing
every parser script that reads a file a sibling writes turned up three
such pairs:

    parseSym   nwchem.symlab    -> nwchem.molab      nwchem.desc    OK
    parseMD    nwchem.mdheader  -> nwchem.mdprop     nwchemmd.desc  OK
    rxMasses   nwchemrx.masses  -> nwchemrx.rxstep   nwchemrx.desc  WRONG

nwchemrx.desc had the reader first: [TSSTEP] and [RXSTEP] at lines 17
and 24, [MASSES] at 31.  Under the old hash-order iteration that was
another coin flip; with the order now fixed it would have been
permanently broken instead, which is worse.  Moved [MASSES] above both.

The failure is not silent-but-harmless: nwchemrx.rxstep divides by
sqrt of each mass to un-mass-weight its coordinates, so with the file
absent the array is empty and the script dies on a division by zero.
The property is simply never stored.

Added a check to tests/parsers that derives this from the same table, so
a new .desc cannot reintroduce it.  Verified it actually fails: against
the previous ordering it reports both reader entries by line number, and
passes once MASSES is moved.

All four suites pass.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EFMUNbw2UpRPmgsqviAowb

Author: andy

scripts/parsers/nwchemrx.desc

@@ -14,6 +14,27 @@ Frequency=last
 End=  Frequencies
 [END]
 
+#  MUST COME BEFORE [TSSTEP] AND [RXSTEP].  nwchemrx.masses writes
+#  $key/rxMasses, and nwchemrx.rxstep divides by sqrt of those masses to
+#  un-mass-weight its coordinates -- with the file absent the array is
+#  empty and the script dies on a division by zero, so the property is
+#  simply never stored.
+#
+#  eccejobmonitor flushes buffered blocks in the order parse types
+#  appear in THIS FILE, and the client runs each script in arrival
+#  order, so the ordering here is the dependency.  It used to iterate a
+#  Perl hash instead, which randomized the order per process and made
+#  this pair work or fail by coin flip (see the NWChem SYMLAB/MOLAB
+#  case, which had the identical shape).  Reordered when that was fixed:
+#  a deterministic wrong order would have been permanently broken rather
+#  than intermittently.
+[MASSES]
+Script=nwchemrx.masses
+Begin = Mass of atom
+Frequency=first
+End = Forward reduced mass
+[END]
+
 [TSSTEP]
 Script=nwchemrx.rxstep
 Begin= All quantities in atomic units, x is vector of mass-weighted coordinates
@@ -28,9 +49,3 @@ Frequency=all
 End = (\s*\S*\s*dx=)
 [END]
 
-[MASSES]
-Script=nwchemrx.masses
-Begin = Mass of atom
-Frequency=first
-End = Forward reduced mass
-[END]

tests/parsers/run_tests.py

@@ -79,9 +79,51 @@ def norm(text):
 # .desc structural checks -- run once per .desc file, independent of fixtures
 # ---------------------------------------------------------------------------
 
+#  Parser scripts that read a file a SIBLING script writes.  The monitor
+#  flushes buffered blocks in descriptor-file order and the client runs
+#  each script as its block arrives, so the writer's entry must appear
+#  before the reader's or the reader runs against a file that does not
+#  exist yet.
+#
+#  This was a live bug (#126): the monitor used to iterate a Perl hash
+#  instead, randomizing the order per process, so NWChem orbital
+#  symmetries were extracted or silently dropped roughly three runs in
+#  eight.  Making the order deterministic fixes that -- and makes a
+#  wrongly-ordered .desc permanently broken instead of intermittently
+#  working, which is why this check exists.
+AUX_FILE_DEPENDENCIES = {
+    #  aux file       writer script        reader script
+    'parseSym':  ('nwchem.symlab',    'nwchem.molab'),
+    'parseMD':   ('nwchem.mdheader',  'nwchem.mdprop'),
+    'rxMasses':  ('nwchemrx.masses',  'nwchemrx.rxstep'),
+}
+
+
+def check_aux_file_order(desc_name, desc, res):
+    """A script's auxiliary-file writer must precede its readers."""
+    entries = list(desc.live_entries())
+    for aux, (writer, reader) in AUX_FILE_DEPENDENCIES.items():
+        wlines = [e.line for e in entries if e.script == writer]
+        rlines = [e.line for e in entries if e.script == reader]
+        if not wlines or not rlines:
+            continue
+        first_writer = min(wlines)
+        for rline in rlines:
+            res.check(
+                first_writer < rline,
+                desc_name,
+                '%s writes %s and %s reads it, but the reader\'s entry is at '
+                'line %d, before the writer at line %d. The monitor flushes '
+                'in this file\'s order, so the reader will run against a '
+                'file that does not exist yet -- silently (see #126).'
+                % (writer, aux, reader, rline, first_writer))
+
+
 def check_desc_structure(desc_name, desc, res):
     where = desc_name
 
+    check_aux_file_order(desc_name, desc, res)
+
     for entry, which, err in desc.bad_regex:
         res.check(False, where,
                   '[%s] (line %d): %s= pattern does not compile: %s'