CREST Adapter

Makefile

@@ -36,6 +36,7 @@ help:
 	@echo "  install-kinbot   Install KinBot"
 	@echo "  install-sella    Install Sella"
 	@echo "  install-xtb      Install xTB"
+	@echo "  install-crest    Install CREST"
 	@echo "  install-torchani Install TorchANI"
 	@echo "  install-ob       Install OpenBabel"
 	@echo ""
@@ -100,6 +101,9 @@ install-sella:
 install-xtb:
 	bash $(DEVTOOLS_DIR)/install_xtb.sh
 
+install-crest:
+	bash $(DEVTOOLS_DIR)/install_crest.sh
+
 install-torchani:
 	bash $(DEVTOOLS_DIR)/install_torchani.sh
 

arc/constants.pxd

@@ -1 +1 @@
-cdef double pi, Na, kB, R, h, hbar, c, e, m_e, m_p, m_n, amu, a0, bohr_to_angstrom, E_h, F, E_h_kJmol
+cdef double pi, Na, kB, R, h, hbar, c, e, m_e, m_p, m_n, amu, a0, E_h, F, E_h_kJmol, bohr_to_angstrom, angstrom_to_bohr

arc/constants.py

@@ -41,7 +41,7 @@
 
 #: The Bohr radius :math:`a_0` in :math:`\mathrm{m}`
 a0 = 5.2917721092e-11
 bohr_to_angstrom = a0 * 1e10
 
 #: The atomic mass unit in :math:`\mathrm{kg}`
 amu = 1.660538921e-27
@@ -79,6 +79,9 @@
 #: Vacuum permittivity
 epsilon_0 = 8.8541878128
 
+bohr_to_angstrom = 0.529177
+angstrom_to_bohr = 1 / bohr_to_angstrom
+
 # Cython does not automatically place module-level variables into the module
 # symbol table when in compiled mode, so we must do this manually so that we
 # can use the constants from both Cython and regular Python code
@@ -101,4 +104,5 @@
     'F': F,
     'epsilon_0': epsilon_0,
     'bohr_to_angstrom': bohr_to_angstrom,
+    'angstrom_to_bohr': angstrom_to_bohr,
 })

arc/job/adapter.py

@@ -96,6 +96,7 @@ class JobEnum(str, Enum):
     # TS search methods
     autotst = 'autotst'  # AutoTST, 10.1021/acs.jpca.7b07361, 10.26434/chemrxiv.13277870.v2
     heuristics = 'heuristics'  # ARC's heuristics
+    crest = 'crest'  # CREST conformer/TS search
     kinbot = 'kinbot'  # KinBot, 10.1016/j.cpc.2019.106947
     gcn = 'gcn'  # Graph neural network for isomerization, https://doi.org/10.1021/acs.jpclett.0c00500
     user = 'user'  # user guesses
@@ -780,8 +781,7 @@ def _get_additional_job_info(self):
                     content += '\n'
         else:
             raise ValueError(f'Unrecognized cluster software: {cluster_soft}')
-        if content:
-            self.additional_job_info = content.lower()
+        self.additional_job_info = content.lower() if content else None
 
     def _check_job_server_status(self) -> str:
         """
@@ -801,6 +801,10 @@ def _check_job_ess_status(self):
         Raises:
             IOError: If the output file and any additional server information cannot be found.
         """
+        existing_keywords = list(self.job_status[1].get('keywords', list()))
+        # Refresh scheduler-side logs before ESS parsing so server-reported OOMs
+        # can be detected even when the output file is absent or incomplete.
+        self._get_additional_job_info()
         if self.server != 'local' and self.execution_type != 'incore':
             if os.path.exists(self.local_path_to_output_file):
                 os.remove(self.local_path_to_output_file)
@@ -839,7 +843,22 @@ def _check_job_ess_status(self):
                                                                      )
         else:
             status, keywords, error, line = '', '', '', ''
