B4

Author: alongd

arc/job/adapters/molpro.py

@@ -249,7 +249,21 @@ def write_input_file(self) -> None:
         if self.level.method in MRCC_ROUTED_METHODS:
             # Restriction is implicit from the preceding {hf;...} block; the
             # MRCC plugin call does not accept a 'u'/'r' prefix.
-            input_dict['method'] = '{mrcc,method=' + self.level.method.upper() + '}'
+            mrcc_call = '{mrcc,method=' + self.level.method.upper() + '}'
+            if not is_restricted(self):
+                # Open-shell wavefunction: Molpro emits ROHF for the {hf;...}
+                # block above. MRCC's approximate-CC family (CCSDT, CCSDT(Q),
+                # CCSDTQ, CCSDTQ(P)) refuses standard ROHF orbitals with the
+                # error "Approximate CC methods are not implemented for
+                # standard ROHF orbitals! Use semicanonical orbitals!".
+                # Running {uccsd} on the ROHF reference produces semicanonical
+                # orbitals as a side effect; MRCC then picks them up
+                # automatically. This costs one extra UCCSD pass per sub-job
+                # but is the only way the post-(T) MRCC methods will run for
+                # radicals. {ccsd} on its own would be cheaper but does not
+                # consistently produce SC orbitals across Molpro versions.
+                mrcc_call = '{uccsd}\n' + mrcc_call
+            input_dict['method'] = mrcc_call
             input_dict['restricted'] = ''
 
         # Job type specific options

arc/job/adapters/molpro_test.py

@@ -460,13 +460,28 @@ def test_write_mrci_input_file(self):
         self.assertEqual(content_7, job_7_expected_input_file)
 
     def test_write_input_file_mrcc_routing(self):
-        """Methods unsupported by native Molpro but supported by MRCC are routed through the MRCC plugin."""
+        """Methods unsupported by native Molpro but supported by MRCC are routed through the MRCC plugin.
+
+        For an open-shell wavefunction, an additional ``{uccsd}`` step is
+        emitted between the HF block and the MRCC plugin call. Molpro defaults
+        to ROHF for open-shell HF, but MRCC's approximate-CC family
+        (``CCSDT``, ``CCSDT(Q)``, ``CCSDTQ``, ``CCSDTQ(P)``) refuses standard
+        ROHF orbitals with the error::
+
+            Approximate CC methods are not implemented for standard ROHF orbitals!
+            Use semicanonical orbitals!
+
+        Running ``{uccsd}`` on the ROHF reference produces the semicanonical
+        orbitals MRCC needs as a side effect — they're left on disk and the
+        subsequent ``{mrcc,method=...}`` call picks them up automatically.
+        """
         self.job_mrcc_ccsdt.cpu_cores = 48
         self.job_mrcc_ccsdt.set_input_file_memory()
         self.job_mrcc_ccsdt.write_input_file()
         with open(os.path.join(self.job_mrcc_ccsdt.local_path,
                                input_filenames[self.job_mrcc_ccsdt.job_adapter]), 'r') as f:
             content_ccsdt = f.read()
+        # spc1 has multiplicity=3 (open-shell triplet) — uccsd prefix expected.
         expected_ccsdt = """***,spc1
 memory,Total=438,m;
 
@@ -486,6 +501,7 @@ def test_write_input_file_mrcc_routing(self):
  wf,spin=2,charge=0;
 }
 
+{uccsd}
 {mrcc,method=CCSDT}
 
 
@@ -497,6 +513,13 @@ def test_write_input_file_mrcc_routing(self):
         # Sanity: the bare directive Molpro rejects must NOT appear on its own line.
         self.assertNotIn('\nccsdt;\n', content_ccsdt)
         self.assertNotIn('\nuccsdt;\n', content_ccsdt)
+        # The uccsd step must come between the HF block and the mrcc plugin call —
+        # not after, not before HF.
+        uccsd_idx = content_ccsdt.index('{uccsd}')
+        hf_close_idx = content_ccsdt.index('}\n\n{uccsd}')
+        mrcc_idx = content_ccsdt.index('{mrcc,method=CCSDT}')
+        self.assertLess(hf_close_idx, uccsd_idx)
+        self.assertLess(uccsd_idx, mrcc_idx)
 
         self.job_mrcc_ccsdtq.cpu_cores = 48
         self.job_mrcc_ccsdtq.set_input_file_memory()
@@ -532,6 +555,9 @@ def test_write_input_file_mrcc_routing(self):
 """
         self.assertEqual(content_ccsdtq, expected_ccsdtq)
         self.assertNotIn('\nccsdt(q);\n', content_ccsdtq)
