Update

Author: calvinp0

arc/statmech/arkane.py

@@ -688,18 +688,9 @@ def _section_contains_key(file_path: str, section_start: str, section_end: str,
 
 def _get_qm_corrections_files() -> List[str]:
     """
-    Return quantum corrections data.py paths, preferring ARC-local data.
-
-    Preference order:
-      1) ARC-local database/data directories (if present)
-      2) RMG-database
+    Return quantum corrections data.py paths from the RMG database.
     """
     candidates = [
-        os.path.join(ARC_PATH, 'arc', 'database', 'input', 'quantum_corrections', 'data.py'),
-        os.path.join(ARC_PATH, 'arc', 'database', 'quantum_corrections', 'data.py'),
-        os.path.join(ARC_PATH, 'arc', 'data', 'input', 'quantum_corrections', 'data.py'),
-        os.path.join(ARC_PATH, 'arc', 'data', 'quantum_corrections', 'data.py'),
-        os.path.join(ARC_PATH, 'data', 'quantum_corrections.py'),
         os.path.join(RMG_DB_PATH, 'input', 'quantum_corrections', 'data.py'),
     ]
     return [path for path in candidates if os.path.isfile(path)]
@@ -785,7 +776,7 @@ def _iter_level_keys_from_section(file_path: str,
 def _available_years_for_level(level: "Level",
                                file_path: str,
                                section_start: str,
-                               section_end: str) -> list[Optional[int]]:
+                               section_end: str) -> List[Optional[int]]:
     """
     Return a sorted list of available year suffixes for a given Level in a section.
     """
@@ -826,7 +817,7 @@ def _available_years_for_level(level: "Level",
     return sorted(years, key=lambda y: (-1 if y is None else y))
 
 
-def _format_years(years: list[Optional[int]]) -> str:
+def _format_years(years: List[Optional[int]]) -> str:
     """
     Format a list of years for logging.
     """
@@ -851,7 +842,14 @@ def _find_best_level_key_for_sp_level(level: "Level",
 
     target_method_norm = _normalize_method(level.method)
     target_base, method_year = _split_method_year(target_method_norm)
-    target_year = getattr(level, 'year', None) if getattr(level, 'year', None) is not None else method_year
+    explicit_year = getattr(level, 'year', None)
+    if explicit_year is not None and method_year is not None and explicit_year != method_year:
+        raise InputError(
+            f"Conflicting year specifications for level '{level}': "
+            f"explicit year={explicit_year}, method suffix year={method_year}. "
+            "Please remove the year suffix from the method name or update the 'year' attribute to match."
+        )
+    target_year = explicit_year if explicit_year is not None else method_year
     target_basis_norm = _normalize_basis(level.basis)
     target_software = level.software.lower() if level.software else None
 
@@ -933,14 +931,16 @@ def get_arkane_model_chemistry(sp_level: 'Level',
     """
     Get Arkane model chemistry string with database validation.
 
-    Reads quantum_corrections/data.py as plain text (prefers ARC-local overrides,
-    then RMG-database), searches for
+    Reads quantum_corrections/data.py as plain text, searches for
     LevelOfTheory(...) keys, and matches:
       - method:   ignoring hyphens and optional 4-digit year suffix
       - basis:    ignoring hyphens and spaces
 
-    If multiple entries only differ by year, the one with the *latest* year
-    is chosen (year=0 if no year in that entry).
+    When a year is explicitly specified in the Level, only entries with that exact
+    year are matched. If no year is specified and an entry without a year exists,
+    that entry is used. Only when no year is specified and no no-year entry exists,
+    if multiple entries differ only by year, the one with the *latest* year is
+    chosen (treating entries with no year as year=0).
 
     Args:
         sp_level (Level): Level of theory for energy.
@@ -981,7 +981,8 @@ def get_arkane_model_chemistry(sp_level: 'Level',
                     f"available years: {_format_years(years)}. "
                     f"Specify a year to select a matching entry."
                 )
-            return _level_to_str(sp_level)
+            # No matching AEC level in Arkane DB for this composite method
+            return None
         return best_energy
 
     # ---- Case 1: User supplied explicit frequency scale factor ----
@@ -1074,8 +1075,7 @@ def check_arkane_bacs(sp_level: 'Level',
     """
     Check that Arkane has AECs and BACs for the given sp level of theory.
 
-    Uses plain-text parsing of quantum_corrections/data.py (prefers ARC-local overrides,
-    then RMG-database), matching LevelOfTheory
+    Uses plain-text parsing of quantum_corrections/data.py, matching LevelOfTheory
     keys by:
       - method base (ignore hyphens + optional year)
       - basis (normalized)

arc/statmech/arkane_test.py

@@ -7,16 +7,29 @@
 
 import os
 import shutil
+import tempfile
 import unittest
 
+from arc.exceptions import InputError
 from arc.common import ARC_PATH
 from arc.level import Level
 from arc.reaction import ARCReaction
 from arc.species import ARCSpecies
 from arc.statmech.adapter import StatmechEnum
 from arc.statmech.arkane import ArkaneAdapter
-from arc.statmech.arkane import _level_to_str, _section_contains_key, get_arkane_model_chemistry
-from arc.imports import settings
+from arc.statmech.arkane import (
+    _available_years_for_level,
+    _find_best_level_key_for_sp_level,
+    _get_qm_corrections_files,
+    _level_to_str,
+    _normalize_basis,
+    _normalize_method,
+    _parse_lot_params,
+    _section_contains_key,
+    _split_method_year,
+    get_arkane_model_chemistry,
+)
+from unittest.mock import patch
 
 
 class TestEnumerationClasses(unittest.TestCase):
@@ -181,6 +194,105 @@ def test_get_arkane_model_chemistry_latest_year(self):
                                                      freq_scale_factor=1.0)
         self.assertEqual(model_chemistry, "LevelOfTheory(method='cbsqb3',software='gaussian')")
 
+    def test_level_helpers(self):
+        """Test helper functions for method/basis/year parsing."""
+        self.assertEqual(_normalize_method("DLPNO-CCSD(T)-F12"), "dlpnoccsd(t)f12")
+        self.assertEqual(_normalize_method("dlpnoccsd(t)f122023"), "dlpnoccsd(t)f122023")
+
+        base, year = _split_method_year("dlpnoccsd(t)f122023")
+        self.assertEqual(base, "dlpnoccsd(t)f12")
+        self.assertEqual(year, 2023)
+        base, year = _split_method_year("dlpnoccsd(t)f12")
+        self.assertEqual(base, "dlpnoccsd(t)f12")
+        self.assertIsNone(year)
+
+        self.assertEqual(_normalize_basis("cc-pVTZ-F12"), "ccpvtzf12")
+        self.assertEqual(_normalize_basis("ccpvtz f12"), "ccpvtzf12")
+
+        params = _parse_lot_params(
+            "LevelOfTheory(method='dlpnoccsd(t)f122023',basis='ccpvtzf12',software='orca')"
+        )
+        self.assertEqual(params["method"], "dlpnoccsd(t)f122023")
+        self.assertEqual(params["basis"], "ccpvtzf12")
+        self.assertEqual(params["software"], "orca")
+
+    def test_level_key_selection(self):
+        """Test matching of LevelOfTheory keys by year and no-year preference."""
+        section = '\n'.join([
+            'atom_energies = {',
+            "    \"LevelOfTheory(method='cbsqb3',software='gaussian')\": {},",
+            "    \"LevelOfTheory(method='cbsqb32023',software='gaussian')\": {},",
+            "}",
+            "pbac = {",
+        ])
+        with tempfile.NamedTemporaryFile(mode="w+", delete=False) as f:
+            f.write(section)
+            path = f.name
+        try:
+            level = Level(method="CBS-QB3", software="gaussian")
+            best = _find_best_level_key_for_sp_level(level, path, "atom_energies = {", "pbac = {")
+            self.assertEqual(best, "LevelOfTheory(method='cbsqb3',software='gaussian')")
+
+            level_year = Level(method="CBS-QB3", software="gaussian", year=2023)
+            best_year = _find_best_level_key_for_sp_level(level_year, path, "atom_energies = {", "pbac = {")
+            self.assertEqual(best_year, "LevelOfTheory(method='cbsqb32023',software='gaussian')")
+
+            years = _available_years_for_level(level, path, "atom_energies = {", "pbac = {")
+            self.assertEqual(years, [None, 2023])
+        finally:
+            os.remove(path)
+
+    def test_conflicting_year_spec(self):
+        """Test conflicting year in method suffix vs explicit year."""
+        section = '\n'.join([
+            'atom_energies = {',
+            "    \"LevelOfTheory(method='b97d32023',software='gaussian')\": {},",
+            "}",
+            "pbac = {",
+        ])
+        with tempfile.NamedTemporaryFile(mode="w+", delete=False) as f:
+            f.write(section)
+            path = f.name
+        try:
+            level = Level(method="b97d32023", software="gaussian", year=2022)
+            with self.assertRaises(InputError):
+                _find_best_level_key_for_sp_level(level, path, "atom_energies = {", "pbac = {")
+        finally:
+            os.remove(path)
+
+    def test_qm_corrections_file_path(self):
+        """Test quantum corrections files are read from the RMG database path."""
+        with tempfile.TemporaryDirectory() as rmg_root:
+            rmg_qc = os.path.join(rmg_root, 'input', 'quantum_corrections', 'data.py')
+            os.makedirs(os.path.dirname(rmg_qc), exist_ok=True)
+            with open(rmg_qc, 'w') as f:
+                f.write('# rmg qc\n')
+
+            with patch('arc.statmech.arkane.RMG_DB_PATH', rmg_root):
+                paths = _get_qm_corrections_files()
+                self.assertTrue(paths)
+                self.assertEqual(paths[0], rmg_qc)
+
+    def test_get_arkane_model_chemistry_from_qm_file(self):
+        """Test reading LevelOfTheory keys from a quantum corrections file."""
+        section = '\n'.join([
+            'atom_energies = {',
+            "    \"LevelOfTheory(method='cbsqb3',software='gaussian')\": {},",
+            "}",
+            "pbac = {",
+        ])
+        with tempfile.NamedTemporaryFile(mode="w+", delete=False) as f:
+            f.write(section)
+            path = f.name
+        try:
+            with patch('arc.statmech.arkane._get_qm_corrections_files', return_value=[path]):
+                model_chemistry = get_arkane_model_chemistry(
+                    sp_level=Level(method='CBS-QB3'),
+                    freq_scale_factor=1.0,
+                )
+            self.assertEqual(model_chemistry, "LevelOfTheory(method='cbsqb3',software='gaussian')")
+        finally:
+            os.remove(path)
     def test_generate_arkane_input(self):
         """Test generating Arkane input"""
         statmech_dir = os.path.join(ARC_PATH, 'arc', 'testing', 'arkane_input_tests_delete')

docs/source/advanced.rst

@@ -154,8 +154,9 @@ is equivalent to::
     sp_level = {'method': 'wb97xd', 'basis': 'def2svp'}
 
 Note: Year suffixes in the method (e.g., ``wb97xd32023``) are meant for Arkane database matching
-and are not valid QC methods. Do not include year suffixes in ``level_of_theory``; instead, set
-``arkane_level_of_theory`` with a ``year`` value if you need a specific correction year.
+and are not valid QC methods. Do not include year suffixes in ``level_of_theory``; instead, specify a
+``year`` key on ``sp_level`` if you need a specific correction year. ``arkane_level_of_theory`` can still
+be used to explicitly override Arkane behavior.
 
 Note: If ``level_of_theory`` does not contain any deliminator (neither ``//`` nor ``\/``), it is interpreted as a
 composite method.

docs/source/examples.rst

@@ -86,9 +86,8 @@ To specify a composite method, simply define something like::
 
 Note: Do not include year suffixes in ``level_of_theory`` (e.g., ``wb97xd32023``). Year suffixes are
 for Arkane database matching only and are not valid QC methods. If you need a specific correction year,
-set ``arkane_level_of_theory`` with a ``year`` value instead.
-If ``year`` is omitted, ARC will prefer the no-year Arkane entry for that method/basis; if none exists,
-ARC will fall back to the latest available year in the Arkane database.
+specify a ``year`` key on ``sp_level``. If ``year`` is omitted, ARC will prefer the no-year Arkane entry for
+that method/basis; if none exists, ARC will fall back to the latest available year in the Arkane database.
 
 Note that for composite methods the ``freq_level`` and ``scan_level`` may have different
 default values than for non-composite methods (defined in settings.py). Note: an independent