Consolidating Ouput (#853)

ARC has had a very complex output and requires knowledge of how to
navigate the folder structure and files in order to find the data you
need.

This consolidation is an attempt to bring all that information to one
place in an easy to read format. Additionally it is paves the path for
ease of use with TCKDB

Author: alongd

arc/job/adapters/ts/orca_neb.py

@@ -31,7 +31,7 @@
 
 input_filenames, output_filenames, servers, submit_filenames, orca_neb_settings = \
     settings['input_filenames'], settings['output_filenames'], settings['servers'], settings['submit_filenames'], \
-    settings['orca_neb_settings']
+    settings.get('orca_neb_settings', {})
 
 
 input_template = """
@@ -328,6 +328,7 @@ def process_run(self):
         if os.path.isfile(self.local_path_to_output_file):
             tsg.initial_xyz = parse_geometry(self.local_path_to_output_file)
             tsg.execution_time = self.final_time - self.initial_time
+            tsg.log_path = self.local_path_to_output_file
             tsg.success = True
         self.reactions[0].ts_species.ts_guesses.append(tsg)
 

arc/level.py

@@ -459,10 +459,12 @@ def assign_frequency_scale_factor(level: Union[str, Level]) -> Optional[int]:
     """
     freq_scale_factors = read_yaml_file(os.path.join(ARC_PATH, 'data', 'freq_scale_factors.yml'))['freq_scale_factors']
     if isinstance(level, str):
-        if level in freq_scale_factors:
-            return freq_scale_factors[level]
+        entry = freq_scale_factors.get(level)
+        if entry is not None:
+            return entry['factor'] if isinstance(entry, dict) else entry
         level = Level(repr=level)
     level_str = str(level)
-    if level_str in freq_scale_factors:
-        return freq_scale_factors[level_str]
+    entry = freq_scale_factors.get(level_str)
+    if entry is not None:
+        return entry['factor'] if isinstance(entry, dict) else entry
     return None

arc/main.py

@@ -34,7 +34,8 @@
 from arc.level import Level, assign_frequency_scale_factor
 from arc.job.factory import _registered_job_adapters
 from arc.job.ssh import SSHClient
-from arc.processor import process_arc_project
+from arc.output import write_output_yml
+from arc.processor import process_arc_project, resolve_neb_level
 from arc.reaction import ARCReaction
 from arc.scheduler import Scheduler
 from arc.species.converter import str_to_xyz
@@ -637,6 +638,35 @@ def execute(self) -> dict:
                             skip_nmd=self.skip_nmd,
                             )
 
+        # Determine whether the user supplied the scale factor explicitly, or ARC looked it up.
+        _freq_level_for_lookup = self.composite_method if self.composite_method is not None else self.freq_level
+        _yml_scale = assign_frequency_scale_factor(level=_freq_level_for_lookup) if _freq_level_for_lookup is not None else None
+        _user_provided_scale = (_yml_scale is None or _yml_scale != self.freq_scale_factor)
+
+        neb_level = resolve_neb_level(self.ts_adapters)
+
+        try:
+            write_output_yml(
+                project=self.project,
+                project_directory=self.project_directory,
+                species_dict=self.scheduler.species_dict,
+                reactions=self.scheduler.rxn_list,
+                output_dict=self.output,
+                opt_level=self.opt_level,
+                freq_level=self.freq_level,
+                sp_level=self.sp_level,
+                neb_level=neb_level,
+                composite_method=self.composite_method,
+                freq_scale_factor=self.freq_scale_factor,
+                freq_scale_factor_user_provided=_user_provided_scale,
+                bac_type=self.bac_type,
+                arkane_level_of_theory=self.arkane_level_of_theory,
+                irc_requested=self.job_types.get('irc', True),
+                t0=self.t0,
+            )
+        except Exception as e:
+            logger.error(f'Could not write output.yml: {e}')
+
         status_dict = self.summary()
         log_footer(execution_time=self.execution_time)
         return status_dict
@@ -1174,10 +1204,10 @@ def check_arkane_level_of_theory(self):
         if self.arkane_level_of_theory is None:
             self.arkane_level_of_theory = self.composite_method if self.composite_method is not None \
                 else self.sp_level if self.sp_level is not None else None
-        if self.arkane_level_of_theory is not None and self.bac_type is not None:
-            check_arkane_bacs(sp_level=self.arkane_level_of_theory, bac_type=self.bac_type, raise_error=self.compute_thermo)
-        else:
+        if self.arkane_level_of_theory is None:
             logger.warning('Could not determine a level of theory to be used for Arkane!')
+        elif self.bac_type is not None:
+            check_arkane_bacs(sp_level=self.arkane_level_of_theory, bac_type=self.bac_type, raise_error=self.compute_thermo)
 
     def backup_restart(self):
         """