+        # spc1 here has multiplicity=1 (closed-shell) — no semicanonical-orbital
+        # prep step is needed and none should be emitted.
+        self.assertNotIn('{uccsd}', content_ccsdtq)
 
     def test_set_files(self):
         """Test setting files"""

arc/job/trsh.py

@@ -395,10 +395,41 @@ def determine_ess_status(output_path: str,
             return 'errored', keywords, error, line
 
         elif software == 'molpro':
+            # MRCC ROHF-incompatibility check BEFORE the generic reverse scan
+            # because the underlying cause ("Use semicanonical orbitals!")
+            # appears earlier in the file than the downstream "Fatal error in
+            # mrcc." line — reverse iteration would otherwise classify the
+            # latter (generic) before the former (specific). Fix in the
+            # adapter prepends ``{uccsd}`` to generate semicanonical orbitals;
+            # this keyword surfaces the diagnostic for any legacy run that
+            # hits it.
+            joined = '\n'.join(lines) if isinstance(lines, list) else str(lines)
+            if 'standard ROHF orbitals' in joined or 'Use semicanonical orbitals' in joined:
+                rohf_line = next(
+                    (ln for ln in lines if 'standard ROHF orbitals' in ln
+                     or 'Use semicanonical orbitals' in ln),
+                    '',
+                )
+                return ('errored', ['MRCCRequiresSemicanonical'],
+                        'MRCC requires semicanonical orbitals; ROHF orbitals '
+                        'are not supported for approximate CC.',
+                        rohf_line)
             for line in reverse_lines:
                 if 'molpro calculation terminated' in line.lower() \
                         or 'variable memory released' in line.lower():
                     return 'done', list(), '', ''
+                elif 'Fatal error in xmrcc' in line or 'Fatal error in mrcc' in line:
+                    # MRCC bailed for a tiny system where the requested CC
+                    # excitation rank exceeds the determinant space (e.g.
+                    # atomic H or H2 at CCSDT(Q)). The composite framework
+                    # should short-circuit a δ-term high leg with this
+                    # keyword to the corresponding low-leg energy (δ = 0,
+                    # which is correct for a degenerate-method case).
+                    keywords = ['MRCCDegenerateSystem']
+                    error = ('MRCC xmrcc fatal — the requested CC excitation '
+                             'rank exceeds the determinant space for this '
+                             'system (degenerate / too few electrons).')
+                    break
                 elif 'No convergence' in line and '?No convergence in rhfpr' not in line:
                     keywords = ['Unconverged']
                     error = 'Unconverged'

arc/job/trsh_test.py

@@ -171,6 +171,32 @@ def test_determine_ess_status(self):
         self.assertEqual(error, "Unrecognized basis set 6-311G**")
         self.assertIn(" ? Basis library exhausted", line)  # line includes '\n'
 
+        # Molpro + MRCC: degenerate small system (e.g. atomic H, H2 at CCSDT(Q)).
+        # MRCC's xmrcc bails because there's no determinant space at the
+        # requested excitation rank. Trsh must classify this so the framework
+        # knows to short-circuit the sub-job (delta = 0) instead of cycling
+        # the generic ladder (shift / vdz / memory).
+        path = os.path.join(self.base_path["molpro"], "mrcc_xmrcc_fatal.out")
+        status, keywords, error, line = trsh.determine_ess_status(
+            output_path=path, species_label="H", job_type="sp"
+        )
+        self.assertEqual(status, "errored")
+        self.assertEqual(keywords, ["MRCCDegenerateSystem"])
+        self.assertIn("xmrcc", error.lower())
+        self.assertIn("Fatal error in xmrcc", line)
+
+        # Molpro + MRCC: ROHF orbitals incompatible with approximate CC methods
+        # (open-shell radicals). Trsh classifies and the adapter's UCCSD
+        # prefix should prevent this from happening on new runs; the keyword
+        # is the diagnostic for any legacy runs that don't have the prefix.
+        path = os.path.join(self.base_path["molpro"], "mrcc_rohf_unsupported.out")
+        status, keywords, error, line = trsh.determine_ess_status(
+            output_path=path, species_label="OH", job_type="sp"
+        )
+        self.assertEqual(status, "errored")
+        self.assertEqual(keywords, ["MRCCRequiresSemicanonical"])
+        self.assertIn("semicanonical", error.lower())
+
         # Orca
 
         # test detection of a successful job

arc/output.py

@@ -24,6 +24,7 @@
     AEC_SECTION_START, AEC_SECTION_END,
     MBAC_SECTION_START, MBAC_SECTION_END,
     PBAC_SECTION_START, PBAC_SECTION_END,
+    filter_real_stderr_lines,
     find_best_across_files, get_qm_corrections_files,
 )
 
