Updates

Author: calvinp0

arc/main.py

@@ -36,6 +36,7 @@
 from arc.job.ssh import SSHClient
 from arc.output import write_output_yml
 from arc.processor import process_arc_project, resolve_neb_level
+from arc.provenance import DecisionKind, EdgeType
 from arc.reaction import ARCReaction
 from arc.scheduler import Scheduler
 from arc.species.converter import str_to_xyz
@@ -671,6 +672,70 @@ def execute(self) -> dict:
         log_footer(execution_time=self.execution_time)
         return status_dict
 
+    def _add_arkane_provenance_nodes(self):
+        """Add Arkane computation and result nodes to the provenance graph.
+
+        For each converged species with thermo results, creates:
+            convergence_confirmed → calc(statmech_thermo) → data(thermo)
+
+        For each converged reaction with kinetics results, creates:
+            convergence_confirmed → calc(statmech_kinetics) → data(kinetics)
+        """
+        graph = self.scheduler.graph
+        for spc in self.scheduler.species_dict.values():
+            if spc.is_ts or getattr(spc.thermo, 'H298', None) is None:
+                continue
+            spc_nid = graph.find_species_node(spc.label)
+            if spc_nid is None:
+                continue
+            # Insert a CalculationNode for the Arkane thermo computation.
+            calc_nid = graph.add_calculation_node(
+                label=spc.label,
+                job_name='arkane_thermo',
+                job_type='statmech_thermo',
+                job_adapter=self.thermo_adapter,
+                status='done',
+            )
+            graph.add_edge(spc_nid, calc_nid, EdgeType.belongs_to)
+            # Link from convergence gate if it exists.
+            conv_nodes = graph.query(decision_kind=DecisionKind.convergence_confirmed, label=spc.label)
+            for conv_node in conv_nodes:
+                graph.add_edge(conv_node.node_id, calc_nid, EdgeType.triggered_by)
+            thermo_nid = graph.add_data_node(
+                label=spc.label,
+                data_kind='thermo',
+                value=f'H298={spc.thermo.H298:.1f} kJ/mol, S298={spc.thermo.S298:.1f} J/mol/K',
+            )
+            graph.add_edge(calc_nid, thermo_nid, EdgeType.output_of)
+        for rxn in self.scheduler.rxn_list:
+            if rxn.kinetics is None:
+                continue
+            ts_nid = graph.find_species_node(rxn.ts_label)
+            if ts_nid is None:
+                continue
+            # Insert a CalculationNode for the Arkane kinetics computation.
+            calc_nid = graph.add_calculation_node(
+                label=rxn.ts_label,
+                job_name='arkane_kinetics',
+                job_type='statmech_kinetics',
+                job_adapter=self.kinetics_adapter,
+                status='done',
+            )
+            graph.add_edge(ts_nid, calc_nid, EdgeType.belongs_to)
+            # Link from TS convergence gate if it exists.
+            conv_nodes = graph.query(decision_kind=DecisionKind.convergence_confirmed, label=rxn.ts_label)
+            for conv_node in conv_nodes:
+                graph.add_edge(conv_node.node_id, calc_nid, EdgeType.triggered_by)
+            ea = rxn.kinetics.get('Ea')
+            ea_str = f', Ea={ea[0]:.1f} {ea[1]}' if ea else ''
+            kinetics_nid = graph.add_data_node(
+                label=rxn.ts_label,
+                data_kind='kinetics',
+                value=f'{rxn.label}{ea_str}',
+            )
+            graph.add_edge(calc_nid, kinetics_nid, EdgeType.output_of)
+        graph.save(self.scheduler.graph_path)
+
     def save_project_info_file(self):
         """
         Save a project info file.

arc/plotter.py

@@ -120,7 +120,10 @@ def render_provenance_graph(prov_graph, run_label: str = 'ARC run') -> 'graphviz
         'ts_validation_freq': 'lightyellow',
         'ts_validation_nmd': 'lightyellow',
         'ts_validation_irc': 'lightyellow',
+        'ts_validation_e0': 'lightyellow',
+        'ts_validation_e_elect': 'lightyellow',
         'ts_switch': 'mistyrose',
+        'convergence_confirmed': 'palegreen',
     }
 
     # Edge styling lookup
@@ -235,8 +238,10 @@ def render_provenance_graph(prov_graph, run_label: str = 'ARC run') -> 'graphviz
         batch_edges_added.add(edge_key)
         etype = edge.edge_type
         style_attrs = _edge_styles.get(etype, {})
-        # Only show labels on semantically interesting edges (not belongs_to, input_of, output_of).
-        label = etype.replace('_', ' ') if etype not in ('belongs_to', 'input_of', 'output_of') else ''
+        # Only show labels on semantically interesting edges; suppress purely structural ones.
+        _suppress = ('belongs_to', 'input_of', 'output_of', 'retried_as')
+        _rename = {'fine_of': 'fine grid', 'troubleshot_by': 'troubleshoot'}
+        label = _rename.get(etype, etype.replace('_', ' ')) if etype not in _suppress else ''
         gv.edge(src, tgt, label=label, **style_attrs)
 
     return gv

arc/provenance/nodes.py

@@ -55,9 +55,12 @@ class DecisionKind(str, Enum):
     ts_validation_freq = 'ts_validation_freq'
     ts_validation_nmd = 'ts_validation_nmd'
     ts_validation_irc = 'ts_validation_irc'
+    ts_validation_e0 = 'ts_validation_e0'
+    ts_validation_e_elect = 'ts_validation_e_elect'
     ts_switch = 'ts_switch'
     job_troubleshooting = 'job_troubleshooting'
     ts_method_spawning = 'ts_method_spawning'
+    convergence_confirmed = 'convergence_confirmed'
 
 
 class EdgeType(str, Enum):

arc/provenance/provenance_test.py

@@ -33,7 +33,9 @@ def test_data_kind_values(self):
     def test_decision_kind_values(self):
         expected = {'conformer_selection', 'ts_guess_clustering', 'ts_guess_selection',
                     'ts_guess_selection_failed', 'ts_validation_freq', 'ts_validation_nmd',
-                    'ts_validation_irc', 'ts_switch', 'job_troubleshooting', 'ts_method_spawning'}
+                    'ts_validation_irc', 'ts_validation_e0', 'ts_validation_e_elect',
+                    'ts_switch', 'job_troubleshooting', 'ts_method_spawning',
+                    'convergence_confirmed'}
         actual = {dk.value for dk in DecisionKind}
         self.assertEqual(expected, actual)