Repository: microcombustion/ctwrap

Issue:
Address NaturalNameWarning
In the current implementation, HDF groups are named by simulation tasks, which may include a period ('.') or other characters that prevent names from being used as attributes. E.g. a name `upstream.phi_2.4<mix>` triggers the following warning:
```
NaturalNameWarning: object name is not a valid Python identifier: 
'upstream.phi_2.4<mix>'; it does not match the pattern ``^[a-zA-Z_][a-zA-Z0-9_]*$``; 
you will not be able to use natural naming to access this object; 
using ``getattr()`` will still work, though
```
The warning is inconsequential but annoying ...

Discussion:
DavidAkinpelu: > Most of my comments are relatively minor (i.e. making CI/CD checks run, docstring formatting, ...)
> 
> The main change I am requesting is to move `write_hdf` into `ignition.py` and `adiabatic_flame.py` (i.e. `ctwrap` itself shouldn't prescribe how to save data any longer). Cantera's HDF methods are written in a way that most things are automatically documented.


ischoegl: Please leave this open.

Patch:
diff --git a/.gitignore b/.gitignore
index 8f40b98..ba7331f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,6 +14,7 @@ dist/
 downloads/
 eggs/
 .eggs/
+.idea/
 lib/
 lib64/
 parts/
diff --git a/ctwrap/__init__.py b/ctwrap/__init__.py
index bacc74f..3e67077 100644
--- a/ctwrap/__init__.py
+++ b/ctwrap/__init__.py
@@ -1,10 +1,6 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Package exports."""
-
-from .simulation import *
-from .parser import *
+from .simulation import Simulation, SimulationHandler
+from .parser import Parser, load_yaml, save_metadata
 from . import modules
-from . import fileio
 
 from ._version import __version__, __author__
diff --git a/ctwrap/_version.py b/ctwrap/_version.py
index b6e813e..b26f0ad 100644
--- a/ctwrap/_version.py
+++ b/ctwrap/_version.py
@@ -1,10 +1,9 @@
 """Versioning information/credits
-
 https://setuptools.readthedocs.io/en/latest/setuptools.html#specifying-your-project-s-version
 """
 
-__author__ = "I. Schoegl"
-__version_info__ = (0, 1, 1)
+__author__ = "I. Schoegl and D. Akinpelu"
+__version_info__ = (0, 2, 0, 'b')
 __version__ = '.'.join(map(str, __version_info__[:3]))
 if len(__version_info__) == 4:
     __version__ += __version_info__[-1]
diff --git a/ctwrap/fileio/__init__.py b/ctwrap/fileio/__init__.py
deleted file mode 100644
index d491729..0000000
--- a/ctwrap/fileio/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from .fileio import *
-from .yaml import *
diff --git a/ctwrap/fileio/csv.py b/ctwrap/fileio/csv.py
deleted file mode 100644
index e0af63e..0000000
--- a/ctwrap/fileio/csv.py
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Excel file input/output"""
-
-import pandas as pd
-import os
-
-# local imports
-from .yaml import flatten, nested
-
-__all__ = ['csvls', 'to_csv', 'from_csv']
-
-
-def csvls(iname, path=None):
-
-    raise NotImplementedError('to be done')
-
-
-def to_csv(oname, groups, path=None, mode='a', force=True):
-
-    raise NotImplementedError('to be done')
-
-
-def from_csv(iname, path=None):
-
-    raise NotImplementedError('to be done')
diff --git a/ctwrap/fileio/fileio.py b/ctwrap/fileio/fileio.py
deleted file mode 100644
index d9af69c..0000000
--- a/ctwrap/fileio/fileio.py
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Generic file input/output."""
-
-from .h5 import *
-from .xlsx import *
-from .csv import *
-
-supported = ('.h5', '.hdf', '.hdf5', '.xlsx', '.csv')
-
-
-def ls(iname, path=None):
-    """List contents of file / file structure"""
-
-    if iname is None:
-        return
-
-    # file extension
-    frmt = '.' + iname.split('.')[-1]
-
-    # save configuration to output file
-    if frmt in {'.h5', '.hdf5', '.hdf'}:
-        h5ls(iname, path=path)
-    elif frmt == '.xlsx':
-        xlsxls(iname, path=path)
-    elif frmt == '.csv':
-        csvls(iname, path=path)
-    else:
-        raise RuntimeError('unknown file format `{}`'.format(frmt))
-
-
-def save(oname, data, mode='a', force=True, path=None):
-    """Save data to file / file structure"""
-
-    if oname is None:
-        return
-
-    # file extension
-    frmt = '.' + oname.split('.')[-1]
-
-    # save configuration to output file
-    if frmt in {'.h5', '.hdf5', '.hdf'}:
-        to_hdf(oname, data, mode=mode, force=force, path=path)
-    elif frmt == '.xlsx':
-        to_xlsx(oname, data, mode=mode, force=force, path=path)
-    elif frmt == '.csv':
-        to_csv(oname, data, mode=mode, force=force, path=path)
-    else:
-        raise RuntimeError('unknown file format `{}`'.format(frmt))
-
-
-def load(iname, path=None):
-    """Load data from file / file structure"""
-
-    if iname is None:
-        return
-
-    # file extension
-    frmt = '.' + iname.split('.')[-1]
-
-    # save configuration to output file
-    if frmt in {'.h5', '.hdf5', '.hdf'}:
-        return from_hdf(iname, path=path)
-    elif frmt == '.xlsx':
-        return from_xlsx(iname, path=path)
-    elif frmt == '.csv':
-        return from_csv(iname, path=path)
-    else:
-        raise RuntimeError('unknown file format `{}`'.format(frmt))
diff --git a/ctwrap/fileio/h5.py b/ctwrap/fileio/h5.py
deleted file mode 100644
index e067f5f..0000000
--- a/ctwrap/fileio/h5.py
+++ /dev/null
@@ -1,99 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Functions handling h5 (hdf5) input/output."""
-
-import pandas as pd
-import os
-
-# filter warning as group names may not be valid python identifiers
-import warnings
-warnings.filterwarnings("ignore",
-                        "object name is not a valid Python identifier:")
-
-# local imports
-from .yaml import flatten, nested
-
-__all__ = ['h5ls', 'to_hdf', 'from_hdf']
-
-
-def _getfile(fname, path=None):
-    """helper function"""
-
-    if path not in ['', None]:
-        fname = (os.sep).join([path, fname])
-
-    return fname, os.path.isfile(fname)
-
-
-def h5ls(iname, path=None):
-    """Retrieve names of groups within a hdf file."""
-
-    fname, fexists = _getfile(iname, path=path)
-    if not fexists:
-        return []
-
-    with pd.HDFStore(fname) as hdf:
-        groups = [k.lstrip('/') for k in hdf.keys()]
-
-    # equivalent with h5py
-    # with h5py.File(fname, 'r') as hdf:
-    #     groups = {k: 'Group' for k in hdf.keys()}
-
-    return groups
-
-
-def to_hdf(oname, groups, path=None, mode='a', force=True):
-    """Write content to group(s) of hdf5 container """
-
-    # file check
-    fname, fexists = _getfile(oname, path=path)
-    if fexists and mode == 'w' and not force:
-        msg = 'Cannot overwrite existing file `{}` (use force to override)'
-        raise RuntimeError(msg.format(oname))
-
-    existing = h5ls(fname)
-    for g in groups:
-
-        if mode == 'a' and g in existing and not force:
-            msg = 'Cannot overwrite existing group `{}` (use force to override)'
-            raise RuntimeError(msg.format(g))
-
-        data = groups[g]
-        if isinstance(data, dict):
-            data = pd.Series(flatten(data))
-            data.to_hdf(fname, g, mode=mode)
-        elif isinstance(data, (pd.DataFrame, pd.Series)):
-            data.to_hdf(fname, g, mode=mode)
-        elif data is None:
-            # print('no data frame')
-            pass
-        else:
-            # ignore anything else
-            pass
-
-        # prevent overwriting of existing groups
-        mode = 'a'
-
-
-def from_hdf(iname, path=None):
-    """Load content from hdf file"""
-
-    # check file
-    fname, fexists = _getfile(iname, path=path)
-    if not fexists:
-        msg = 'File `{}` does not exist'
-        raise RuntimeError(msg.format(oname))
-
-    # retrieve content
-    with pd.HDFStore(fname) as hdf:
-        groups = [k.lstrip('/') for k in hdf.keys()]
-
-        out = {}
-        for g in groups:
-
-            data = pd.read_hdf(hdf, g)
-            if isinstance(data, pd.Series):
-                data = nested(dict(data))
-            out[g] = data
-
-    return out
diff --git a/ctwrap/fileio/xlsx.py b/ctwrap/fileio/xlsx.py
deleted file mode 100644
index 46da0c9..0000000
--- a/ctwrap/fileio/xlsx.py
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Functions handling Excel input/output"""
-
-import pandas as pd
-import os
-
-# filter warning as group names may not be valid python identifiers
-import warnings
-warnings.filterwarnings("ignore",
-                        "object name is not a valid Python identifier:")
-
-# local imports
-from .yaml import flatten, nested
-
-__all__ = ['xlsxls', 'to_xlsx', 'from_xlsx']
-
-
-def _getfile(fname, path=None):
-    """helper function"""
-
-    if path not in ['', None]:
-        fname = (os.sep).join([path, fname])
-
-    return fname, os.path.isfile(fname)
-
-
-def xlsxls(iname, path=None):
-    """Retrieve names of sheets within a xlsx file"""
-
-    fname, fexists = _getfile(iname, path=path)
-    if not fexists:
-        return []
-
-    with pd.ExcelFile(fname) as xlsx:
-        sheets = [s for s in xlsx.sheet_names]
-
-    return sheets
-
-
-def to_xlsx(oname, sheets, path=None, mode='a', force=True):
-    """Write content to sheet(s) of xlsx file"""
-
-    # file check
-    fname, fexists = _getfile(oname, path=path)
-    if fexists and mode == 'w' and not force:
-        msg = 'Cannot overwrite existing file `{}` (use force to override)'
-        raise RuntimeError(msg.format(oname))
-
-    existing = xlsxls(fname)
-    for s in sheets:
-
-        if mode == 'a' and s in existing and not force:
-            msg = 'Cannot overwrite existing sheet `{}` (use force to override)'
-            raise RuntimeError(msg.format(s))
-
-        data = sheets[s]
-        if isinstance(data, dict):
-            data = pd.Series(flatten(data))
-            with pd.ExcelWriter(fname, engine='openpyxl', mode=mode) as writer:
-                data.to_excel(writer, sheet_name=s)
-        elif isinstance(data, (pd.DataFrame, pd.Series)):
-            with pd.ExcelWriter(fname, engine='openpyxl', mode=mode) as writer:
-                data.to_excel(writer, sheet_name=s)
-        elif data is None:
-            # print('no data frame')
-            pass
-        else:
-            # ignore anything else
-            pass
-
-        # prevent overwriting of existing sheets
-        mode = 'a'
-
-
-def from_xlsx(iname, path=None):
-    """Load content from xlsx file"""
-
-    # check file
-    iname, fexists = _getfile(iname, path=path)
-    if not fexists:
-        msg = 'File `{}` does not exist'
-        raise RuntimeError(msg.format(oname))
-
-    # retrieve content
-    with pd.ExcelFile(iname) as xlsx:
-
-        sheets = xlsx.sheet_names
-
-        out = {}
-        for s in sheets:
-
-            data = pd.read_excel(xlsx, s)
-            if isinstance(data, pd.Series):
-                data = nested(dict(data))
-            out[s] = data
-
-    return out
diff --git a/ctwrap/fileio/yaml.py b/ctwrap/fileio/yaml.py
deleted file mode 100644
index cb4d9ff..0000000
--- a/ctwrap/fileio/yaml.py
+++ /dev/null
@@ -1,96 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Function handling file input/output."""
-
-import os
-import re
-
-try:
-    import ruamel_yaml as yaml
-except ImportError:
-    from ruamel import yaml
-
-from copy import deepcopy
-
-__all__ = ['load_yaml', 'flatten', 'nested']
-
-
-def load_yaml(fname, path=None, keys=None):
-    """Load yaml from file
-
-    Arguments:
-        fname (str): file name
-
-    Keyword Arguments:
-        path (str): relative/absolute path. Empty ('') for
-    """
-
-    if path is 'default':
-        fname = (os.sep).join([__DATA_PATH, fname])
-    elif path not in ['', None]:
-        fname = (os.sep).join([path, fname])
-
-    with open(fname) as yml:
-        out = yaml.load(yml, Loader=yaml.SafeLoader)
-
-    if keys is None:
-        return out
-    else:
-        return tuple([deepcopy(out[k]) for k in keys])
-
-
-def flatten(d):
-    """Flatten nested dictionary (recursive function)"""
-
-    out = {}
-    for k, v in d.items():
-        if isinstance(v, dict):
-
-            # recursion
-            inner = flatten(v)
-            out.update({'{}.{}'.format(k, kk): vv for kk, vv in inner.items()})
-
-        else:
-
-            # ensure all saved data is in string format
-            if isinstance(v, (tuple, list)):
-                out[k] = yaml.dump(v).rstrip()
-            elif v is None:
-                out[k] = 'null'
-            else:
-                # note: yaml.dump() adds '\n...\n' to scalars
-                out[k] = yaml.dump(v).rstrip().rstrip('.').rstrip()
-
-    return out
-
-
-def nested(d):
-    """Create nested dictionary (recursive function)"""
-
-    out = {}
-    keys = list(d.keys())
-    ukeys = list(set([k.split('.')[0] for k in keys]))
-    ukeys.sort()
-
-    loader = yaml.SafeLoader
-    for uk in ukeys:
-
-        if uk in keys:
-
-            # recreate tuple / string
-            if isinstance(d[uk], str):
-                out[uk] = yaml.load(d[uk], Loader=loader)
-            else:
-                out[uk] = d[uk]
-
-        else:
-
-            # start recursion
-            replace = '{}.'.format(uk)
-            inner = {
-                kk.replace(replace, ''): vv
-                for kk, vv in d.items() if uk in kk
-            }
-            out[uk] = nested(inner)
-
-    return out
diff --git a/ctwrap/modules/adiabatic_flame.py b/ctwrap/modules/adiabatic_flame.py
index dd2f692..134dc1b 100644
--- a/ctwrap/modules/adiabatic_flame.py
+++ b/ctwrap/modules/adiabatic_flame.py
@@ -1,13 +1,12 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
+""" Module to run adiabatic flame simulation"""
+
+import warnings
 
 from ruamel import yaml
-import pandas as pd
-import numpy as np
 
 from ctwrap import Parser
 
-import warnings
+
 try:
     import cantera as ct
 except ImportError as err:
@@ -35,31 +34,24 @@ def defaults():
     return yaml.load(__DEFAULTS, Loader=yaml.SafeLoader)
 
 
-def run(name,
-        chemistry=None,
-        upstream=None,
-        domain=None,
-        loglevel=0):
-    """Function handling reactor simulation.
+def run(name, chemistry=None, upstream=None, domain=None,
+        loglevel= 0):
+    """
+    Function handling adiabatic flame simulation.
+    The function uses the class 'ctwrap.Parser' in conjunction with 'pint.Quantity'
+    for handling and conversion of units.
 
     Arguments:
-        name (str): name used for output
-
-    Keyword Arguments:
+        name (str): name of the task
         chemistry (dict): reflects yaml 'configuration:chemistry'
         upstream  (dict): reflects yaml 'configuration:upstream'
         domain    (dict): reflects yaml 'configuration:simulation'
         loglevel   (int): amount of diagnostic output (0 to 8)
 
     Returns:
-        dict: dictionary with pandas DataFrame entries
-
-    The function uses the class 'ctwrap.Parser' in conjunction with 'pint.Quantity'
-    for handling and conversion of units.
+        Dictionary containing Cantera `Flamebase` object
     """
 
-    out = {}
-
     # initialize
 
     # IdealGasMix object used to compute mixture properties, set to the state of the
@@ -82,9 +74,7 @@ def run(name,
     if loglevel > 0:
         f.show_solution()
 
-    # entries used for output
-    keys = ['z (m)', 'u (m/s)', 'V (1/s)', 'T (K)', 'rho (kg/m3)'] + \
-        gas.species_names
+    out = {}
 
     # Solve with mixture-averaged transport model
     f.transport_model = 'Mix'
@@ -94,10 +84,10 @@ def run(name,
     if loglevel > 0:
         f.show_solution()
     msg = '    {0:s}: mixture-averaged flamespeed = {1:7f} m/s'
-    print(msg.format(name, f.u[0]))
+    print(msg.format(name, f.velocity[0]))
 
-    out[name + '<mix>'] = pd.DataFrame(
-        np.vstack([f.grid, f.u, f.V, f.T, f.density, f.X]).T, columns=keys)
+    group = name + "<mix>"
+    out[group] = f
 
     # Solve with multi-component transport properties
     f.transport_model = 'Multi'
@@ -105,17 +95,30 @@ def run(name,
     if loglevel > 0:
         f.show_solution()
     msg = '    {0:s}: multi-component flamespeed  = {1:7f} m/s'
-    print(msg.format(name, f.u[0]))
+    print(msg.format(name, f.velocity[0]))
 
-    out[name + '<multi>'] = pd.DataFrame(
-        np.vstack([f.grid, f.u, f.V, f.T, f.density, f.X]).T, columns=keys)
+    group = name + "<multi>"
+    out[group] = f
 
     return out
 
 
-###
+def save(filename, data, task=None):
+    """
+    This function saves the output from the run method
 
-if __name__ == "__main__":
+    Arguments:
+        filename (str): naming of file
+        data (Dict): data to be saved
+        task (str): name of task if running variations
+    """
+
+    for group, flame in data.items():
+        flame.write_hdf(filename=filename, group=group,
+                        mode='a', description=task)
 
+
+if __name__ == "__main__":
     config = defaults()
     df = run('main', **config, loglevel=1)
+    save('adiabatic_flame.h5', df)
diff --git a/ctwrap/modules/ignition.py b/ctwrap/modules/ignition.py
index a535fae..7c169c5 100644
--- a/ctwrap/modules/ignition.py
+++ b/ctwrap/modules/ignition.py
@@ -1,12 +1,11 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import pandas as pd
+""" Module to run ignition simulation """
+import warnings
 from ruamel import yaml
 
+
 from ctwrap import Parser
 
-import warnings
+
 try:
     import cantera as ct
 except ImportError as err:
@@ -38,19 +37,21 @@ def defaults():
     return yaml.load(__DEFAULTS, Loader=yaml.SafeLoader)
 
 
-def run(name, chemistry=None, initial=None, simulation=None):
-    """Function handling reactor simulation.
+def run(name, chemistry=None,
+        initial=None, simulation=None):
+    """
+    Function handling reactor simulation.
+    The function uses the class 'ctwrap.Parser' in conjunction with 'pint.Quantity'
+    for handling and conversion of units.
 
-    Keyword Arguments:
+    Arguments:
+        name (str): name of the task
         chemistry  (dict): reflects yaml 'configuration:chemistry'
         initial    (dict): reflects yaml 'configuration:initial'
         simulation (dict): reflects yaml 'configuration:simulation'
 
     Returns:
-        dict: dictionary with pandas DataFrame entries
-
-    The function uses the class 'ctwrap.Parser' in conjunction with 'pint.Quantity'
-    for handling and conversion of units.
+        Dictionary containing Cantera SolutionArray
     """
 
     # initialize
@@ -78,33 +79,43 @@ def run(name, chemistry=None, initial=None, simulation=None):
     delta_t = par.delta_t
     n_points = par.n_points
 
-    # preprocess
-
-    # create pandas data frame
-    keys = ['t (s)', 'T (K)', 'rho (kg/m3)'] + \
-        gas.species_names
-    df = pd.DataFrame(columns=keys)
+    # SolutionArray
+    states = ct.SolutionArray(gas, extra=['t'])
 
     # Run simulation
-
     time = sim.time
 
     # loop: note that advance() returns boolean
-    for i in range(par.n_points):
+    for i in range(n_points):
 
         time += delta_t
         sim.advance(time)
 
-        df_len = len(df)
-        row = (time, gas.T, gas.density) + tuple(gas.X)
-        df.loc[df_len] = row
+        states.append(reactor.thermo.state, t=time)
+
+
+    return {name: states}
+
 
-    return {name: df}
+def save(filename, data, task=None):
+    """
+    This function saves the output from the run method
+
+    Arguments:
+        filename (str): naming of file
+        data (Dict): data to be saved
+        task (str): name of task if running variations
+    """
 
+    attrs = {'description': task}
+    for group, states in data.items():
+        states.write_hdf(filename=filename, group=group,
+                                 mode='a', attrs=attrs)
 
 ###
 
-if __name__ == "__main__":
 
+if __name__ == "__main__":
     config = defaults()
     out = run('main', **config)
+    save('ignition.h5', out)
diff --git a/ctwrap/modules/minimal.py b/ctwrap/modules/minimal.py
index e42c142..902e5ca 100644
--- a/ctwrap/modules/minimal.py
+++ b/ctwrap/modules/minimal.py
@@ -1,11 +1,9 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Minimal example for ctwrap compatible simulation module"""
 
-from ruamel import yaml
-import pandas as pd
 import time
 
+from ruamel import yaml
+
 __DEFAULTS = """\
 # default parameters for the `minimal` module
 sleep: 0.2
@@ -17,17 +15,24 @@ def defaults():
     return yaml.load(__DEFAULTS, Loader=yaml.SafeLoader)
 
 
-def run(name, sleep=.2, **kwargs):
-    """this function does nothing"""
+def run(name, sleep=.2):
+    """This function does nothing"""
 
     # initialize
     print('    - `minimal`: sleeping for {} seconds ...'.format(sleep))
     time.sleep(sleep)
 
-    return {name: pd.DataFrame({'sleep': [sleep]})}
+    return {name: {'sleep': [sleep]}}
+
+
+def save(data, output=None, mode='a') :
+    """this function does nothing"""
+
+    return
 
 
 if __name__ == "__main__":
 
     config = defaults()
-    run('main', **config)
+    out = run('main', **config)
+    save(out)
diff --git a/ctwrap/parser.py b/ctwrap/parser.py
index e490fa4..91d7beb 100644
--- a/ctwrap/parser.py
+++ b/ctwrap/parser.py
@@ -1,33 +1,63 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Parser object."""
-
+import os
+from typing import Optional, Dict, Any, Tuple, KeysView, Union
+import json
 from pint import UnitRegistry
+from copy import deepcopy
+from ruamel import yaml
+import h5py
+
 
 ureg = UnitRegistry()
 
-__all__ = ['Parser']
+__all__ = ['Parser', 'load_yaml', 'save_metadata']
 
 
 class Parser(object):
-    """A lightweight class that handles units.
+    """
+    A lightweight class that handles units.
 
-    The handling mimics that of a python dictionary, while adding direct access to 
+    The handling mimics that of a python dictionary, while adding direct access to
     keyed values via attributes.
     """
 
-    def __init__(self, dct):
+    def __init__(self, dct: Dict[str, Any]) -> None:
+        """
+        Constructor
+
+        Argument:
+            dct (dict) : dictionary to be parsed
+        """
 
         self.raw = dct
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: str) -> str:
+        """
+        Get attribute
+
+        Arguments:
+             attr (str): attribute
+
+        Returns:
+            Atrribute
+        """
 
         if attr not in self.raw:
             raise AttributeError("unknown attribute '{}'".format(attr))
 
         return self[attr]
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str) -> Union[str, bool, float, Tuple]:
+        """
+        Get item
+
+        Argument:
+            key (str): key
+
+        Returns:
+            Corresponding values from the key
+
+        """
 
         val = self.raw[key]
 