@@ -339,8 +340,9 @@ def _get_energy_corrections(arkane_level_of_theory, bac_type: Optional[str]) ->
                 'fi"',
             ]
             _, stderr = execute_command(command=commands, executable='/bin/bash')
-            if stderr:
-                logger.warning(f'get_qm_corrections.py stderr: {stderr}')
+            real_stderr = filter_real_stderr_lines(stderr) if stderr else []
+            if real_stderr:
+                logger.warning(f'get_qm_corrections.py stderr: {real_stderr}')
 
             result = read_yaml_file(tmp_out) or {}
             return result.get('aec'), result.get('bac')
@@ -412,8 +414,9 @@ def _compute_point_groups(species_dict: Dict, project_directory: str) -> Dict[st
             'fi"',
         ]
         _, stderr = execute_command(command=commands, executable='/bin/bash')
-        if stderr:
-            logger.warning(f'get_point_groups.py stderr: {stderr}')
+        real_stderr = filter_real_stderr_lines(stderr) if stderr else []
+        if real_stderr:
+            logger.warning(f'get_point_groups.py stderr: {real_stderr}')
 
         result = read_yaml_file(tmp_out) or {}
         return {str(k): (str(v) if v is not None else None) for k, v in result.items()}

arc/processor.py

@@ -11,6 +11,7 @@
 from arc.imports import settings
 from arc.level import Level
 from arc.job.local import execute_command
+from arc.statmech.arkane import filter_real_stderr_lines
 from arc.statmech.factory import statmech_factory
 
 
@@ -271,8 +272,9 @@ def compare_thermo(species_for_thermo_lib: list,
                 'fi"',
                 ]
     stdout, stderr = execute_command(command=commands, no_fail=True)
-    if len(stderr):
-        logger.error(f'Error while running RMG thermo script: {stderr}')
+    real_stderr = filter_real_stderr_lines(stderr) if stderr else []
+    if real_stderr:
+        logger.error(f'Error while running RMG thermo script: {real_stderr}')
     species_list = read_yaml_file(path=species_thermo_path)
     for original_spc, rmg_spc in zip(species_for_thermo_lib, species_list):
         h298, s298, comment = rmg_spc.get('h298', None), rmg_spc.get('s298', None), rmg_spc.get('comment', None)

arc/scheduler.py

