Yaml writer addition

rmgpy/reaction.py

@@ -1447,7 +1447,7 @@ def is_balanced(self):
         from rmgpy.molecule.element import element_list
         from rmgpy.molecule.fragment import CuttingLabel, Fragment
 
-        cython.declare(reactant_elements=dict, product_elements=dict, molecule=Graph, atom=Vertex, element=Element,
+        cython.declare(reactant_elements=dict, product_elements=dict, molecule=Molecule, atom=Atom, element=Element,
                        reactants_net_charge=cython.int, products_net_charge=cython.int)
 
         reactant_elements = {}

rmgpy/rmg/main.py

@@ -80,8 +80,11 @@
 from rmgpy.stats import ExecutionStatsWriter
 from rmgpy.thermo.thermoengine import submit
 from rmgpy.tools.plot import plot_sensitivity
+from rmgpy.tools.compare_cantera_yaml import compare_yaml_files, compare_yaml_files_and_report
 from rmgpy.tools.uncertainty import Uncertainty, process_local_results
-from rmgpy.yml import RMSWriter
+from rmgpy.yaml_rms import RMSWriter
+from rmgpy.yaml_cantera1 import CanteraWriter1
+from rmgpy.yaml_cantera2 import CanteraWriter2
 
 ################################################################################
 
@@ -773,7 +776,8 @@ def register_listeners(self, requires_rms=False):
         self.attach(ChemkinWriter(self.output_directory))
 
         self.attach(RMSWriter(self.output_directory))
-
+        self.attach(CanteraWriter1(self.output_directory))
+        self.attach(CanteraWriter2(self.output_directory))
         if self.generate_output_html:
             self.attach(OutputHTMLWriter(self.output_directory))
 
@@ -1221,15 +1225,17 @@ def execute(self, initialize=True, **kwargs):
 
         self.run_model_analysis()
 
-        # generate Cantera files chem.yaml & chem_annotated.yaml in a designated `cantera` output folder
+        # generate Cantera files chem.yaml & chem_annotated.yaml in designated Cantera output folders
         try:
+            logging.info("Translating final chemkin file into Cantera yaml.")
+            translated_cantera_file = None
             if any([s.contains_surface_site() for s in self.reaction_model.core.species]):
                 # Surface (catalytic) chemistry
-                self.generate_cantera_files(
+                translated_cantera_file = self.generate_cantera_files_from_chemkin(
                     os.path.join(self.output_directory, "chemkin", "chem-gas.inp"),
                     surface_file=(os.path.join(self.output_directory, "chemkin", "chem-surface.inp")),
                 )
-                self.generate_cantera_files(
+                self.generate_cantera_files_from_chemkin(
                     os.path.join(self.output_directory, "chemkin", "chem_annotated-gas.inp"),
                     surface_file=(os.path.join(self.output_directory, "chemkin", "chem_annotated-surface.inp")),
                 )
@@ -1262,8 +1268,22 @@ def execute(self, initialize=True, **kwargs):
                         _add_coverage_dependence_to_cantera_yaml(yaml_path, coverage_deps)
 
             else:  # gas phase only
-                self.generate_cantera_files(os.path.join(self.output_directory, "chemkin", "chem.inp"))
-                self.generate_cantera_files(os.path.join(self.output_directory, "chemkin", "chem_annotated.inp"))
+                translated_cantera_file = self.generate_cantera_files_from_chemkin(
+                    os.path.join(self.output_directory, "chemkin", "chem.inp")
+                )
+                self.generate_cantera_files_from_chemkin(
+                    os.path.join(self.output_directory, "chemkin", "chem_annotated.inp")
+                )
+
+            # Compare translated Cantera files and directly generated Cantera files
+
+            compare_yaml_files_and_report(translated_cantera_file,
+                                          os.path.join(self.output_directory, "cantera1", "chem.yaml"),
+                                          output=os.path.join(self.output_directory, "cantera1", "comparison_report.txt"))
+            compare_yaml_files_and_report(translated_cantera_file,
+                                          os.path.join(self.output_directory, "cantera2", "chem.yaml"),
+                                          output=os.path.join(self.output_directory, "cantera2", "comparison_report.txt"))
+
         except EnvironmentError:
             logging.exception("Could not generate Cantera files due to EnvironmentError. Check read\\write privileges in output directory.")
         except Exception:
@@ -1834,14 +1854,15 @@ def process_reactions_to_species(self, obj):
             raise TypeError("improper call, obj input was incorrect")
         return potential_spcs
 
-    def generate_cantera_files(self, chemkin_file, **kwargs):
+    def generate_cantera_files_from_chemkin(self, chemkin_file, **kwargs):
         """
         Convert a chemkin mechanism chem.inp file to a cantera mechanism file chem.yaml
-        and save it in the cantera directory
+        and save it in the cantera directory. 
+        Returns the path to the generated cantera file.
         """
         transport_file = os.path.join(os.path.dirname(chemkin_file), "tran.dat")
         file_name = os.path.splitext(os.path.basename(chemkin_file))[0] + ".yaml"
-        out_name = os.path.join(self.output_directory, "cantera", file_name)
+        out_name = os.path.join(self.output_directory, "cantera_from_ck", file_name)
         if "surface_file" in kwargs:
             out_name = out_name.replace("-gas.", ".")
         cantera_dir = os.path.dirname(out_name)
@@ -1859,6 +1880,7 @@ def generate_cantera_files(self, chemkin_file, **kwargs):
             logging.exception("Error converting to Cantera format.")
             logging.info("Trying again without transport data file.")
             parser.convert_mech(chemkin_file, out_name=out_name, quiet=True, permissive=True, **kwargs)
+        return out_name
 
     def initialize_reaction_threshold_and_react_flags(self):
         num_core_species = len(self.reaction_model.core.species)
@@ -2146,8 +2168,9 @@ def get_git_commit(self, module_path):
 
         if os.path.exists(os.path.join(module_path, "..", ".git")):
             try:
-                return subprocess.check_output(["git", "log", "--format=%H%n%cd", "-1"], cwd=module_path).splitlines()
-            except:
+                head, date = subprocess.check_output(["git", "log", "--format=%H%n%cd", "-1"], cwd=module_path).splitlines()
+                return head.decode(), date.decode()
+            except (subprocess.CalledProcessError, OSError):
                 return "", ""
         else:
             return "", ""

rmgpy/rmg/model.py

@@ -365,10 +365,11 @@ def make_new_species(self, object, label="", reactive=True, check_existing=True,
         spec.molecular_weight = Quantity(spec.molecule[0].get_molecular_weight() * 1000.0, "amu")
 
         if generate_thermo:
-            self.generate_thermo(spec)
+            # Rename from thermo library label only if no user-provided label exists yet.
+            self.generate_thermo(spec, rename=not bool(spec.label))
 
         # If the species still does not have a label, set initial label as the SMILES
-        # This may change later after getting thermo in self.generate_thermo()
+        # (applies when generate_thermo is False, or when no library match was found)
         if not spec.label:
             spec.label = spec.smiles
 

rmgpy/species.py

@@ -428,13 +428,18 @@ def to_chemkin(self):
         from rmgpy.chemkin import get_species_identifier
         return get_species_identifier(self)
 
-    def to_cantera(self, use_chemkin_identifier=False):
+    def to_cantera(self, use_chemkin_identifier=False, all_species=None):
         """
         Converts the RMG Species object to a Cantera Species object
         with the appropriate thermo data.
 
         If use_chemkin_identifier is set to False, the species label is used
         instead. Be sure that species' labels are unique when setting it False.
+
+        If all_species is provided and this is a surface species with
+        coverage-dependent thermo, the coverage-dependencies are attached to
+        the Cantera Species object via update_user_data() so that they appear
+        in input_data and in Solution.write_yaml() output.
         """
         import cantera as ct
 
@@ -475,6 +480,32 @@ def to_cantera(self, use_chemkin_identifier=False):
         if self.transport_data:
             ct_species.transport = self.transport_data.to_cantera()
 
+        # Attach coverage-dependent thermo if present.
+        # thermo_coverage_dependence keys are adjacency-list strings; we resolve
+        # them to species names here using all_species.  The data is stored via
+        # update_user_data() so it appears in ct_species.input_data and in any
+        # YAML serialised by Cantera (e.g. Solution.write_yaml()).
+        if (all_species is not None
+                and self.contains_surface_site()
+                and self.thermo
+                and hasattr(self.thermo, 'thermo_coverage_dependence')
+                and self.thermo.thermo_coverage_dependence):
+            from rmgpy.molecule.molecule import Molecule
+            cov_deps = {}
+            for adj_list, parameters in self.thermo.thermo_coverage_dependence.items():
+                mol = Molecule().from_adjacency_list(adj_list)
+                for sp in all_species:
+                    if sp.is_isomorphic(mol, strict=False):
+                        dep_name = sp.to_chemkin() if use_chemkin_identifier else sp.label
+                        cov_deps[dep_name] = {
+                            'units': {'energy': 'J', 'quantity': 'mol'},
+                            'enthalpy-coefficients': [v.value_si for v in parameters['enthalpy-coefficients']],
+                            'entropy-coefficients': [v.value_si for v in parameters['entropy-coefficients']],
+                        }
+                        break
+            if cov_deps:
+                ct_species.update_user_data({'coverage-dependencies': cov_deps})
+
         return ct_species
 
     def has_statmech(self):

rmgpy/thermo/nasa.pyx

@@ -421,7 +421,6 @@ cdef class NASA(HeatCapacityModel):
             poly.change_base_entropy(deltaS)
         return self
 
-    # need to modify this to include the thermo coverage dependence
     def to_cantera(self):
         """
         Return the cantera equivalent NasaPoly2 object from this NASA object.