@@ -39,5 +69,62 @@ class Parser(object):
     def __repr__(self):
         return repr(self.raw)
 
-    def keys(self):
+    def keys(self) -> KeysView[str]:
+        """
+        Returns list of keys
+        """
         return self.raw.keys()
+
+
+def load_yaml(fname: str,
+              path: Optional[str] = None,
+              keys: Optional[str] = None) -> Tuple[Any, ...]:
+    """
+    Load yaml from file
+
+    Arguments:
+        fname (str) : file name
+        path (str) : relative/absolute path. Empty ('') for
+        keys (str) : key
+    Returns:
+        Dictionary containing the required keys
+    """
+
+    if path not in ['', None]:
+        fname = (os.sep).join([path, fname])
+
+    with open(fname) as yml:
+        out = yaml.load(yml, Loader=yaml.SafeLoader)
+
+    if keys is None:
+        return out
+    else:
+        return tuple([deepcopy(out[k]) for k in keys])
+
+
+def save_metadata(output: Dict[str, Any],
+                  metadata: Dict[str, Any]) -> None:
+    """
+    Function save metadata as attributes to file
+
+    Arguments:
+        output (dict): file information
+        metadata (dict): metadata
+    """
+
+    oname = output['file_name']
+    opath = output['path']
+    formatt = output['format']
+    force = output['force_overwrite']
+
+    if oname is None:
+        return
+    if opath is not None:
+        oname = os.path.join(opath, oname)
+
+    with h5py.File(oname, 'r+') as f:
+        for key, val in metadata.items():
+            if isinstance(val, dict):
+                f.attrs[key] = json.dumps(val)
+            else:
+                f.attrs[key] = val
diff --git a/ctwrap/simulation.py b/ctwrap/simulation.py
index b89235d..56d6f5a 100644
--- a/ctwrap/simulation.py
+++ b/ctwrap/simulation.py
@@ -1,18 +1,22 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """Object handling variations."""
 
 import os
 from copy import deepcopy