@@ -1731,6 +1731,75 @@ def _post_sp_actions_composite(
         else:
             self._finalize_composite(label)
 
+    def _mrcc_degenerate_short_circuit(self, label: str, job) -> bool:
+        """If a composite δ-term high-leg sub-job errored with the
+        ``MRCCDegenerateSystem`` keyword, substitute the sister low-leg's
+        recorded path and advance the composite. Returns ``True`` when the
+        short-circuit was applied so the caller can skip ``troubleshoot_ess``.
+
+        Why this exists: for systems too small to accommodate the requested
+        CC excitation rank (atomic H, H2 at CCSDT(Q), etc.) MRCC's xmrcc
+        bails — there's no determinant space to iterate. The two legs of
+        the δ term are mathematically degenerate (all CC ranks reduce to
+        HF), so δ = 0 is the correct physical answer. The trsh ladder
+        cannot fix this; it must be handled at the protocol level.
+
+        Conservative on safety:
+        * Only fires when keywords contain ``'MRCCDegenerateSystem'``.
+        * Only fires when the species has an active composite.
+        * Only fires for ``__high`` sub-labels with a recorded ``__low``
+          sister in ``output[label]['paths']['sp_composite']``. Low-leg
+          failures and high-leg failures without a completed sister fall
+          through so the caller's normal trsh path runs.
+        """
+        keywords = (job.job_status[1] or {}).get('keywords') or []
+        if 'MRCCDegenerateSystem' not in keywords:
+            return False
+        protocol = self._composite_for(label)
+        if protocol is None:
+            return False
+        # Identify which pending sub_label this errored job corresponds to.
+        pending = self._sp_composite_pending.get(label, {})
+        failed_sub_label = next(
+            (sl for sl, lvl in pending.items() if lvl == job.level),
+            None,
+        )
+        if failed_sub_label is None or not failed_sub_label.endswith('__high'):
+            logger.warning(format_log_event(
+                label,
+                "MRCCDegenerateSystem on a non-high sub-job — falling through to trsh",
+                {"sub_label": failed_sub_label, "level": str(job.level)},
+            ))
+            return False
+        sister_low = failed_sub_label[: -len('__high')] + '__low'
+        completed = self.output.get(label, {}).get('paths', {}).get('sp_composite', {}) or {}
+        sister_path = completed.get(sister_low)
+        if not sister_path:
+            logger.warning(format_log_event(
+                label,
+                "MRCCDegenerateSystem high-leg failed but low-leg not yet recorded — deferring",
+                {"failed": failed_sub_label, "sister": sister_low},
+            ))
+            return False
+        logger.warning(format_log_event(
+            label,
+            "MRCC degenerate-system fallback: substituting low-leg energy for high-leg",
+            {"failed": failed_sub_label, "sister": sister_low,
+             "reason": "Method exceeds determinant space; δ = 0 by symmetry."},
+        ))
+        # Substitute by re-using the low-leg's path. _record_composite_completion
+        # writes the path into output and clears the pending entry — same as a
+        # normal completion, but pointing both legs at the same file so they
+        # parse to the same energy and the δ evaluates to zero.
+        completed_paths = self.output[label]['paths']['sp_composite']
+        completed_paths[failed_sub_label] = sister_path
+        del pending[failed_sub_label]
+        if pending:
+            self._spawn_composite_pending(label)
+        else:
+            self._finalize_composite(label)
+        return True
+
     def _rehydrate_composite_state(self) -> None:
         """On scheduler init/restart, seed pending for every species with an active
         composite, rebuild the SpeciesSection for species that already finalized,
@@ -3212,6 +3281,13 @@ def check_sp_job(self,
             if self.species_dict[label].number_of_atoms == 1:
                 # save the geometry from the sp job for monoatomic species for which no opt/freq jobs will be spawned
                 self.output[label]['paths']['geo'] = job.local_path_to_output_file
+        elif self._mrcc_degenerate_short_circuit(label=label, job=job):
+            # MRCC bailed for a degenerate small-system δ-term high leg
+            # (atomic H, H2, etc., where the requested CC excitation rank
+            # exceeds the determinant space). The trsh ladder cannot help —
+            # cause is intrinsic. Helper substituted the low-leg energy and
+            # advanced the composite; nothing further to do here.
+            self.save_restart_dict()
         else:
             self.troubleshoot_ess(label=label,
                                   job=job,