TMP2

Author: alongd

arc/checks/ts.py

@@ -19,7 +19,6 @@
                         )
 from arc.imports import settings
 from arc.species.converter import check_xyz_dict, displace_xyz, xyz_to_dmat
-from arc.mapping.engine import get_atom_indices_of_labeled_atoms_in_an_rmg_reaction
 from arc.statmech.factory import statmech_factory
 
 if TYPE_CHECKING:

arc/common.py

@@ -19,15 +19,13 @@
 import warnings
 import yaml
 from collections import deque
-from itertools import chain
 from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
 import qcelemental as qcel
 
 from arkane.ess import ess_factory, GaussianLog, MolproLog, OrcaLog, QChemLog, TeraChemLog
-import rmgpy
 from rmgpy.exceptions import AtomTypeError, ILPSolutionError, ResonanceError
 from rmgpy.molecule.atomtype import ATOMTYPES
 from rmgpy.molecule.element import get_element
@@ -40,9 +38,7 @@
 
 
 if TYPE_CHECKING:
-    from rmgpy.reaction import Reaction
     from rmgpy.species import Species
-    from arc.reaction import ARCReaction
 
 
 logger = logging.getLogger('arc')
@@ -1563,50 +1559,6 @@ def calc_rmsd(x: Union[list, np.array],
     return float(rmsd)
 
 
-def _check_r_n_p_symbols_between_rmg_and_arc_rxns(arc_reaction: 'ARCReaction',
-                                                  rmg_reactions: List['Reaction'],
-                                                  ) -> bool:
-    """
-    A helper function to check that atom symbols are in the correct order between an ARC reaction
-    and its corresponding RMG reactions generated by the get_rmg_reactions_from_arc_reaction() function.
-    Used internally for testing.
-
-    Args:
-        arc_reaction (ARCReaction): The ARCReaction object to inspect.
-        rmg_reactions (List['Reaction']): Entries are RMG Reaction objects to inspect.
-                                          Could contain either Species or Molecule object as reactants/products.
-
-    Returns:
-        bool: Whether atom symbols are in the same respective order.
-    """
-    result = True
-    num_rs, num_ps = len(arc_reaction.r_species), len(arc_reaction.p_species)
-    arc_r_symbols = [atom.element.symbol for atom in chain(*tuple(arc_reaction.r_species[i].mol.atoms for i in range(num_rs)))]
-    arc_p_symbols = [atom.element.symbol for atom in chain(*tuple(arc_reaction.p_species[i].mol.atoms for i in range(num_ps)))]
-    for rmg_reaction in rmg_reactions:
-        rmg_r_symbols = [atom.element.symbol
-                         for atom in chain(*tuple(rmg_reaction.reactants[i].atoms
-                                                  if isinstance(rmg_reaction.reactants[i], Molecule)
-                                                  else rmg_reaction.reactants[i].molecule[0].atoms
-                                                  for i in range(num_rs)))]
-        rmg_p_symbols = [atom.element.symbol
-                         for atom in chain(*tuple(rmg_reaction.products[i].atoms
-                                                  if isinstance(rmg_reaction.products[i], Molecule)
-                                                  else rmg_reaction.products[i].molecule[0].atoms
-                                                  for i in range(num_ps)))]
-        if any(symbol_1 != symbol_2 for symbol_1, symbol_2 in zip(arc_r_symbols, rmg_r_symbols)):
-            print('\nDifferent element order in reactants between ARC and RMG:')  # Don't modify to logging.
-            print(arc_r_symbols)
-            print(rmg_r_symbols)
-            result = False
-        if any(symbol_1 != symbol_2 for symbol_1, symbol_2 in zip(arc_p_symbols, rmg_p_symbols)):
-            print('\nDifferent element order in products between ARC and RMG:')
-            print(arc_p_symbols)
-            print(rmg_p_symbols)
-            result = False
-    return result
-
-
 def safe_copy_file(source: str,
                    destination: str,
                    wait: int = 10,

arc/common_test.py

@@ -21,9 +21,7 @@
 import arc.common as common
 from arc.exceptions import InputError, SettingsError
 from arc.imports import settings
-from arc.mapping.engine import get_rmg_reactions_from_arc_reaction
 import arc.species.converter as converter
-from arc.reaction import ARCReaction
 from arc.species.species import ARCSpecies
 
 
@@ -1268,13 +1266,6 @@ def test_sort_atoms_in_descending_label_order(self):
         mol.atoms[0].label = "a"
         self.assertIsNone(common.sort_atoms_in_descending_label_order(mol=mol))
 
-    def test_check_r_n_p_symbols_between_rmg_and_arc_rxns(self):
-        """Test the _check_r_n_p_symbols_between_rmg_and_arc_rxns() function"""
-        arc_rxn = ARCReaction(r_species=[ARCSpecies(label='CH4', smiles='C'), ARCSpecies(label='OH', smiles='[OH]')],
-                              p_species=[ARCSpecies(label='CH3', smiles='[CH3]'), ARCSpecies(label='H2O', smiles='O')])
-        rmg_reactions = get_rmg_reactions_from_arc_reaction(arc_reaction=arc_rxn)
-        self.assertTrue(common._check_r_n_p_symbols_between_rmg_and_arc_rxns(arc_rxn, rmg_reactions))
-
     def test_almost_equal_coords(self):
         """Test the almost_equal_coords() function"""
         with self.assertRaises(TypeError):

arc/family/__init__.py

@@ -1 +1,3 @@
 import arc.family.family
+from arc.family.family import ReactionFamily
+from arc.family.family import get_reaction_family_products

arc/family/family.py

@@ -11,7 +11,6 @@
 
 from arc.common import clean_text, generate_resonance_structures, get_logger
 from arc.imports import settings
-from arc.species.converter import check_isomorphism
 
 if TYPE_CHECKING:
     from arc.species import ARCSpecies
@@ -519,7 +518,7 @@ def check_product_isomorphism(products: List['Molecule'],
     Returns:
         bool: Whether the products are isomorphic to the species.
     """
-    prods_a = [generate_resonance_structures(mol) or [mol] for mol in products]
+    prods_a = [generate_resonance_structures(mol.copy(deep=True)) or [mol.copy(deep=True)] for mol in products]
     prods_b = [spc.mol_list or [spc.mol] for spc in p_species]
     if len(prods_a) == 1:
         prod_a = prods_a[0]
@@ -564,6 +563,7 @@ def get_all_families(rmg_family_set: Union[List[str], str] = 'default',
                      ) -> List[str]:
     """
     Get all available RMG and ARC families.
+    If ``rmg_family_set`` is a list of family labels and does not contain family sets, it will be returned as is.
 
     Args:
         rmg_family_set (Union[List[str], str], optional): The RMG family set to use.
@@ -574,9 +574,11 @@ def get_all_families(rmg_family_set: Union[List[str], str] = 'default',
         List[str]: A list of all available families.
     """
     rmg_family_set = rmg_family_set or 'default'
+    family_sets = get_rmg_recommended_family_sets()
+    if isinstance(rmg_family_set, list) and all(fam not in family_sets for fam in rmg_family_set):
+        return rmg_family_set
     rmg_families, arc_families = list(), list()
     if consider_rmg_families:
-        family_sets = get_rmg_recommended_family_sets()
         if not isinstance(rmg_families, list) and rmg_family_set not in list(family_sets) + ['all']:
             raise ValueError(f'Invalid RMG family set: {rmg_family_set}')
         if rmg_family_set == 'all':

arc/family/family_test.py

@@ -605,6 +605,8 @@ def test_get_all_families(self):
         families = get_all_families(consider_rmg_families=False)
         self.assertIsInstance(families, list)
         self.assertIn('hydrolysis', families)
+        families = get_all_families(rmg_family_set=['H_Abstraction'])
+        self.assertEqual(families, ['H_Abstraction'])
 
     def test_get_rmg_recommended_family_sets(self):
         """Test getting RMG recommended family sets"""
@@ -638,12 +640,12 @@ def test_load(self):
         self.assertFalse(fam_2.own_reverse)
         self.assertEqual(fam_2.reactants, [['Root']])
         self.assertEqual(fam_2.product_num, 2)
-        self.assertEqual(fam_2.entries, {'Root': """1 *3 R!H u0 {2,S} {3,[S,D]}
-2 *4 R!H u0 {1,S} {4,[S,D]}
-3 *2 R!H u0 {1,[S,D]} {5,[D,T,B]}
-4 *5 R!H u0 {2,[S,D]} {6,S}
-5 *1 R!H u0 {3,[D,T,B]}
-6 *6 H   u0 {4,S}"""})
+        self.assertEqual(fam_2.entries, {'Root': """1 *3 R!H    u0 {2,S} {3,[S,D]}
+2 *4 R!H    u0 {1,S} {4,[S,D]}
+3 *2 R!H    u0 {1,[S,D]} {5,[D,T,B]}
+4 *5 R!H    u0 {2,[S,D]} {6,S}
+5 *1 R!H    u0 {3,[D,T,B]}
+6 *6 [H,Li] u0 {4,S}"""})
         self.assertEqual(fam_2.actions, [['CHANGE_BOND', '*1', -1, '*2'],
                                          ['BREAK_BOND', '*5', 1, '*6'],
                                          ['BREAK_BOND', '*3', 1, '*4'],
@@ -960,6 +962,17 @@ def test_get_isomorphic_subgraph(self):
                                                       )
         self.assertEqual(isomorphic_subgraph, {0: '*3', 4: '*1', 7: '*2'})
 
+    # def test_order_species_list(self):
+    #     """Test the order_species_list() function"""
+    #     spc1 = ARCSpecies(label='spc1', smiles='C')
+    #     spc2 = ARCSpecies(label='spc2', smiles='CC')
+    #     ordered_species_list = order_species_list(species_list=[spc2, spc1], reference_species=[spc1, spc2])
+    #     self.assertEqual(ordered_species_list, [spc1, spc2])
+    #     ordered_species_list = order_species_list(species_list=[spc2, spc1], reference_species=[spc2, spc1])
+    #     self.assertEqual(ordered_species_list, [spc2, spc1])
+    #     ordered_species_list = order_species_list(species_list=[spc2.mol, spc1], reference_species=[spc2, spc1.mol])
+    #     self.assertEqual(ordered_species_list, [spc2.mol, spc1])
+
 
 if __name__ == '__main__':
     unittest.main(testRunner=unittest.TextTestRunner(verbosity=2))