-import warnings
-import  importlib
+import importlib
+import h5py
+
+from typing import Dict, Any, Optional, TypeVar, Union
+
 
 # multiprocessing
 import multiprocessing as mp
 import queue  # imported for using queue.Empty exception
 
-# ctwrap specific imports
-from . import fileio
+# ctwrap specific import
+from .parser import load_yaml, save_metadata
+
+
+supported = ('.h5', '.hdf', '.hdf5')
 
 __all__ = ['Simulation', 'SimulationHandler']
 
@@ -21,16 +25,21 @@ indent2 = '   - '
 
 
 class Simulation(object):
-    """The Simulation class wraps modules into an object.
-    Attributes:
-        data (dict): dictionary of pandas.DataFrame objects
+    """
+    The Simulation class wraps modules into an object.
     Required module functions 'run' and 'defaults' are passed through
+
+    Attributes:
+        data (dict): dictionary
+
     """
 
-    def __init__(self, module, output=None):
-        """Constructor for `Simulation` object.
+    def __init__(self, module: str, output: Dict[str, Any] = None):
+        """
+        Constructor for `Simulation` object.
+
         Arguments:
-           module (module):  handle name or handle to module running the simulation
+           module (module): handle name or handle to module running the simulation
            output (dict): generated by `SimulationHandler`
         """
 
