Added user option to provide verytight which will replace tight

Author: calvinp0

arc/job/adapters/gaussian.py

@@ -211,6 +211,32 @@ def __init__(self,
             elif self.species[0].checkfile is not None and os.path.isfile(self.species[0].checkfile):
                 self.checkfile = self.species[0].checkfile
 
+    def _user_requested_verytight(self) -> bool:
+        """
+        Return True if the user passed ``verytight`` through ``self.args``.
+
+        When True, the fine-mode opt-keyword builder will skip auto-adding
+        ``tight`` so the user's ``verytight`` wins unambiguously in the final
+        ``opt=(...)`` clause assembled by ``combine_parameters``.
+
+        Scope: only the ``keyword`` channel is meaningful here — ``block`` is for
+        Gaussian input blocks and ``trsh`` is for ARC's troubleshooting layer,
+        neither of which is the right place for a user opt-cutoff override.
+
+        Notes for the implementer:
+            - ``self.args['keyword']`` is a ``dict[str, str]`` (see
+              ``Level._check_args`` at arc/level.py:281). Values may be in any
+              case and may contain other keywords too (e.g. ``"opt=(verytight)
+              freq=hpmodes"``).
+            - Match must be word-bounded: a stray ``verytightscf`` should not
+              count, and ``tight`` alone must NOT match.
+            - Be defensive: ``self.args`` or ``self.args['keyword']`` may be
+              missing or empty depending on how the Level was constructed.
+        """
+        keyword_args = (self.args or {}).get('keyword') or {}
+        joined = ' '.join(str(v) for v in keyword_args.values())
+        return re.search(r'\bverytight\b', joined, re.IGNORECASE) is not None
+
     def write_input_file(self) -> None:
         """
         Write the input file to execute the job on the server.
@@ -299,10 +325,11 @@ def write_input_file(self) -> None:
                         if input_dict['trsh']:
                             input_dict['trsh'] += ' '
                         input_dict['trsh'] += 'scf=(tight,direct)'
+                tight_kw = [] if self._user_requested_verytight() else ['tight']
                 if self.is_ts:
-                    keywords.extend(['tight', 'maxstep=5'])
+                    keywords.extend([*tight_kw, 'maxstep=5'])
                 else:
-                    keywords.extend(['tight', 'maxstep=5', f'maxcycle={max_c}'])
+                    keywords.extend([*tight_kw, 'maxstep=5', f'maxcycle={max_c}'])
             input_dict['job_type_1'] = "opt" if self.level.method_type not in ['dft', 'composite', 'wavefunction']\
                 else f"opt=({', '.join(key for key in keywords)})"
 

arc/job/adapters/gaussian_test.py

@@ -1161,6 +1161,28 @@ def test_trsh_write_input_file(self):
 
         self.assertEqual(content_24, job_24_expected_input_file)
 
+    def test_user_requested_verytight(self):
+        """Detection only fires for word-bounded ``verytight`` in the keyword channel."""
+        cases = [
+            ({'keyword': {'opt': 'opt=(verytight)'}, 'block': {}, 'trsh': {}}, True),
+            ({'keyword': {'opt': 'opt=(VeryTight)'}, 'block': {}, 'trsh': {}}, True),
+            ({'keyword': {'general': 'opt=(calcfc)'}, 'block': {}, 'trsh': {}}, False),
+            ({'keyword': {'opt': 'opt=(tight)'}, 'block': {}, 'trsh': {}}, False),
+            ({'keyword': {'general': 'verytightscf'}, 'block': {}, 'trsh': {}}, False),
+            ({'keyword': {}, 'block': {}, 'trsh': {}}, False),
+            # verytight smuggled in via block/trsh must not count
+            ({'keyword': {}, 'block': {'1': 'opt=(verytight)'}, 'trsh': {}}, False),
+            ({'keyword': {}, 'block': {}, 'trsh': {'opt': 'opt=(verytight)'}}, False),
+        ]
+        original_args = self.job_3.args
+        try:
+            for args, expected in cases:
+                with self.subTest(args=args):
+                    self.job_3.args = args
+                    self.assertEqual(self.job_3._user_requested_verytight(), expected)
+        finally:
+            self.job_3.args = original_args
+
 
     @classmethod
     def tearDownClass(cls):