Input and Output

Input and output to different forms is an active area of development for pMuTT.

Excel

excel.read_excel

Special Rules

Special rules can be defined in the read_excel() function to process inputs differently. Currently supported special rules are listed below.

excel.set_element
excel.set_formula
excel.set_atoms
excel.set_statmech_model
excel.set_trans_model
excel.set_vib_model
excel.set_rot_model
excel.set_elec_model
excel.set_nucl_model
excel.set_vib_wavenumbers
excel.set_rot_temperatures
excel.set_nasa_a_low
excel.set_nasa_a_high
excel.set_list_value
excel.set_dict_value

Thermdat

This is the output format used for Chemkin. A list of NASA objects can be written to a thermdat file.

thermdat.read_thermdat
thermdat.write_thermdat

JSON

JavaScript Object Notation (JSON) is a format that is easily read and written by both humans and machines. All pmutt objects with the methods to_dict and from_dict are JSON compatible.

json.pmuttEncoder
json.json_to_pmutt

Examples

Saving pmutt objects can be done by using pmuttEncoder().

import json
from pmutt.io.json import pmuttEncoder

with open(json_path, 'w') as f_ptr:
    json.dump(pmutt_obj, f_ptr, cls=pmuttEncoder, indent=True)

Loading pmutt objects can be done by using the object hook: json_to_pmutt().

import json
from pmutt.io.json import json_to_pmutt

with open(json_path, 'r') as f_ptr:
    pmutt_obj = json.load(f_ptr, object_hook=json_to_pmutt)

Sample JSON File

JSON writes in a human-readable syntax. An example showing a H2 Shomate object in JSON format is shown below.

{
 "class": "<class 'pmutt.empirical.shomate.Shomate'>",
 "type": "shomate",
 "name": "H2",
 "phase": "G",
 "elements": {
  "H": 2
 },
 "notes": null,
 "smiles": null,
 "model": null,
 "misc_models": [
  {
   "class": "<class 'pmutt.empirical.GasPressureAdj'>"
  }
 ],
 "a": [
  33.066178,
  -11.363417,
  11.432816,
  -2.772874,
  -0.158558,
  -9.980797,
  172.707974,
  0.0
 ],
 "T_low": 298.0,
 "T_high": 1000.0,
 "units": "J/mol/K"
}

Creating New pmutt Classes

Encoding

To ensure your new class can be encoded using the pmuttEncoder, the to_dict() method should be implemented. One of the entries of the dictionary should be 'class': str(self.__class__) so that it can be decoded later. The other elements should be the attributes that can be used to reinitialize the object and must be JSON-supported objects. A simple example using FreeTrans is shown below.

def to_dict(self):
    return {'class': str(self.__class__),
            'n_degrees': self.n_degrees,
            'molecular_weight': self.molecular_weight}

If the attributes are not supported by JSON (such as other pmutt objects), use their to_dict() methods to convert to JSON-supported objects. An example using StatMech is shown below.

def to_dict(self):
    return {'class': str(self.__class__),
            'trans_model': self.trans_model.to_dict(),
            'vib_model': self.vib_model.to_dict(),
            'rot_model': self.rot_model.to_dict(),
            'elec_model': self.elec_model.to_dict(),
            'nucl_model': self.nucl_model.to_dict()}

Decoding

To ensure your object can be decoded using the json_to_pmutt object hook, add an entry to the dictionary in the pmutt.io.json.type_to_class method. The key should be the type of your object in string format (i.e. the result of str(self.__class__)). Your class should also have the from_dict() class method to reinitialize your object. A simple example using FreeTrans is shown below.

from pmutt.io.json import remove_class

@classmethod
def from_dict(cls, json_obj):
    json_obj = remove_class(json_obj)
    return cls(**json_obj)

Similarly to encoding, sometimes your object contains pmutt objects. You can use the json_to_pmutt object hook to remake these objects. An example using StatMech is shown below.

from pmutt.io import json as json_pmutt

@classmethod
def from_dict(cls, json_obj):
    json_obj = remove_class(json_obj)
    trans_model = json_pmutt.json_to_pmutt(json_obj['trans_model'])
    vib_model = json_pmutt.json_to_pmutt(json_obj['vib_model'])
    rot_model = json_pmutt.json_to_pmutt(json_obj['rot_model'])
    elec_model = json_pmutt.json_to_pmutt(json_obj['elec_model'])
    nucl_model = json_pmutt.json_to_pmutt(json_obj['nucl_model'])

    return cls(trans_model=trans_model,
               vib_model=vib_model,
               rot_model=rot_model,
               elec_model=elec_model,
               nucl_model=nucl_model)

YAML

YAML Ain’t Markup Language (YAML) is a human friendly data serialization standard for all programming languages. All pmutt objects are natively supported by YAML.

Examples

Saving pmutt objects can be done by using pmuttEncoder().

import yaml

with open(yaml_path, 'w') as f_ptr:
    yaml.dump(pmutt_obj, f_ptr)

Loading pmutt objects can be done by using the object hook: json_to_pmutt().

import yaml

with open(yaml_path, 'r') as f_ptr:
    pmutt_obj = yaml.load(f_ptr)

Sample YAML File

YAML writes in a human-readable syntax. An example showing a H2 Shomate object in YAML format is shown below.

!!python/object:pmutt.empirical.shomate.Shomate
T_high: 1000.0
T_low: 298.0
_units: J/mol/K
a: !!python/object/apply:numpy.core.multiarray._reconstruct
  args:
  - !!python/name:numpy.ndarray ''
  - !!python/tuple [0]
  - !!binary |
    Yg==
  state: !!python/tuple
  - 1
  - !!python/tuple [8]
  - !!python/object/apply:numpy.dtype
    args: [f8, 0, 1]
    state: !!python/tuple [3, <, null, null, null, -1, -1, 0]
  - false
  - !!binary |
    e9tMhXiIQEDxngPLEbomwP9eCg+a3SZA/G1PkNguBsAZdELooEvEv6MHPgYr9iPAYw0XuaeWZUAA
    AAAAAAAAAA==
elements: {H: 2}
misc_models:
- !!python/object:pmutt.empirical.GasPressureAdj {}
model: null
n_sites: null
name: H2
notes: null
phase: G
smiles: null

VASP

vasp.set_vib_wavenumbers_from_outcar

Gaussian

gaussian.read_pattern
gaussian.read_zpe
gaussian.read_electronic_and_zpe
gaussian.read_frequencies
gaussian.read_rotational_temperatures
gaussian.read_molecular_mass
gaussian.read_rot_symmetry_num

Chemkin

chemkin.read_reactions
chemkin.write_EA
chemkin.write_gas
chemkin.write_surf
chemkin.write_T_flow
chemkin.write_tube_mole

OpenMKM

omkm.write_cti
omkm.write_yaml
omkm.get_species_phases
omkm.get_reactions_phases
omkm.get_interactions_phases
omkm.organize_phases