@@ -47,32 +56,40 @@ class Simulation(object):
         self.data = None
 
     @classmethod
-    def from_module(cls, module, output=None):
-        """Alternative constructor for `Simulation` object.
-        Arguments:
-           module (module):  handle name or handle to module running the simulation
-           output (dict): generated by `SimulationHandler`
+    def from_module(cls,
+                    module: str,
+                    output: Optional[Dict[str, Any]] = None) -> \
+            Union['simulation', Dict[str, Any], str]:
+        """
+        Alternative constructor for `Simulation` object.
         The `from_module` instantiation call renames the class
         based on the module name.
+
+        Arguments:
+           module (module): handle name or handle to module running the simulation
+           output (dict): generated by `SimulationHandler`
         """
 
         # create a name that reflect the module name (CamelCase)
         if isinstance(module, str):
-            name  = module.split('.')[-1]
+            name = module.split('.')[-1]
         else:
             name = module.__name__.split('.')[-1]
             module = module.__name__
         name = ''.join([m.title() for m in name.split('_')])
 
-        return type(name, (cls, ), {})(module, output)
+        return type(name, (cls,), {})(module, output)
 
-    def run(self, name='defaults', config=None, **kwargs):
-        """Run function holding configuration in dictionary.
-        Args:
+    def run(self, name: Optional[str] ='defaults',
+            config: Optional[Dict[str, Any]] = None,
+            **kwargs: str) -> None:
+        """
+        Run function holding configuration in dictionary.
+
+        Arguments:
            name (string): name of simulation run
-           config (dict): configuration
-        Kwargs:
-           kwargs (optional): depends on implementation of __init__
+           config (dict, optional): configuration
+           **kwargs (optional): depends on implementation of __init__
         """
 
         self._module = importlib.import_module(self._module)
@@ -83,30 +100,84 @@ class Simulation(object):
         self.data = self._module.run(name, **config, **kwargs)
         self._module = self._module.__name__
 
-    def defaults(self):
+    def defaults(self) -> Dict[str, Any]:
         """Pass-through returning module defaults as a dictionary"""
         return self._module.defaults()
 
-    def _save(self):
-        """Save simulation data (hidden)"""
+    def _save(self, mode="a", task=None, **kwargs: str) -> None:
+        """
+        Save simulation data (hidden)
+
+        Arguments:
+            **kwargs (optional): keyword arguments
+        """
 
         if self._output is None:
             return
 
-        oname = self._output['file_name']
-        opath = self._output['path']
+        filename = self._output['file_name']
+
+        if filename is None:
+            return
+
+        filepath = self._output['path']
+        formatt = "." + self._output['format']
         force = self._output['force_overwrite']
 
