Functional test comparing Cantera YAML outputs to Chemkin-converted YAML

Made test_cantera_input_files_match_chemkin that uses CompareYaml to verify RMG-generated Cantera
YAML files match those converted from Chemkin format.

Changes to compare_yaml_outputs.py:
- Update get_absolute_path() to handle absolute paths correctly
- Add support for plain 'reactions' key used by gas-only mechanisms
- Reduce redundant load_yaml_file() calls in get_reactions_dict()

The test compares chem{N}.yaml (from CanteraWriter) with chem.yaml
(from ck2yaml conversion), checking species counts, names, and reactions.

Author: rwest

test/rmgpy/rmg/mainTest.py

@@ -55,7 +55,10 @@ def setup_class(cls):
         cls.seedKinetics = os.path.join(cls.databaseDirectory, "kinetics", "libraries", "testSeed")
         cls.seedKineticsEdge = os.path.join(cls.databaseDirectory, "kinetics", "libraries", "testSeed_edge")
 
-        os.mkdir(os.path.join(cls.testDir, cls.outputDir))
+        output_path = os.path.join(cls.testDir, cls.outputDir)
+        if os.path.exists(output_path):
+            shutil.rmtree(output_path)
+        os.mkdir(output_path)
 
         cls.rmg = RMG(
             input_file=os.path.join(cls.testDir, "input.py"),
@@ -186,6 +189,69 @@ def test_make_cantera_input_file(self):
                     ct.Solution(os.path.join(outName, f))
                 except:
                     assert False, "The output Cantera file is not loadable in Cantera."
+    
+    def test_cantera_input_files_match_chemkin(self):
+        """
+        Test that the Cantera YAML files generated directly by RMG match
+        those converted from Chemkin files.
+        """
+        import sys
+        # Add the yaml_writer test directory to path for importing CompareYaml
+        yaml_writer_test_dir = os.path.join(
+            originalPath, "..", "test", "rmgpy", "yaml_writer"
+        )
+        sys.path.insert(0, yaml_writer_test_dir)
+        from compare_yaml_outputs import CompareYaml
+        sys.path.pop(0)
+
+        # Find the RMG-generated cantera yaml file (named chem{N}.yaml)
+        cantera_dir = os.path.join(self.rmg.output_directory, "cantera")
+        cantera_from_ck_dir = os.path.join(
+            self.rmg.output_directory, "cantera_from_ck"
+        )
+
+        # Get the yaml files generated directly by RMG
+        cantera_files = [
+            f for f in os.listdir(cantera_dir) if f.endswith('.yaml')
+        ]
+        assert len(cantera_files) > 0, \
+            "No Cantera YAML files found in cantera directory"
+        # Sort by the number in the filename to get the final mechanism
+        cantera_files.sort(
+            key=lambda x: int(''.join(filter(str.isdigit, x)) or 0),
+            reverse=True
+        )
+        rmg_yaml_file = cantera_files[0]
+
+        # Get the yaml file converted from chemkin
+        ck_yaml_file = "chem.yaml"
+        assert os.path.exists(os.path.join(cantera_from_ck_dir, ck_yaml_file)),\
+            f"Chemkin-converted YAML file {ck_yaml_file} not found"
+
+        # Compare the two yaml files
+        yaml_files = {
+            'yaml1': [cantera_dir, rmg_yaml_file],
+            'yaml2': [cantera_from_ck_dir, ck_yaml_file]
+        }
+        compare = CompareYaml(yaml_files)
+
+        # Check species count matches
+        assert compare.compare_species_count(), (
+            f"Species count mismatch between RMG yaml ({rmg_yaml_file}) "
+            f"and chemkin yaml ({ck_yaml_file})"
+        )
+
+        # Check species names match
+        assert compare.compare_species_names(), (
+            f"Species names mismatch between RMG yaml ({rmg_yaml_file}) "
+            f"and chemkin yaml ({ck_yaml_file})"
+        )
+
+        # Check reactions match
+        assert compare.compare_reactions(), (
+            f"Reactions mismatch between RMG yaml ({rmg_yaml_file}) "
+            f"and chemkin yaml ({ck_yaml_file})"
+        )
 
 
 @pytest.mark.functional

test/rmgpy/yaml_writer/compare_yaml_outputs.py

@@ -4,12 +4,16 @@
 import re
 
 class YamlAnalyst:
-    def __init__(self, path_to_chemkin_yaml, chemkin_yaml_file):
-        self.path_to_chemkin_yaml = path_to_chemkin_yaml
-        self.chemkin_yaml_file = chemkin_yaml_file
+    def __init__(self, path_to_yaml, yaml_file):
+        self.path_to_yaml = path_to_yaml
+        self.yaml_file = yaml_file
 
     def get_absolute_path(self):
-        return os.path.join(os.getcwd(), self.path_to_chemkin_yaml, self.chemkin_yaml_file)
+        path = os.path.join(self.path_to_yaml, self.yaml_file)
+        # If path is already absolute, use it; otherwise join with cwd
+        if os.path.isabs(path):
+            return path
+        return os.path.join(os.getcwd(), path)
 
     def load_yaml_file(self):
         with open(self.get_absolute_path(), 'r') as file:
@@ -29,13 +33,17 @@ def get_species_count_per_phase(self):
 
     def get_reactions_dict(self):
         reactions_dict = {}
-        for key, values in self.load_yaml_file().items():
-            if key in [f"{phase['name']}-reactions" for phase in self.load_yaml_file()['phases']]:
-                reactions_dict[key] = self.load_yaml_file()[key]
+        data = self.load_yaml_file()
+        for key, values in data.items():
+            if key in [f"{phase['name']}-reactions" for phase in data['phases']]:
+                reactions_dict[key] = data[key]
             elif key == 'gas_reactions':
-                reactions_dict['gas_reactions'] = self.load_yaml_file()['gas_reactions']
+                reactions_dict['gas_reactions'] = data['gas_reactions']
             elif key == 'surface_reactions':
-                reactions_dict['surface_reactions'] = self.load_yaml_file()['surface_reactions']
+                reactions_dict['surface_reactions'] = data['surface_reactions']
+            elif key == 'reactions':
+                # Gas-only mechanisms use plain 'reactions' key
+                reactions_dict['reactions'] = data['reactions']
         return reactions_dict
 
     def create_reaction_df(self, reactions):