Use rdkit for SSSR and RCs (bug fix + Python upgrade)

.conda/meta.yaml

@@ -64,7 +64,6 @@ requirements:
     - conda-forge::gprof2dot
     - conda-forge::numdifftools
     - conda-forge::quantities !=0.16.0,!=0.16.1
-    - conda-forge::ringdecomposerlib-python
     - rmg::pydas >=1.0.3
     - rmg::pydqed >=1.0.3
     - rmg::symmetry
@@ -114,7 +113,6 @@ requirements:
     - conda-forge::gprof2dot
     - conda-forge::numdifftools
     - conda-forge::quantities !=0.16.0,!=0.16.1
-    - conda-forge::ringdecomposerlib-python
     - rmg::pydas >=1.0.3
     - rmg::pydqed >=1.0.3
     - rmg::symmetry
@@ -165,7 +163,6 @@ test:
     - conda-forge::gprof2dot
     - conda-forge::numdifftools
     - conda-forge::quantities !=0.16.0,!=0.16.1
-    - conda-forge::ringdecomposerlib-python
     - rmg::pydas >=1.0.3
     - rmg::pydqed >=1.0.3
     - rmg::symmetry

.github/workflows/CI.yml

@@ -63,7 +63,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9"]
+        python-version: ["3.9", "3.10", "3.11"]
         os: [macos-13, macos-latest, ubuntu-latest]
         include-rms: ["", "with RMS"]
         exclude:

.github/workflows/conda_build.yml

@@ -17,7 +17,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-13, macos-latest]
         numpy-version: ["1.26"]
-        python-version: ["3.9"]
+        python-version: ["3.9", "3.10", "3.11"]
     runs-on: ${{ matrix.os }}
     name: Build ${{ matrix.os }} Python ${{ matrix.python-version }} Numpy ${{ matrix.numpy-version }}
     defaults:

arkane/encorr/isodesmic.py

@@ -413,7 +413,7 @@ def _get_ring_constraints(
         self, species: ErrorCancelingSpecies
     ) -> List[GenericConstraint]:
         ring_features = []
-        rings = species.molecule.get_smallest_set_of_smallest_rings()
+        rings = species.molecule.get_symmetrized_smallest_set_of_smallest_rings()
         for ring in rings:
             ring_features.append(GenericConstraint(constraint_str=f"{len(ring)}_ring"))
 

environment.yml

@@ -84,7 +84,6 @@ dependencies:
   # bug in quantities, see:
   # https://github.com/ReactionMechanismGenerator/RMG-Py/pull/2694#issuecomment-2489286263
   - conda-forge::quantities !=0.16.0,!=0.16.1
-  - conda-forge::ringdecomposerlib-python
 
 # packages we maintain
   - rmg::pydas >=1.0.3

rmgpy/data/solvation.py