-        fileio.save(oname, self.data, mode='a', force=force, path=opath)
+        if filepath is not None:
+            filename = os.path.join(filepath, filename)
+
+        # file check
+        fexists = os.path.isfile(filename)
+
+        if fexists:
+            with h5py.File(filename, 'r') as hdf:
+                for group in hdf.keys():
+                    if group in self.data and mode == 'a' and not force:
+                        msg = 'Cannot overwrite existing ' \
+                              'group `{}` (use force to override)'
+                        raise RuntimeError(msg.format(group))
+
+        if formatt in supported:
+            self._module = importlib.import_module(self._module)
+            self._module.save(filename, self.data, task)
+            self._module = self._module.__name__
+        else:
+            raise ValueError("Invalid file format {}".format(formatt))
+
+    def _save_metadata(self,
+                       metadata: Optional[Dict[str, Any]] = None,
+                       ) -> None:
+        """
+        This function calls the module save method.
+
+        Arguments:
+            metadata (dict): data to be saved
+        """
+
+        if metadata is None:
+            return
+
+        if self._output is None:
+            return
+
+        save_metadata(self._output, metadata)
 
 
 class SimulationHandler(object):
-    """Class handling parameter variations.
+    """
+    Class handling parameter variations.
     Class adds methods to switch between multiple configurations.
     """
 
-    def __init__(self, defaults, variation, output, verbosity=0):
-        """Constructor
+    def __init__(self,
+                 defaults: Dict[str, Any],
+                 variation: Dict[str, Any],
+                 output: Dict[str, Any],
+                 verbosity: Optional[int] = 0):
+        """
+        Constructor for `SimulationHandler` object.
+
         Arguments:
             defaults (dict): dictionary containing simulation defaults
             variation (dict): dictionary containing 'entry' and 'values'
@@ -116,7 +187,7 @@ class SimulationHandler(object):
 
         # parse arguments
         self._defaults = defaults
-        #self._variation = variation
+        self._variation = variation
         self._output = output
         self.verbosity = verbosity
 
@@ -137,37 +208,34 @@ class SimulationHandler(object):
                 self._entry, self._values))
 
         if self._output is not None:
-
             var = variation.copy()
             var['tasks'] = [t for t in self.tasks]
             var['tasks'].sort()
 
             # assemble information
-            info = {
+            self._metadata = {
                 'defaults': self._defaults,
                 'variation': var,
             }
 
-            # save to file
-            oname = self._output['file_name']
-            path = self._output['path']
-            force = self._output['force_overwrite']
-
-            fileio.save(oname, info, mode='w', force=force, path=path)
-
     @classmethod
-    def from_yaml(cls, yaml_file, name=None, path=None, **kwargs):
-        """Alternate constructor using YAML file as input.
-        Args:
+    def from_yaml(cls, yaml_file: str,
+                  name: Optional[str] = None,
+                  path: Optional[str] = None,
+                  **kwargs: str):
+        """
+        Alternate constructor using YAML file as input.
+
+        Arguments:
            yaml_file (string): yaml file
-        Kwargs:
            name (string): output name (overrides yaml)
            path (string): file path (both yaml and output)
-           kwargs (optional): dependent on implementation (e.g. verbosity, reacting)
+           ** kwargs (optional): dependent on implementation
+           (e.g. verbosity, reacting)
         """
 
         # load configuration from yaml
-        content = fileio.load_yaml(yaml_file, path)
+        content = load_yaml(yaml_file, path)
         output = content.get('output', {})
 
         # naming priorities: keyword / yaml / automatic
@@ -178,14 +246,20 @@ class SimulationHandler(object):
         return cls.from_dict(content, name=name, path=path, **kwargs)
 
     @classmethod
-    def from_dict(cls, content, name=None, path=None, **kwargs):
-        """Alternate constructor using a dictionary as input.
-        Args:
-           content (dict): dictionary
-        Kwargs:
+    def from_dict(cls, content: Dict[str, Any],
+                  name: Optional[str] = None,
+                  path: Optional[str] = None,
+                  **kwargs: str) -> \
+            Union['simulationHandler', Dict[str, Any], str]:
+        """
+        Alternate constructor using a dictionary as input.
+
+        Arguments:
+           content (dict): dictionary from yaml input
            name (string): output name (overrides yaml)
            path (string): output path (overrides yaml)
-           kwargs (optional): dependent on implementation (e.g. verbosity, reacting)
+           ** kwargs (optional): dependent on implementation
+           (e.g. verbosity, reacting)
         """
 
         assert 'ctwrap' in content, 'obsolete yaml file format'
@@ -199,9 +273,20 @@ class SimulationHandler(object):
         return cls(defaults, variation, output, **kwargs)
 
     @staticmethod
-    def _parse_output(dct, fname=None, fpath=None):
-        """Parse output dictionary (hidden function)
+    def _parse_output(dct: Dict[str, Any],
+                      fname: Optional[str] = None,
+                      fpath: Optional[str] = None):
+        """
+        Parse output dictionary (hidden function)
         Overrides defaults with keyword arguments.
+
+        Arguments:
+           dct (dict, optional): dictionary from yaml input
+           fname (name, optional): filename (overrides yaml)
+           fpath (string, optional): output path (overrides yaml)
+
+        Returns:
+            Dictionary containng output information
         """
 
         if dct is None:
@@ -213,7 +298,7 @@ class SimulationHandler(object):
         if 'format' not in out:
             out['format'] = ''
         if 'force_overwrite' not in out:
-            out['force_overwrite'] = True
+            out['force_overwrite'] = False
 
         fformat = out['format']
 
@@ -228,7 +313,7 @@ class SimulationHandler(object):
                 fpath = head
 
             fname, ext = os.path.splitext(fname)
-            if ext in fileio.supported:
+            if ext in supported:
                 fformat = ext
 
             out['name'] = fname
@@ -258,11 +343,19 @@ class SimulationHandler(object):
         for task in self.tasks:
             yield task
 
-    def __getitem__(self, task):
+    def __getitem__(self, task: str):
         return self.configuration(task)
 
-    def configuration(self, task):
-        """Return """
+    def configuration(self, task: str):
+        """
+        Return configuration.
+
+        Argument:
+            task(str) : task to do
+
+        Return:
+            updated configuration dictionary based on the task
+        """
 
         value = self.tasks.get(task, None)
         assert task is not None, 'invalid value'
@@ -291,10 +384,12 @@ class SimulationHandler(object):
 
     @property
     def verbose(self):
+        """verbosity"""
         return self.verbosity > 0
 
     @property
     def output_name(self):
+        """return output name"""
         if self._output['path'] is None:
             return self._output['file_name']
         else:
@@ -306,7 +401,16 @@ class SimulationHandler(object):
         e = self._entry
         return {'{}_{}'.format(e, v): v for v in self._values}
 
-    def run_task(self, sim, task, **kwargs):
+    def run_task(self, sim: Simulation, task: str, **kwargs:str):
+        """
+        Function to run a specific task.
+
+        Arguments:
+            sim (object): instance of Simulation class
+            task (str): task to do
+            ** kwargs (optional): dependent on implementation
+            (e.g. verbosity, reacting)
+        """
 
         assert task in self.tasks, 'unknown task `{}`'.format(task)
 
@@ -317,10 +421,25 @@ class SimulationHandler(object):
         config = self.configuration(task)
 
         obj.run(task, config, **kwargs)
-        obj._save()
+        obj._save(task=task)
+        obj._save_metadata(self._metadata)
+
+    def run_serial(self,
+                   sim: Simulation,
+                   verbosity: Optional[int] = None,
+                   **kwargs: str) -> bool:
+        """
+        Run variation in series.
 
-    def run_serial(self, sim, verbosity=None, **kwargs):
-        """Run variation in series"""
+        Arguments:
+            sim (object): instance of Simulation class
+            verbosity (int, optional): verbosity
+            ** kwargs (optional): dependent on implementation
+             (e.g. verbosity, reacting)
+
+        Returns:
+            return True when task is completed
+        """
 
         assert isinstance(sim, Simulation), 'need simulation object'
 
