species: default thermo_at_own_level to False

Reaction wells take the reaction-wide level directly by default (no relabeled copies, no duplicated jobs); set True per species to opt into its own granular level for thermo.

Author: alongd

arc/scheduler_test.py

@@ -1284,9 +1284,11 @@ def build_scheduler(self, rxn, species_list, name):
                          testing=True)
 
     def test_bimolecular_creates_copies(self):
-        """Test that a reaction with wells on a different grain than the reaction gets relabeled copies"""
-        r = [ARCSpecies(label='CH4', smiles='C'), ARCSpecies(label='OH', smiles='[OH]')]
-        p = [ARCSpecies(label='CH3', smiles='[CH3]'), ARCSpecies(label='H2O', smiles='O')]
+        """Test that with thermo_at_own_level=True, wells on a different grain get relabeled copies"""
+        r = [ARCSpecies(label='CH4', smiles='C', thermo_at_own_level=True),
+             ARCSpecies(label='OH', smiles='[OH]', thermo_at_own_level=True)]
+        p = [ARCSpecies(label='CH3', smiles='[CH3]', thermo_at_own_level=True),
+             ARCSpecies(label='H2O', smiles='O', thermo_at_own_level=True)]
         rxn = ARCReaction(label='CH4 + OH <=> CH3 + H2O', r_species=r, p_species=p)
         sched = self.build_scheduler(rxn, r + p, 'adaptive_bimol')
 
@@ -1312,14 +1314,12 @@ def test_bimolecular_creates_copies(self):
             self.assertIsNone(original.adaptive_lot_n_heavy)
             self.assertTrue(original.compute_thermo)
 
-    def test_thermo_at_own_level_false_no_copy(self):
-        """Test that with thermo_at_own_level=False the species itself takes the reaction-wide level, with no copy"""
-        r = [ARCSpecies(label='CH4', smiles='C', thermo_at_own_level=False),
-             ARCSpecies(label='OH', smiles='[OH]', thermo_at_own_level=False)]
-        p = [ARCSpecies(label='CH3', smiles='[CH3]', thermo_at_own_level=False),
-             ARCSpecies(label='H2O', smiles='O', thermo_at_own_level=False)]
+    def test_thermo_at_own_level_default_no_copy(self):
+        """Test that by default (thermo_at_own_level=False) the species itself takes the reaction-wide level, no copy"""
+        r = [ARCSpecies(label='CH4', smiles='C'), ARCSpecies(label='OH', smiles='[OH]')]
+        p = [ARCSpecies(label='CH3', smiles='[CH3]'), ARCSpecies(label='H2O', smiles='O')]
         rxn = ARCReaction(label='CH4 + OH <=> CH3 + H2O', r_species=r, p_species=p)
-        sched = self.build_scheduler(rxn, r + p, 'adaptive_noflag')
+        sched = self.build_scheduler(rxn, r + p, 'adaptive_default')
 
         self.assertEqual(rxn.label, 'CH4 + OH <=> CH3 + H2O')
         self.assertFalse(any('_TS' in label for label in sched.species_dict))

arc/species/species.py

@@ -109,10 +109,10 @@ class ARCSpecies(object):
         bond_corrections (dict, optional): The bond additivity corrections (BAC) to be used. Determined from the
                                            structure if not directly given.
         compute_thermo (bool, optional): Whether to calculate thermodynamic properties for this species.
-        thermo_at_own_level (bool, optional): Relevant only when ``adaptive_levels`` are used. If ``True`` (default),
-            the species' thermochemistry is computed at its own size-appropriate (granular) adaptive level even when
-            it participates in a reaction; the reaction's energetics then use a separate relabeled copy of the species
-            evaluated at the reaction-consistent level. If ``False``, the species itself is evaluated at the
+        thermo_at_own_level (bool, optional): Relevant only when ``adaptive_levels`` are used. If ``True``, the
+            species' thermochemistry is computed at its own size-appropriate (granular) adaptive level even when it
+            participates in a reaction; the reaction's energetics then use a separate relabeled copy of the species
+            evaluated at the reaction-consistent level. If ``False`` (default), the species itself is evaluated at the
             reaction-consistent (coarser) level and no copy is made.
         include_in_thermo_lib (bool, optional): Whether to include in the output RMG library.
         e0_only (bool, optional): Whether to only run statmech (w/o thermo) to compute E0.