+            if self.additional_job_info:
+                try:
+                    status, keywords, error, line = determine_ess_status(
+                        output_path=self.local_path_to_output_file,
+                        species_label=self.species_label,
+                        job_type=self.job_type,
+                        job_log=self.additional_job_info,
+                        software=self.job_adapter,
+                    )
+                except FileNotFoundError:
+                    status, keywords, error, line = '', '', '', ''
         self.job_status[1]['status'] = status
+        if 'max_total_job_memory' in existing_keywords and status == 'errored' \
+                and isinstance(keywords, list) and 'Memory' in keywords \
+                and 'max_total_job_memory' not in keywords:
+            keywords.append('max_total_job_memory')
         self.job_status[1]['keywords'] = keywords
         self.job_status[1]['error'] = error
         self.job_status[1]['line'] = line.rstrip()

arc/job/adapter_test.py

@@ -180,6 +180,12 @@ def setUpClass(cls):
                                     server='server3',
                                     testing=True,
                                     )
+        os.makedirs(cls.job_5.local_path, exist_ok=True)
+        fixture_path = os.path.join(ARC_TESTING_PATH, 'trsh', 'wall_exceeded.txt')
+        with open(fixture_path, 'r') as f:
+            log_content = f.read()
+        with open(os.path.join(cls.job_5.local_path, 'out.txt'), 'w') as f:
+            f.write(log_content)
         cls.job_6 = GaussianAdapter(execution_type='queue',
                                     job_name='opt_101',
                                     job_type='opt',
@@ -248,6 +254,24 @@ def test_set_cpu_and_mem(self):
         self.assertEqual(self.job_4.submit_script_memory, expected_memory)
         self.job_4.server = 'local'
 
+    def test_set_cpu_and_mem_marks_max_total_job_memory(self):
+        """Test tagging jobs whose requested memory is clipped to the node cap."""
+        job = GaussianAdapter(execution_type='queue',
+                              job_type='opt',
+                              level=Level(method='cbs-qb3'),
+                              project='test',
+                              project_directory=os.path.join(ARC_TESTING_PATH, 'test_JobAdapter'),
+                              species=[ARCSpecies(label='spc1', xyz=['O 0 0 1'])],
+                              server='server2',
+                              job_memory_gb=300,
+                              testing=True,
+                              )
+
+        job.set_cpu_and_mem()
+
+        self.assertAlmostEqual(job.job_memory_gb, 256 * 0.95)
+        self.assertIn('max_total_job_memory', job.job_status[1]['keywords'])
+
     def test_set_file_paths(self):
         """Test setting up the job's paths"""
         self.assertEqual(self.job_1.local_path, os.path.join(self.job_1.project_directory, 'calcs', 'Species',
@@ -321,6 +345,42 @@ def test_determine_job_status(self):
         self.assertEqual(self.job_5.job_status[1]['status'], 'errored')
         self.assertEqual(self.job_5.job_status[1]['keywords'], ['ServerTimeLimit'])
 
+    @patch('arc.job.adapter.determine_ess_status')
+    def test_preserve_max_total_job_memory_keyword(self, mock_determine_ess_status):
+        """Test preserving the max_total_job_memory marker across ESS status parsing."""
+        self.job_4.job_status[1]['keywords'] = ['max_total_job_memory']
+        self.job_4.initial_time = datetime.datetime.now() - datetime.timedelta(minutes=2)
+        self.job_4.final_time = datetime.datetime.now() - datetime.timedelta(minutes=1)
+        os.makedirs(self.job_4.local_path, exist_ok=True)
+        with open(self.job_4.local_path_to_output_file, 'w') as f:
+            f.write('dummy output')
+        mock_determine_ess_status.return_value = (
+            'errored',
+            ['MDCI', 'Memory'],
+            'Insufficient job memory.',
+            'Please increase MaxCore',
+        )
+
+        self.job_4._check_job_ess_status()
+
+        self.assertEqual(self.job_4.job_status[1]['status'], 'errored')
+        self.assertEqual(self.job_4.job_status[1]['keywords'], ['MDCI', 'Memory', 'max_total_job_memory'])
+
+    def test_check_job_ess_status_without_output_uses_job_log_memory_error(self):
+        """Test detecting server-reported memory errors even when the output file is absent."""
+        if os.path.isfile(self.job_4.local_path_to_output_file):
+            os.remove(self.job_4.local_path_to_output_file)
+        self.job_4.initial_time = datetime.datetime.now() - datetime.timedelta(minutes=2)
+        self.job_4.final_time = datetime.datetime.now() - datetime.timedelta(minutes=1)
+        self.job_4.additional_job_info = '\tMEMORY EXCEEDED\n'
+
+        with patch.object(self.job_4, '_get_additional_job_info'):
+            self.job_4._check_job_ess_status()
+
+        self.assertEqual(self.job_4.job_status[1]['status'], 'errored')
+        self.assertEqual(self.job_4.job_status[1]['keywords'], ['Memory'])
+        self.assertEqual(self.job_4.job_status[1]['error'], 'Insufficient job memory.')
+
     @patch(
         "arc.job.trsh.servers",
         {

arc/job/adapters/orca.py

@@ -84,13 +84,14 @@ def _format_orca_basis(basis: str) -> str:
 # job_type_2: reserved for Opt + Freq.
 # restricted: 'R' = closed-shell SCF, 'U' = spin unrestricted SCF, 'RO' = open-shell spin restricted SCF
 # auxiliary_basis: required for DLPNO calculations (speed up calculation)
+# cabs: Complementary Auxiliary Basis Set for F12 calculations (e.g., cc-pVTZ-F12-CABS)
 # memory: MB per core (must increase as system gets larger)
 # cpus: must be less than number of electron pairs, defaults to min(heavy atoms, cpus limit)
 # job_options_blocks: input blocks that enable detailed control over program
 # job_options_keywords: input keywords that control the job
 # method_class: 'HF' for wavefunction methods (hf, mp, cc, dlpno ...). 'KS' for DFT methods.
 # options: additional keywords to control job (e.g., TightSCF, NormalPNO ...)
-input_template = """!${restricted}${method_class} ${method} ${basis} ${auxiliary_basis} ${keywords}
+input_template = """!${restricted}${method_class} ${method} ${basis} ${auxiliary_basis}${cabs} ${keywords}
 !${job_type_1} 
 ${job_type_2}
 %%maxcore ${memory}
@@ -254,6 +255,12 @@ def write_input_file(self) -> None:
         """
         Write the input file to execute the job on the server.
         """
+        if 'f12' in self.level.method and not self.level.cabs:
+            raise ValueError(
+                f"Level '{self.level}' uses an F12 method without a CABS basis. "
+                f"Set `cabs:` in the level spec (e.g. cc-pVTZ-F12-CABS). "
+                f"Without it ORCA runs with DimCABS = 0 and returns non-F12 energies."
+            )
         input_dict = dict()
         for key in ['block',
                     'scan',
@@ -264,6 +271,7 @@ def write_input_file(self) -> None:
             input_dict[key] = ''
         input_dict['auxiliary_basis'] = _format_orca_basis(self.level.auxiliary_basis or '')
         input_dict['basis'] = _format_orca_basis(self.level.basis or '')
+        input_dict['cabs'] = f' {_format_orca_basis(self.level.cabs)}' if self.level.cabs else ''
         input_dict['charge'] = self.charge
         input_dict['cpus'] = self.cpu_cores
         input_dict['label'] = self.species_label
@@ -272,30 +280,28 @@ def write_input_file(self) -> None:
         input_dict['multiplicity'] = self.multiplicity
         input_dict['xyz'] = xyz_to_str(self.xyz)
 
-        scf_convergence = self.args['keyword'].get('scf_convergence', '').lower() or \
-            orca_default_options_dict['global']['keyword'].get('scf_convergence', '').lower()
-        if not scf_convergence:
+        self.args['keyword'].setdefault(
+            'scf_convergence',
+            orca_default_options_dict['global']['keyword'].get('scf_convergence', '').lower())
+        if not self.args['keyword']['scf_convergence']:
             raise ValueError('Orca SCF convergence is not specified. Please specify this variable either in '
                              'settings.py as default or in the input file as additional options.')
-        self.add_to_args(val=scf_convergence, key1='keyword')
 
         # Orca requires different blocks for wavefunction methods and DFT methods
         if self.level.method_type == 'dft':
             input_dict['method_class'] = 'KS'
-            # DFT grid must be the same for both opt and freq
-            if self.fine:
-                self.add_to_args(val='defgrid3', key1='keyword')
-            else:
-                self.add_to_args(val='defgrid2', key1='keyword')
+            # DFT grid must be the same for both opt and freq.
+            # Users can override by setting `dft_grid` in args.keyword (e.g. dft_grid: DEFGRID1).
+            self.args['keyword'].setdefault('dft_grid', 'defgrid3' if self.fine else 'defgrid2')
         elif self.level.method_type == 'wavefunction':
             input_dict['method_class'] = 'HF'
             if 'dlpno' in self.level.method:
-                dlpno_threshold = self.args['keyword'].get('dlpno_threshold', '').lower() or \
-                    orca_default_options_dict['global']['keyword'].get('dlpno_threshold', '').lower()
-                if not dlpno_threshold:
+                self.args['keyword'].setdefault(
+                    'dlpno_threshold',
+                    orca_default_options_dict['global']['keyword'].get('dlpno_threshold', '').lower())
+                if not self.args['keyword']['dlpno_threshold']:
                     raise ValueError('Orca DLPNO threshold is not specified. Please specify this variable either in '
                                      'settings.py as default or in the input file as additional options.')
-                self.add_to_args(val=dlpno_threshold, key1='keyword')
         else:
             logger.debug(f'Running {self.level.method_type} {self.level.method} method in Orca.')
 

arc/job/adapters/orca_test.py

@@ -99,6 +99,34 @@ def test_set_input_file_memory(self):
         expected_memory = math.ceil(14 * 1024 / 8)
         self.assertEqual(self.job_1.input_file_memory, expected_memory)
 
+    def test_set_input_file_memory_with_configured_core_count(self):
+        """Test ORCA %%maxcore calculation for a configured total memory and cpu count."""
+        original_memory = self.job_1.job_memory_gb
+        original_cpu_cores = self.job_1.cpu_cores
+        self.job_1.job_memory_gb = 250
+        self.job_1.cpu_cores = 22
+        self.job_1.set_input_file_memory()
+        self.assertEqual(self.job_1.input_file_memory, math.ceil(250 * 1024 / 22))
+        self.job_1.job_memory_gb = original_memory
+        self.job_1.cpu_cores = original_cpu_cores
+        self.job_1.set_input_file_memory()
+
+    def test_write_input_file_with_configured_core_count(self):
+        """Test rendering ORCA input for a configured total memory and cpu count."""
+        original_memory = self.job_1.job_memory_gb
+        original_cpu_cores = self.job_1.cpu_cores
+        self.job_1.job_memory_gb = 250
+        self.job_1.cpu_cores = 22
+        self.job_1.set_input_file_memory()
+        self.job_1.write_input_file()
+        with open(os.path.join(self.job_1.local_path, input_filenames[self.job_1.job_adapter]), 'r') as f:
+            content = f.read()
+        self.assertIn('%maxcore 11637', content)
+        self.assertIn('%pal nprocs 22 end', content)
+        self.job_1.job_memory_gb = original_memory
+        self.job_1.cpu_cores = original_cpu_cores
+        self.job_1.set_input_file_memory()
+
     def test_write_input_file(self):
         """Test writing Orca input files"""
         self.job_1.write_input_file()

arc/job/adapters/ts/__init__.py

@@ -1,6 +1,8 @@
 import arc.job.adapters.ts.autotst_ts
+import arc.job.adapters.ts.crest
 import arc.job.adapters.ts.gcn_ts
 import arc.job.adapters.ts.heuristics
 import arc.job.adapters.ts.kinbot_ts
+import arc.job.adapters.ts.seed_hub
 import arc.job.adapters.ts.xtb_gsm
 import arc.job.adapters.ts.orca_neb