@@ -333,7 +452,6 @@ class SimulationHandler(object):
         tasks = [t for t in self.tasks]
         tasks.sort()
         for t in tasks:
-
             if verbosity > 0:
                 print(indent1 + 'processing `{}`'.format(t))
 
@@ -341,16 +459,28 @@ class SimulationHandler(object):
             config = self.configuration(t)
 
             obj.run(t, config, **kwargs)
-            obj._save()
-
+            obj._save(task=t)
+        obj._save_metadata(self._metadata)
         return True
 
     def run_parallel(self,
-                     sim,
-                     number_of_processes=None,
-                     verbosity=None,
-                     **kwargs):
-        """Run variation using multiprocessing"""
+                     sim: Simulation,
+                     number_of_processes: Optional[int] = None,
+                     verbosity: Optional[str] = None,
+                     **kwargs: str) -> bool:
+        """
+        Run variation using multiprocessing.
+
+        Arguments:
+            sim (object): instance of Simulation class
+            number_of_processes(int, optional): number of processes
+            verbosity(int, optional): verbosity level
+            ** kwargs (optional): dependent on implementation
+             (e.g. verbosity, reacting)
+
+        Returns:
+            return True when task is completed
+        """
 
         assert isinstance(sim, Simulation), 'need simulation object'
 
@@ -381,7 +511,7 @@ class SimulationHandler(object):
             p = mp.Process(
                 target=worker,
                 args=(tasks_to_accomplish, finished_tasks, sim._module, lock,
-                      self._output, verbosity))
+                      self._output, self._metadata, verbosity))
             processes.append(p)
             p.start()
 
@@ -398,8 +528,26 @@ class SimulationHandler(object):
         return True
 
 
-def worker(tasks_to_accomplish, tasks_that_are_done, module, lock, output,
-           verbosity):
+def worker(tasks_to_accomplish, tasks_that_are_done, module: str, lock,
+           output: Dict[str, Any],
+           metadata: Dict[str, Any],
+           verbosity: int) -> True:
+    """
+    Worker function.
+
+    Arguments:
+        tasks_to_accomplish (queue): multiprocessing queue of remaining task
+        tasks_that_are_done (queue): multiprocessing queue of complted task
+        module (str): name of handler to be run
+        lock (lock): multiprocessing lock
+        output (dict): dictionary containing output information
+        metadata (dict): dictioanry containing metadata
+        verbosity (int): verbosity level
+
+    Returns:
+        True when tasks are completed
+
+    """
 
     this = mp.current_process().name
 
@@ -427,9 +575,14 @@ def worker(tasks_to_accomplish, tasks_that_are_done, module, lock, output,
                 print(msg.format(task, this))
             obj.run(task, config, **kwargs)
             with lock:
-                obj._save()
+                obj._save(task=task)
 
             msg = 'case `{}` completed by {}'.format(task, this)
             tasks_that_are_done.put(msg)
 
+    if verbosity > 1:
+        print("Appending metadata")
+
+    obj._save_metadata(metadata)
+
     return True
diff --git a/docs/conf.py b/docs/conf.py
index d0b13ca..d8c9a0d 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -42,6 +42,7 @@ release = __version__
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
+    'sphinx.ext.napoleon',
     'sphinx.ext.autodoc',
     'sphinx_autodoc_typehints',
     'sphinx.ext.viewcode',
@@ -75,4 +76,4 @@ html_theme = 'nature' #'alabaster'
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
\ No newline at end of file
+html_static_path = ['_static']
diff --git a/docs/pages/parser.rst b/docs/pages/parser.rst
index 7f790c8..d35317a 100644
--- a/docs/pages/parser.rst
+++ b/docs/pages/parser.rst
@@ -3,3 +3,8 @@ ctwrap Parser
 
 .. automodule:: ctwrap.parser
    :members:
+
+.. autofunction:: ctwrap.load_yaml
+
+.. autofunction:: ctwrap.save_metadata
+
diff --git a/examples/adiabatic_flame_example.ipynb b/examples/adiabatic_flame_example.ipynb
index ce14db7..bbf645f 100644
--- a/examples/adiabatic_flame_example.ipynb
+++ b/examples/adiabatic_flame_example.ipynb
@@ -18,29 +18,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "env: OMP_NUM_THREADS=1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%env OMP_NUM_THREADS=1"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import cantera as ct\n",
-    "import ctwrap as cw"
+    "import ctwrap as cw\n",
+    "import json"
    ]
   },
   {
@@ -61,20 +54,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<ctwrap.simulation.AdiabaticFlame at 0x7fdd4493dcf8>"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "sim = cw.Simulation.from_module(cw.modules.adiabatic_flame)\n",
     "sim"
@@ -82,20 +64,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "    defaults: mixture-averaged flamespeed = 0.711265 m/s\n",
-      "    defaults: multi-component flamespeed  = 0.727009 m/s\n",
-      "CPU times: user 338 ms, sys: 24.8 ms, total: 363 ms\n",
-      "Wall time: 386 ms\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%time\n",
     "sim.run()"
@@ -110,27 +81,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Simulations for entry `upstream.phi` with values: [0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<ctwrap.simulation.SimulationHandler at 0x7fdd681792e8>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "s = cw.SimulationHandler.from_yaml('adiabatic_flame.yaml', verbosity=1)\n",
     "s"
@@ -145,52 +98,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "    upstream.phi_0.6: mixture-averaged flamespeed = 0.924047 m/s\n",
-      "    upstream.phi_0.8: mixture-averaged flamespeed = 1.735133 m/s\n",
-      "    upstream.phi_0.6: multi-component flamespeed  = 0.934704 m/s\n",
-      "    upstream.phi_0.8: multi-component flamespeed  = 1.720514 m/s\n",
-      "    upstream.phi_1.0: mixture-averaged flamespeed = 2.322010 m/s\n",
-      "    upstream.phi_0.4: mixture-averaged flamespeed = 0.201058 m/s\n",
-      "    upstream.phi_1.0: multi-component flamespeed  = 2.289856 m/s\n",
-      "    upstream.phi_0.4: multi-component flamespeed  = 0.215256 m/s\n",
-      "    upstream.phi_1.2: mixture-averaged flamespeed = 2.716045 m/s\n",
-      "    upstream.phi_1.4: mixture-averaged flamespeed = 2.951101 m/s\n",
-      "    upstream.phi_1.2: multi-component flamespeed  = 2.671883 m/s\n",
-      "    upstream.phi_1.4: multi-component flamespeed  = 2.899580 m/s\n",
-      "    upstream.phi_1.8: mixture-averaged flamespeed = 3.045410 m/s\n",
-      "    upstream.phi_1.8: multi-component flamespeed  = 2.992115 m/s\n",
-      "    upstream.phi_1.6: mixture-averaged flamespeed = 3.051486 m/s\n",
-      "    upstream.phi_1.6: multi-component flamespeed  = 2.997080 m/s\n",
-      "    upstream.phi_2.0: mixture-averaged flamespeed = 2.973896 m/s\n",
-      "    upstream.phi_2.0: multi-component flamespeed  = 2.924909 m/s\n",
-      "    upstream.phi_2.2: mixture-averaged flamespeed = 2.860158 m/s\n",
-      "    upstream.phi_2.2: multi-component flamespeed  = 2.817677 m/s\n",
-      "    upstream.phi_2.4: mixture-averaged flamespeed = 2.726736 m/s\n",
-      "    upstream.phi_2.4: multi-component flamespeed  = 2.691135 m/s\n",
-      "    upstream.phi_2.6: mixture-averaged flamespeed = 2.586489 m/s\n",
-      "    upstream.phi_2.6: multi-component flamespeed  = 2.558451 m/s\n",
-      "CPU times: user 17.8 ms, sys: 19 ms, total: 36.8 ms\n",
-      "Wall time: 2.69 s\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%time\n",
     "s.run_parallel(sim, verbosity=0)"
@@ -205,13 +115,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
+    "import h5py\n",
     "import matplotlib.pyplot as plt\n",
     "import matplotlib as mpl\n",
-    "\n",
     "col = mpl.rcParams['axes.prop_cycle'].by_key()['color']\n",
     "n_col = len(col)"
    ]
@@ -225,37 +135,77 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# load data from output file\n",
-    "data = cw.fileio.from_hdf(s.output_name)\n",
-    "# data.keys()"
+    "data = h5py.File(s.output_name, 'r')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "mix = {k.split('<')[0]: data[k] for k in data if 'mix' in k}\n",
-    "mlt = {k.split('<')[0]: data[k] for k in data if 'multi' in k}\n",
-    "\n",
-    "tasks = data.get('variation')['tasks']\n",
-    "phi = data.get('variation')['values']\n",
-    "# tasks, phi"
+    "data.keys()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "up = data.get('defaults')['upstream']\n",
-    "# up"
+    "data.attrs.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "var = json.loads(data.attrs['variation'])\n",
+    "var"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "default = json.loads(data.attrs['defaults'])\n",
+    "default"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "up = default.get('upstream')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "phi = var.get('values')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mix = {k.split('<')[0]: dict(data[k]['flame']) for k in data if 'mix' in k}\n",
+    "mlt = {k.split('<')[0]: dict(data[k]['flame']) for k in data if 'multi' in k}"
    ]
   },
   {
@@ -269,29 +219,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# create figure\n",
     "fig, ax = plt.subplots(1)\n",
     "\n",
     "# plot results\n",
-    "u_mix = [ mix[t]['u (m/s)'][0] for t in tasks]\n",
-    "u_mlt = [ mlt[t]['u (m/s)'][0] for t in tasks]\n",
+    "u_mix = [ mix[t]['velocity'][0] for t in mix]\n",
+    "u_mlt = [ mlt[t]['velocity'][0] for t in mlt]\n",
     "\n",
     "ax.plot(phi, u_mix, marker='o', \n",
     "            linestyle='none', label='mixture-averaged') \n",
@@ -313,35 +250,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x432 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# create figure and adjust size\n",
     "fig, ax = plt.subplots(1)\n",
     "fig.set_size_inches(6.,6.)\n",
     "\n",
     "# plot results\n",
-    "for i, key in enumerate(tasks):\n",
+    "for i, key in enumerate(mix.keys()):\n",
     "    df = mix[key]\n",
     "    label = key.split('_')[1]\n",
-    "    ax.plot(1000*df['z (m)'], df['T (K)'], color=col[i % n_col], \n",
+    "    ax.plot(1000*df['grid'][:], df['T'][:], color=col[i % n_col], \n",
     "            linestyle='-', label=label) \n",
     "    df = mlt[key]\n",
-    "    ax.plot(1000*df['z (m)'], df['T (K)'], color=col[i % n_col], \n",
+    "    ax.plot(1000*df['grid'][:], df['T'][:], color=col[i % n_col], \n",
     "            linestyle=':', label=label) \n",
     "\n",
     "# add title/axis labels\n",
@@ -378,7 +302,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.6"
+   "version": "3.7.8"
   }
  },
  "nbformat": 4,