@@ -317,7 +317,7 @@ def __init__(self,
                  charge: int | None = None,
                  checkfile: str | None = None,
                  compute_thermo: bool | None = None,
-                 thermo_at_own_level: bool = True,
+                 thermo_at_own_level: bool = False,
                  adaptive_lot_n_heavy: int | None = None,
                  include_in_thermo_lib: bool | None = True,
                  consider_all_diastereomers: bool = True,
@@ -702,7 +702,7 @@ def as_dict(self,
             species_dict['charge'] = self.charge
         if not self.compute_thermo and not self.is_ts:
             species_dict['compute_thermo'] = self.compute_thermo
-        if not self.thermo_at_own_level:
+        if self.thermo_at_own_level:
             species_dict['thermo_at_own_level'] = self.thermo_at_own_level
         if self.adaptive_lot_n_heavy is not None:
             species_dict['adaptive_lot_n_heavy'] = self.adaptive_lot_n_heavy
@@ -902,7 +902,7 @@ def from_dict(self, species_dict):
         self.multi_species = species_dict['multi_species'] if 'multi_species' in species_dict else None
         self.charge = species_dict['charge'] if 'charge' in species_dict else 0
         self.compute_thermo = species_dict['compute_thermo'] if 'compute_thermo' in species_dict else not self.is_ts
-        self.thermo_at_own_level = species_dict['thermo_at_own_level'] if 'thermo_at_own_level' in species_dict else True
+        self.thermo_at_own_level = species_dict['thermo_at_own_level'] if 'thermo_at_own_level' in species_dict else False
         self.adaptive_lot_n_heavy = species_dict['adaptive_lot_n_heavy'] if 'adaptive_lot_n_heavy' in species_dict else None
         self.include_in_thermo_lib = species_dict['include_in_thermo_lib'] if 'include_in_thermo_lib' in species_dict else True
         self.e0_only = species_dict['e0_only'] if 'e0_only' in species_dict else False

arc/species/species_test.py

@@ -610,22 +610,22 @@ def test_as_dict(self):
 
     def test_thermo_at_own_level_round_trip(self):
         """Test that thermo_at_own_level and adaptive_lot_n_heavy round-trip through as_dict/from_dict"""
-        # Defaults: not serialized, restored to True / None.
+        # Defaults: not serialized, restored to False / None.
         default_spc = ARCSpecies(label='ethane', smiles='CC')
         default_dict = default_spc.as_dict()
         self.assertNotIn('thermo_at_own_level', default_dict)
         self.assertNotIn('adaptive_lot_n_heavy', default_dict)
         restored_default = ARCSpecies(species_dict=default_dict)
-        self.assertTrue(restored_default.thermo_at_own_level)
+        self.assertFalse(restored_default.thermo_at_own_level)
         self.assertIsNone(restored_default.adaptive_lot_n_heavy)
 
         # Non-default values: serialized and restored.
-        spc = ARCSpecies(label='ethane', smiles='CC', thermo_at_own_level=False, adaptive_lot_n_heavy=8)
+        spc = ARCSpecies(label='ethane', smiles='CC', thermo_at_own_level=True, adaptive_lot_n_heavy=8)
         spc_dict = spc.as_dict()
-        self.assertFalse(spc_dict['thermo_at_own_level'])
+        self.assertTrue(spc_dict['thermo_at_own_level'])
         self.assertEqual(spc_dict['adaptive_lot_n_heavy'], 8)
         restored = ARCSpecies(species_dict=spc_dict)
-        self.assertFalse(restored.thermo_at_own_level)
+        self.assertTrue(restored.thermo_at_own_level)
         self.assertEqual(restored.adaptive_lot_n_heavy, 8)
 
     def test_from_dict(self):

docs/source/advanced.rst

@@ -283,12 +283,12 @@ levels (defined separately, e.g., via ``opt_level``, or using ARC's defaults).
 When a species participates in a reaction, all of the reaction's species (the TS and the
 reactant/product wells) are energy-evaluated at a single, reaction-consistent level keyed
 by the largest participant (the TS), so the barrier is computed at one consistent level.
-By default (the per-species ``thermo_at_own_level`` flag, ``True``) each species'
-thermochemistry is still computed at its own size-appropriate (granular) adaptive level: an
-autonomous, relabeled copy of any well that lands on a coarser grain than its reaction is
-created and used by the reaction (at the reaction-wide level), while the original species
-keeps its own level for thermochemistry. Set ``thermo_at_own_level=False`` on a species to
-have it evaluated at the reaction-wide level directly (no copy, coarser thermochemistry).
+By default (the per-species ``thermo_at_own_level`` flag, ``False``) a well that lands on a
+coarser grain than its reaction is evaluated directly at the reaction-wide level, and its
+thermochemistry uses that same (coarser) level. Set ``thermo_at_own_level=True`` on a species
+to instead compute its thermochemistry at its own size-appropriate (granular) adaptive level:
+an autonomous, relabeled copy of the species is then created and used by the reaction (at the
+reaction-wide level), while the original keeps its own level for thermochemistry.
 
 
 Control job memory allocation