@@ -1623,15 +1623,15 @@ def estimate_radical_solute_data_via_hbi(self, molecule, stable_solute_data_esti
         # Take C1=CC=C([O])C(O)=C1 as an example, we need to remove the interation of OH-OH, then add the interaction of Oj-OH.
         # For now, we only apply this part to cyclic structure because we only have radical interaction data for aromatic radical.
         if saturated_struct.is_cyclic():
-            sssr = saturated_struct.get_smallest_set_of_smallest_rings()
+            sssr = saturated_struct.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:
                         self._remove_group_solute_data(solute_data, self.groups['longDistanceInteraction_cyclic'],
                                                        saturated_struct, {'*1': atomPair[0], '*2': atomPair[1]})
                     except KeyError:
                         pass
-            sssr = molecule.get_smallest_set_of_smallest_rings()
+            sssr = molecule.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:
@@ -1707,15 +1707,15 @@ def estimate_halogen_solute_data(self, molecule, stable_solute_data_estimator):
 
         # Remove all of the long distance interactions of the replaced structure. Then add the long interactions of the halogenated molecule.
         if replaced_struct.is_cyclic():
-            sssr = replaced_struct.get_smallest_set_of_smallest_rings()
+            sssr = replaced_struct.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:
                         self._remove_group_solute_data(solute_data, self.groups['longDistanceInteraction_cyclic'],
                                                        replaced_struct, {'*1': atomPair[0], '*2': atomPair[1]})
                     except KeyError:
                         pass
-            sssr = molecule.get_smallest_set_of_smallest_rings()
+            sssr = molecule.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:
@@ -1799,7 +1799,7 @@ def compute_group_additivity_solute(self, molecule):
         # In my opinion, it's cleaner to do it in the current way.
         # WIPWIPWIPWIPWIPWIPWIP         #########################################         WIPWIPWIPWIPWIPWIPWIP
         if cyclic:
-            sssr = molecule.get_smallest_set_of_smallest_rings()
+            sssr = molecule.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:

rmgpy/data/thermo.py

@@ -346,7 +346,7 @@ def is_bicyclic(polyring):
     returns True if it's a bicyclic, False otherwise
     """
     submol, _ = convert_ring_to_sub_molecule(polyring)
-    sssr = submol.get_smallest_set_of_smallest_rings()
+    sssr = submol.get_symmetrized_smallest_set_of_smallest_rings()
 
     return len(sssr) == 2
 
@@ -466,8 +466,8 @@ def is_ring_partial_matched(ring, matched_group):
         return True
     else:
         submol_ring, _ = convert_ring_to_sub_molecule(ring)
-        sssr = submol_ring.get_smallest_set_of_smallest_rings()
-        sssr_grp = matched_group.get_smallest_set_of_smallest_rings()
+        sssr = submol_ring.get_symmetrized_smallest_set_of_smallest_rings()
+        sssr_grp = matched_group.make_sample_molecule().get_symmetrized_smallest_set_of_smallest_rings()
         if sorted([len(sr) for sr in sssr]) == sorted([len(sr_grp) for sr_grp in sssr_grp]):
             return False
         else:
@@ -2141,15 +2141,15 @@ def estimate_radical_thermo_via_hbi(self, molecule, stable_thermo_estimator):
         # Take C1=CC=C([O])C(O)=C1 as an example, we need to remove the interation of OH-OH, then add the interaction of Oj-OH.
         # For now, we only apply this part to cyclic structure because we only have radical interaction data for aromatic radical.
         if saturated_struct.is_cyclic():
-            sssr = saturated_struct.get_smallest_set_of_smallest_rings()
+            sssr = saturated_struct.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:
                         self._remove_group_thermo_data(thermo_data, self.groups['longDistanceInteraction_cyclic'],
                                                        saturated_struct, {'*1': atomPair[0], '*2': atomPair[1]})
                     except KeyError:
                         pass
-            sssr = molecule.get_smallest_set_of_smallest_rings()
+            sssr = molecule.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:
@@ -2272,7 +2272,7 @@ def compute_group_additivity_thermo(self, molecule):
         # In my opinion, it's cleaner to do it in the current way.
         # WIPWIPWIPWIPWIPWIPWIP         #########################################         WIPWIPWIPWIPWIPWIPWIP
         if cyclic:
-            sssr = molecule.get_smallest_set_of_smallest_rings()
+            sssr = molecule.get_symmetrized_smallest_set_of_smallest_rings()
             for ring in sssr:
                 for atomPair in itertools.permutations(ring, 2):
                     try:

rmgpy/molecule/adjlist.py

@@ -1093,7 +1093,7 @@ def to_adjacency_list(atoms, multiplicity, metal='', facet='', label=None, group
                 # numbers if doesn't work
                 try:
                     adjlist += bond.get_order_str()
-                except ValueError:
+                except (ValueError, TypeError):
                     adjlist += str(bond.get_order_num())
             adjlist += '}'
 

rmgpy/molecule/converter.pxd

@@ -29,7 +29,7 @@ cimport rmgpy.molecule.molecule as mm
 cimport rmgpy.molecule.element as elements
 
 
-cpdef to_rdkit_mol(mm.Molecule mol, bint remove_h=*, bint return_mapping=*, bint sanitize=*, bint save_order=?)
+cpdef to_rdkit_mol(mm.Molecule mol, bint remove_h=*, bint return_mapping=*, object sanitize=*, bint save_order=?, bint ignore_bond_orders=?)
 
 cpdef mm.Molecule from_rdkit_mol(mm.Molecule mol, object rdkitmol, bint raise_atomtype_exception=?)
 

rmgpy/molecule/converter.py

@@ -38,6 +38,7 @@
 import cython
 # Assume that rdkit is installed
 from rdkit import Chem
+from rdkit.Chem.rdchem import KekulizeException, AtomKekulizeException
 # Test if openbabel is installed
 try:
     from openbabel import openbabel
@@ -49,55 +50,61 @@
 from rmgpy.exceptions import DependencyError
 
 
-def to_rdkit_mol(mol, remove_h=True, return_mapping=False, sanitize=True, save_order=False):
+def to_rdkit_mol(mol, remove_h=True, return_mapping=False, sanitize=True,
+                 save_order=False, ignore_bond_orders=False):
     """
     Convert a molecular structure to a RDKit rdmol object. Uses
     `RDKit <https://rdkit.org/>`_ to perform the conversion.
     Perceives aromaticity and, unless remove_h==False, removes Hydrogen atoms.
 
     If return_mapping==True then it also returns a dictionary mapping the
     atoms to RDKit's atom indices.
+
+    If ignore_bond_orders==True, all bonds are converted to unknown bonds, and 
+    sanitization is skipped. This is helpful when all you want is ring perception,
+    for example. Must also set sanitize=False.
     """
-    from rmgpy.molecule.fragment import Fragment
+    if ignore_bond_orders and sanitize:
+        raise ValueError("If ignore_bond_orders is True, sanitize must be False")
+    from rmgpy.molecule.fragment import Fragment, CuttingLabel
     # Sort the atoms before converting to ensure output is consistent
     # between different runs
     if not save_order:
         mol.sort_atoms()
     atoms = mol.vertices
     rd_atom_indices = {}  # dictionary of RDKit atom indices
-    label_dict = {} # store label of atom for Framgent
+    label_dict = {}  # For fragment cutting labels. Key is rdkit atom index, value is label string
     rdkitmol = Chem.rdchem.EditableMol(Chem.rdchem.Mol())
     for index, atom in enumerate(mol.vertices):
         if atom.element.symbol == 'X':
             rd_atom = Chem.rdchem.Atom('Pt')  # not sure how to do this with linear scaling when this might not be Pt
+        elif atom.element.symbol in ['R', 'L']:
+            rd_atom = Chem.rdchem.Atom(0)
         else:
             rd_atom = Chem.rdchem.Atom(atom.element.symbol)
         if atom.element.isotope != -1:
             rd_atom.SetIsotope(atom.element.isotope)
         rd_atom.SetNumRadicalElectrons(atom.radical_electrons)
         rd_atom.SetFormalCharge(atom.charge)
-        if atom.element.symbol == 'C' and atom.lone_pairs == 1 and mol.multiplicity == 1: rd_atom.SetNumRadicalElectrons(
-            2)
+        if atom.element.symbol == 'C' and atom.lone_pairs == 1 and mol.multiplicity == 1:
+            rd_atom.SetNumRadicalElectrons(2)
         rdkitmol.AddAtom(rd_atom)
         if remove_h and atom.symbol == 'H':
             pass
         else:
             rd_atom_indices[atom] = index
 
-        # Check if a cutting label is present. If preserve this so that it is added to the SMILES string
-        # Fragment's representative species is Molecule (with CuttingLabel replaced by Si but label as CuttingLabel)
-        # so we use detect_cutting_label to check atom.label
-        _, cutting_label_list = Fragment().detect_cutting_label(atom.label)
-        if cutting_label_list != []:
-            saved_index = index
-            label = atom.label
-            if label in label_dict:
-                label_dict[label].append(saved_index)
-            else:
-                label_dict[label] = [saved_index]
+        # Save cutting labels to add to the SMILES string
+        if atom.label and atom.label in ('R', 'L'):
+            label_dict[index] = atom.label
+
     rd_bonds = Chem.rdchem.BondType
-    orders = {'S': rd_bonds.SINGLE, 'D': rd_bonds.DOUBLE, 'T': rd_bonds.TRIPLE, 'B': rd_bonds.AROMATIC,
-              'Q': rd_bonds.QUADRUPLE}
+    # no vdW bond in RDKit, so "ZERO" or "OTHER" might be OK
+    orders = {'S': rd_bonds.SINGLE, 'D': rd_bonds.DOUBLE,
+              'T': rd_bonds.TRIPLE, 'B': rd_bonds.AROMATIC,
+              'Q': rd_bonds.QUADRUPLE, 'vdW': rd_bonds.ZERO,
+              'H': rd_bonds.HYDROGEN, 'R': rd_bonds.UNSPECIFIED,
+              None: rd_bonds.UNSPECIFIED}
     # Add the bonds
     for atom1 in mol.vertices:
         for atom2, bond in atom1.edges.items():
@@ -106,23 +113,31 @@ def to_rdkit_mol(mol, remove_h=True, return_mapping=False, sanitize=True, save_o
             index1 = atoms.index(atom1)
             index2 = atoms.index(atom2)
             if index1 < index2:
-                order_string = bond.get_order_str()
-                order = orders[order_string]
+                if ignore_bond_orders:
+                    order = rd_bonds.UNSPECIFIED
+                else:
+                    order_string = bond.get_order_str()
+                    order = orders[order_string]
                 rdkitmol.AddBond(index1, index2, order)
 
     # Make editable mol into a mol and rectify the molecule
     rdkitmol = rdkitmol.GetMol()
-    if label_dict:
-        for label, ind_list in label_dict.items():
-            for ind in ind_list:
-                Chem.SetSupplementalSmilesLabel(rdkitmol.GetAtomWithIdx(ind), label)
+    for index, label in label_dict.items():
+        Chem.SetSupplementalSmilesLabel(rdkitmol.GetAtomWithIdx(index), label)
     for atom in rdkitmol.GetAtoms():
         if atom.GetAtomicNum() > 1:
             atom.SetNoImplicit(True)
-    if sanitize:
-        Chem.SanitizeMol(rdkitmol)
     if remove_h:
-        rdkitmol = Chem.RemoveHs(rdkitmol, sanitize=sanitize)
+        rdkitmol = Chem.RemoveHs(rdkitmol, sanitize=False) # skip sanitization here, do it later if requested
+    if sanitize == True:
+        Chem.SanitizeMol(rdkitmol)
+    elif sanitize == "partial":
+        try:
+            Chem.SanitizeMol(rdkitmol, sanitizeOps=Chem.SANITIZE_ALL ^ Chem.SANITIZE_PROPERTIES)
+        except (KekulizeException, AtomKekulizeException):
+            logging.warning("Kekulization failed; sanitizing without Kekulize")
+            Chem.SanitizeMol(rdkitmol, sanitizeOps=Chem.SANITIZE_ALL ^ Chem.SANITIZE_PROPERTIES ^ Chem.SANITIZE_KEKULIZE)
+
     if return_mapping:
         return rdkitmol, rd_atom_indices
     return rdkitmol