diff --git a/examples/ignition_example.ipynb b/examples/ignition_example.ipynb
index e8bccbc..5a411f4 100644
--- a/examples/ignition_example.ipynb
+++ b/examples/ignition_example.ipynb
@@ -18,49 +18,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "env: OMP_NUM_THREADS=1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%env OMP_NUM_THREADS=1"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "import matplotlib as mpl\n",
-    "\n",
+    "import h5py\n",
+    "import json\n",
     "col = mpl.rcParams['axes.prop_cycle'].by_key()['color']"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'0.1.0'"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import ctwrap as cw\n",
     "cw.__version__"
@@ -84,20 +66,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<ctwrap.simulation.Ignition at 0x7f10e150d438>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "sim = cw.Simulation.from_module(cw.modules.ignition)\n",
     "sim"
@@ -105,18 +76,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 494 ms, sys: 7.07 ms, total: 501 ms\n",
-      "Wall time: 515 ms\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%time\n",
     "sim.run()"
@@ -133,27 +95,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Simulations for entry `initial.phi` with values: [0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<ctwrap.simulation.SimulationHandler at 0x7f10e23d3b00>"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# create variation object\n",
     "fname = 'ignition.yaml'\n",
@@ -170,37 +114,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " * running simulation using 4 cores\n",
-      " * processing `initial.phi_0.4` (Process-1)\n",
-      " * processing `initial.phi_0.6` (Process-2)\n",
-      " * processing `initial.phi_0.8` (Process-3)\n",
-      " * processing `initial.phi_1.0` (Process-4)\n",
-      " * processing `initial.phi_1.2` (Process-2)\n",
-      " * processing `initial.phi_1.4` (Process-4)\n",
-      " * processing `initial.phi_1.6` (Process-1)\n",
-      " * processing `initial.phi_1.8` (Process-3)\n",
-      "CPU times: user 9.58 ms, sys: 20.6 ms, total: 30.2 ms\n",
-      "Wall time: 1.21 s\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "True"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%time\n",
     "sh.run_parallel(sim)"
@@ -222,56 +138,49 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = h5py.File(sh.output_name, 'r')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "dict_keys(['initial.phi_0.8', 'initial.phi_0.4', 'variation', 'initial.phi_1.6', 'initial.phi_1.4', 'initial.phi_1.8', 'initial.phi_1.2', 'initial.phi_0.6', 'defaults', 'initial.phi_1.0'])"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# load data from output file\n",
-    "data = cw.fileio.from_hdf(sh.output_name)\n",
     "data.keys()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data.attrs.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "var = json.loads(data.attrs['variation'])\n",
+    "var"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'entry': 'initial.phi',\n",
-       " 'tasks': ['initial.phi_0.4',\n",
-       "  'initial.phi_0.6',\n",
-       "  'initial.phi_0.8',\n",
-       "  'initial.phi_1.0',\n",
-       "  'initial.phi_1.2',\n",
-       "  'initial.phi_1.4',\n",
-       "  'initial.phi_1.6',\n",
-       "  'initial.phi_1.8'],\n",
-       " 'values': [0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8]}"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# eliminate entries containing documentation\n",
-    "config = data.pop('defaults')\n",
-    "variation = data.pop('variation')\n",
-    "variation"
+    "default = json.loads(data.attrs['defaults'])\n",
+    "default"
    ]
   },
   {
@@ -285,22 +194,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# create figure and adjust size\n",
     "fig, ax = plt.subplots(1) \n",
@@ -309,7 +205,7 @@
     "# plot results\n",
     "for f, key in enumerate(data):\n",
     "    df = data[key]\n",
-    "    ax.semilogx(1000*df['t (s)'],df['T (K)'],color=col[f],label=key) \n",
+    "    ax.semilogx(1000*df['t'][:],df['T'][:],color=col[f],label=key) \n",
     "\n",
     "# add title/axis labels\n",
     "ax.set_title(r'IdealGasConstPressure Reactor')\n",
@@ -349,7 +245,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.6"
+   "version": "3.7.8"
   }
  },
  "nbformat": 4,
