B5

Author: alongd

arc/job/adapters/molpro.py

@@ -60,7 +60,7 @@
 ${cabs}
 int;
 
-{hf;${shift}
+{${hf_method};${shift}
  maxit,999;
  wf,spin=${spin},charge=${charge};
 }
@@ -242,29 +242,36 @@ def write_input_file(self) -> None:
         input_dict['spin'] = self.multiplicity - 1
         input_dict['xyz'] = xyz_to_str(self.xyz)
         input_dict['orbitals'] = '\ngprint,orbitals;\n'
+        input_dict['hf_method'] = 'hf'  # default; overridden below for open-shell MRCC
 
         if not is_restricted(self):
             input_dict['restricted'] = 'u'
 
         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.
-            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['method'] = '{mrcc,method=' + self.level.method.upper() + '}'
             input_dict['restricted'] = ''
+            if not is_restricted(self):
+                # Open-shell wavefunction + MRCC's approximate-CC family
+                # (CCSDT(Q), CCSDTQ(P), and the perturbative-(T) variants)
+                # refuses standard ROHF orbitals:
+                #   "Approximate CC methods are not implemented for standard
+                #    ROHF orbitals! Use semicanonical orbitals!"
+                # Solution: use UHF instead of (RO)HF as the SCF reference.
+                # UHF orbitals are semicanonical by construction (alpha and
+                # beta Fock matrices are separately diagonal) and live at the
+                # default record 2100.2, which MRCC reads. MRCC then reports
+                # ``Type=UHF/CANONICAL`` and accepts.
+                #
+                # An earlier attempt at this fix prepended ``{uccsd}`` to the
+                # MRCC call. {uccsd} does run UCCSD on top of ROHF, but the
+                # post-UCCSD canonical orbitals go to a separate record while
+                # the default 2100.2 still holds the original ROHF orbitals —
+                # MRCC reads 2100.2 by default and complained. Switching the
+                # SCF reference to UHF avoids this orbital-record bookkeeping
+                # entirely.
+                input_dict['hf_method'] = 'uhf'
 
         # Job type specific options
         if self.job_type in ['opt', 'optfreq', 'conf_opt']:

arc/job/adapters/molpro_test.py

@@ -462,26 +462,27 @@ def test_write_mrci_input_file(self):
     def test_write_input_file_mrcc_routing(self):
         """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::
+        For an open-shell wavefunction, the SCF reference is switched from
+        ``{hf;...}`` (which gives Molpro's ROHF for open-shell) to
+        ``{uhf;...}``. MRCC's approximate-CC family (``CCSDT(Q)``,
+        ``CCSDTQ(P)``, and the perturbative-``(T)`` variants) 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.
+        UHF orbitals are semicanonical by construction (alpha and beta Fock
+        matrices are separately diagonal), saved to the default record 2100.2
+        which MRCC reads — MRCC then reports ``Type=UHF/CANONICAL`` and runs
+        the requested approximate-CC method.
         """
         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.
+        # spc1 has multiplicity=3 (open-shell triplet) — UHF reference expected.
         expected_ccsdt = """***,spc1
 memory,Total=438,m;
 
@@ -496,12 +497,11 @@ def test_write_input_file_mrcc_routing(self):
 
 int;
 
-{hf;
+{uhf;
  maxit,999;
  wf,spin=2,charge=0;
 }
 
-{uccsd}
 {mrcc,method=CCSDT}
 
 
@@ -513,13 +513,12 @@ 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)
+        # An earlier (insufficient) fix used `{uccsd}` between HF and MRCC —
+        # this contract has been replaced with UHF, so {uccsd} must NOT appear.
+        self.assertNotIn('{uccsd}', content_ccsdt)
+        # UHF must replace HF as the only SCF reference (no {hf;...} block).
+        self.assertNotIn('{hf;', content_ccsdt)
+        self.assertIn('{uhf;', content_ccsdt)
 
         self.job_mrcc_ccsdtq.cpu_cores = 48
         self.job_mrcc_ccsdtq.set_input_file_memory()
@@ -555,9 +554,11 @@ 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.
+        # spc1 here has multiplicity=1 (closed-shell) — RHF gives canonical
+        # orbitals MRCC accepts directly. No UHF/UCCSD pre-step needed.
         self.assertNotIn('{uccsd}', content_ccsdtq)
+        self.assertNotIn('{uhf;', content_ccsdtq)
+        self.assertIn('{hf;', content_ccsdtq)
 
     def test_set_files(self):
         """Test setting files"""

arc/molecule/translator.py

@@ -553,7 +553,11 @@ def _write(mol, identifier_type, backend):
             logger.warning(f"Unexpected error from backend '{option}': {e}")
             continue
 
-    logger.error(f"Unable to generate identifier '{identifier_type}' for this molecule:\n{mol.to_adjacency_list()}")
+    logger.warning(
+        f"Unable to generate identifier '{identifier_type}' for this molecule "
+        f"(structure may be fragmented or carry anomalous formal charges):\n"
+        f"{mol.to_adjacency_list()}"
+    )
     raise ValueError(f"Unable to generate identifier type '{identifier_type}' with backend(s): {backend}")