diff --git a/examples/minimal_example.ipynb b/examples/minimal_example.ipynb
index 22e6863..7daae57 100644
--- a/examples/minimal_example.ipynb
+++ b/examples/minimal_example.ipynb
@@ -82,7 +82,7 @@
     {
      "data": {
       "text/plain": [
-       "<ctwrap.simulation.Minimal at 0x7f06f9113b00>"
+       "<ctwrap.simulation.Minimal at 0x228a26b55c8>"
       ]
      },
      "execution_count": 2,
@@ -105,8 +105,7 @@
      "output_type": "stream",
      "text": [
       "    - `minimal`: sleeping for 0.2 seconds ...\n",
-      "CPU times: user 4.08 ms, sys: 943 µs, total: 5.03 ms\n",
-      "Wall time: 205 ms\n"
+      "Wall time: 204 ms\n"
      ]
     }
    ],
@@ -139,7 +138,7 @@
     {
      "data": {
       "text/plain": [
-       "<ctwrap.simulation.SimulationHandler at 0x7f071d1cbe48>"
+       "<ctwrap.simulation.SimulationHandler at 0x228a2768c48>"
       ]
      },
      "execution_count": 4,
@@ -206,8 +205,7 @@
       "    - `minimal`: sleeping for 1.4 seconds ...\n",
       "    - `minimal`: sleeping for 1.6 seconds ...\n",
       "    - `minimal`: sleeping for 1.8 seconds ...\n",
-      "CPU times: user 28.4 ms, sys: 8.23 ms, total: 36.6 ms\n",
-      "Wall time: 8.83 s\n"
+      "Wall time: 8.82 s\n"
      ]
     },
     {
@@ -245,24 +243,7 @@
      "output_type": "stream",
      "text": [
       " * running simulation using 4 cores\n",
-      " * processing `sleep_0.4` (Process-1)\n",
-      "    - `minimal`: sleeping for 0.4 seconds ...\n",
-      " * processing `sleep_0.6` (Process-2)\n",
-      "    - `minimal`: sleeping for 0.6 seconds ...\n",
-      " * processing `sleep_0.8` (Process-3)\n",
-      "    - `minimal`: sleeping for 0.8 seconds ...\n",
-      " * processing `sleep_1.0` (Process-4)\n",
-      "    - `minimal`: sleeping for 1.0 seconds ...\n",
-      " * processing `sleep_1.2` (Process-1)\n",
-      "    - `minimal`: sleeping for 1.2 seconds ...\n",
-      " * processing `sleep_1.4` (Process-2)\n",
-      "    - `minimal`: sleeping for 1.4 seconds ...\n",
-      " * processing `sleep_1.6` (Process-3)\n",
-      "    - `minimal`: sleeping for 1.6 seconds ...\n",
-      " * processing `sleep_1.8` (Process-4)\n",
-      "    - `minimal`: sleeping for 1.8 seconds ...\n",
-      "CPU times: user 21.3 ms, sys: 27.8 ms, total: 49.2 ms\n",
-      "Wall time: 2.85 s\n"
+      "Wall time: 4.65 s\n"
      ]
     },
     {
@@ -305,7 +286,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.6"
+   "version": "3.7.8"
   }
  },
  "nbformat": 4,
diff --git a/examples/parser_example.ipynb b/examples/parser_example.ipynb
index 533d647..8a7560f 100644
--- a/examples/parser_example.ipynb
+++ b/examples/parser_example.ipynb
@@ -47,15 +47,15 @@
     {
      "data": {
       "text/plain": [
-       "{'chemistry': {'mechanism': 'h2o2.xml'},\n",
-       " 'initial': {'P': [1.0, 'atmosphere', 'pressure'],\n",
-       "  'T': [1000.0, 'kelvin', 'initial temperature'],\n",
+       "{'initial': {'T': [1000.0, 'kelvin', 'initial temperature'],\n",
+       "  'P': [1.0, 'atmosphere', 'pressure'],\n",
+       "  'phi': [1.0, 'dimensionless', 'equivalence ratio'],\n",
        "  'fuel': 'H2',\n",
-       "  'oxidizer': 'O2:1,AR:3.76',\n",
-       "  'phi': [1.0, 'dimensionless', 'equivalence ratio']},\n",
-       " 'simulation': {'atol': 1e-15,\n",
-       "  'delta_t': 1e-05,\n",
+       "  'oxidizer': 'O2:1,AR:3.76'},\n",
+       " 'chemistry': {'mechanism': 'h2o2.xml'},\n",
+       " 'simulation': {'delta_t': 1e-05,\n",
        "  'n_points': 500,\n",
+       "  'atol': 1e-15,\n",
        "  'rtol': 1e-09}}"
       ]
      },
@@ -84,7 +84,7 @@
     {
      "data": {
       "text/plain": [
-       "{'phi': [1.0, 'dimensionless', 'equivalence ratio'], 'oxidizer': 'O2:1,AR:3.76', 'fuel': 'H2', 'T': [1000.0, 'kelvin', 'initial temperature'], 'P': [1.0, 'atmosphere', 'pressure']}"
+       "{'T': [1000.0, 'kelvin', 'initial temperature'], 'P': [1.0, 'atmosphere', 'pressure'], 'phi': [1.0, 'dimensionless', 'equivalence ratio'], 'fuel': 'H2', 'oxidizer': 'O2:1,AR:3.76'}"
       ]
      },
      "execution_count": 4,
@@ -106,7 +106,7 @@
     {
      "data": {
       "text/plain": [
-       "dict_keys(['phi', 'oxidizer', 'fuel', 'T', 'P'])"
+       "dict_keys(['T', 'P', 'phi', 'fuel', 'oxidizer'])"
       ]
      },
      "execution_count": 5,
@@ -137,7 +137,7 @@
      "data": {
       "text/plain": [
        "(1000.0 <Unit('kelvin')>,\n",
-       " 1.0 <Unit('atmosphere')>,\n",
+       " 1.0 <Unit('standard_atmosphere')>,\n",
        " 1.0 <Unit('dimensionless')>)"
       ]
      },
@@ -160,7 +160,7 @@
      "data": {
       "text/plain": [
        "(1000.0 <Unit('kelvin')>,\n",
-       " 1.0 <Unit('atmosphere')>,\n",
+       " 1.0 <Unit('standard_atmosphere')>,\n",
        " 1.0 <Unit('dimensionless')>)"
       ]
      },
@@ -321,7 +321,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.6"
+   "version": "3.7.8"
   }
  },
  "nbformat": 4,
diff --git a/setup.py b/setup.py
index 80927ce..93ddb59 100644
--- a/setup.py
+++ b/setup.py
@@ -40,5 +40,6 @@ setup(
     include_package_data=True,
     install_requires=[
         'pandas>=0.24.0', 'numpy',
-        'ruamel.yaml', 'pint'],
+        'ruamel.yaml', 'pint',
+        'h5py', 'matplotlib',],
     zip_safe=False)


Test patch:
diff --git a/tests/test_ctwrap.py b/tests/test_ctwrap.py
index 73bf6cd..9231b23 100644
--- a/tests/test_ctwrap.py
+++ b/tests/test_ctwrap.py
@@ -20,7 +20,7 @@ class TestParser(unittest.TestCase):
 
     def test_parser(self):
 
-        defaults = cw.fileio.load_yaml(
+        defaults = cw.parser.load_yaml(
             'ignition.yaml', path=EXAMPLES, keys=['defaults'])
         p = cw.Parser(defaults[0]['initial'])
         self.assertIsInstance(p.T, pq.Quantity)
@@ -50,6 +50,7 @@ class TestWrap(unittest.TestCase):
         self.assertIsInstance(sh.tasks, dict)
         self.assertIn(self._task, sh.tasks)
 
+
     def test_serial(self):
         sim = cw.Simulation.from_module(self._module)
         sh = cw.SimulationHandler.from_yaml(self._yaml, path=EXAMPLES)