(PR #36) Visualizer support

- Restructured Tomato parser to better handle available keys in the raw data - resolves missing current in OCV runs
- Implemented guard for fluctuating current (less than 10 positive/negative values in a row) - resolves incorrect cycle count
- Updated cycling analysis script to support collapsible raw-data dataframe views in visualizer panels
- Now pre-computing Q per t - used in V vs. C plot

aiida_aurora/parsers.py

@@ -120,30 +120,31 @@ def parse_tomato_results(data_dic, logger=None):
             The name of each array is:  `'step{step_number}_{raw_quantity_name}_{identifier}'`
 
         """
-        array_dic = {}
-        for imstep, mstep in enumerate(data_dic["steps"]):  # method step
-            raw_qty_names = list(mstep["data"][0]["raw"].keys())
-            if logger:
-                logger.debug(f"parse_tomato_results: step {imstep}: {list(raw_qty_names)}")
-            for raw_qty_name in raw_qty_names:
-                # substitute any special character with underscores
-                raw_qty_name_cleaned = re.sub("[^0-9a-zA-Z_]", "_", raw_qty_name)
-                if isinstance(mstep["data"][0]["raw"][raw_qty_name], dict):
-                    for identifier in mstep["data"][0]["raw"][raw_qty_name].keys():
-                        array_dic[f"step{imstep}_{raw_qty_name_cleaned}_{identifier}"] = np.array([
-                            step["raw"][raw_qty_name][identifier] for step in mstep["data"]
-                        ])
-                else:
-                    array_dic[f"step{imstep}_{raw_qty_name_cleaned}"] = np.array([
-                        step["raw"][raw_qty_name] for step in mstep["data"]
-                    ])
-            array_dic[f"step{imstep}_uts"] = np.array([step["uts"] for step in mstep["data"]])
+
+        parsed = {}
+
+        data = data_dic["steps"][0]["data"]
+
+        keys = ["Ewe", "I"]  # HACK hardcoded
+        fill = {"n": np.nan, "s": np.nan, "u": ""}
+
         if logger:
-            logger.debug(f"parse_tomato_results: arrays stored: {list(array_dic.keys())}")
+            logger.debug(f"parse_tomato_results: storing {keys}")
+
+        for key in keys:
+            clean_key = re.sub("[^0-9a-zA-Z_]", "_", key)  # TODO necessary?
+            for id in ("n", "s", "u"):
+                values = [step["raw"].get(key, fill)[id] for step in data]
+                parsed[f"step0_{clean_key}_{id}"] = np.array(values)
+
+        parsed["step0_uts"] = np.array([step["uts"] for step in data])
 
         node = ArrayData()
-        for key, value in array_dic.items():
+        for key, value in parsed.items():
             node.set_array(key, value)
             node.set_attribute_many(data_dic["metadata"])
 
+        if logger:
+            logger.debug(f"parse_tomato_results: {list(parsed.keys())} stored")
+
         return node

aiida_aurora/utils/__init__.py

@@ -1,6 +1,5 @@
-from . import cycling_analysis, plot
+from . import cycling_analysis
 
 __all__ = [
     'cycling_analysis',
-    'plot',
 ]

aiida_aurora/utils/analyzers.py

@@ -134,8 +134,7 @@ def _get_capacities(self, snapshot: dict):
         """
         try:
             data = get_data_from_raw(snapshot)
-            capacities = data['Qd'] if self.is_discharge else data['Qc']
-            return capacities / 3.6  # As -> mAh
+            return data['Qd'] if self.is_discharge else data['Qc']
         except KeyError as err:
             self.logger.error(f"missing '{str(err)}' in snapshot")
         return []

aiida_aurora/utils/cycling_analysis.py

@@ -1,13 +1,17 @@
+from __future__ import annotations
+
 import json
-from typing import Dict, Optional, Tuple
+
+from pandas import DataFrame
+from pandas.io.formats.style import Styler
 
 from aiida.orm import CalcJobNode, QueryBuilder, RemoteData, SinglefileData
 
 from aiida_aurora.data import BatterySampleData
 from aiida_aurora.utils.parsers import get_data_from_raw, get_data_from_results
 
 
-def cycling_analysis(node: CalcJobNode) -> Tuple[dict, str]:
+def cycling_analysis(node: CalcJobNode) -> tuple[dict, str, DataFrame]:
     """Perform post-processing of cycling experiments results.
 
     Used by the frontend Aurora app for plotting.
@@ -23,7 +27,7 @@ def cycling_analysis(node: CalcJobNode) -> Tuple[dict, str]:
 
     Returns
     -------
-    `Tuple[dict, str]`
+    `tuple[dict, str, DataFrame]`
         Post-processed data and an analysis report.
 
     Raises
@@ -35,28 +39,28 @@ def cycling_analysis(node: CalcJobNode) -> Tuple[dict, str]:
     if node.process_type != "aiida.calculations:aurora.cycler":
         raise TypeError("`node` is not a `BatteryCyclerExperiment`")
 
-    report = f"CalcJob:   <{node.pk}> '{node.label}'\n"
+    log = f"CalcJob:   <{node.pk}> '{node.label}'\n"
 
     sample: BatterySampleData = node.inputs.battery_sample
-    report += f"Sample:    {sample.label}\n"
+    log += f"Sample:    {sample.label}\n"
 
-    report += "Monitored: "
+    log += "Monitored: "
 
     if monitors := get_monitors(node):
-        report += "True\n"
-        report += add_monitor_details(monitors)
+        log += "True"
+        log += add_monitor_details(monitors)
     else:
-        report += "False\n"
+        log += "False"
 
     try:
-        data, analysis = process_data(node)
+        data, warning, raw = process_data(node)
     except Exception as err:
-        data, analysis = {}, f"*** ERROR ***\n\n{str(err)}"
+        data, warning, raw = {}, f"*** ERROR ***\n\n{str(err)}", None
 
-    return (data, f"{report}\n{analysis}")
+    return (data, f"{log}\n{warning}", raw)
 
 
-def get_monitors(node: CalcJobNode) -> Dict[str, dict]:
+def get_monitors(node: CalcJobNode) -> dict[str, dict]:
     """Fetch the monitor dictionary.
 
     The function is backwards compatible, capable of fetching the
@@ -72,7 +76,7 @@ def get_monitors(node: CalcJobNode) -> Dict[str, dict]:
 
     Returns
     -------
-    `Dict[str, dict]`
+    `dict[str, dict]`
         A dictionary of monitors.
     """
 
@@ -85,7 +89,7 @@ def get_monitors(node: CalcJobNode) -> Dict[str, dict]:
     return convert_to_new_monitor_format(monitor) if monitor else {}
 
 
-def get_node_monitor_calcjob(node: CalcJobNode) -> Optional[CalcJobNode]:
+def get_node_monitor_calcjob(node: CalcJobNode) -> CalcJobNode | None:
     """Fetch the monitor calcjob associated with the calculation
     `node`.
 
@@ -99,7 +103,7 @@ def get_node_monitor_calcjob(node: CalcJobNode) -> Optional[CalcJobNode]:
 
     Returns
     -------
-    `Optional[CalcJobNode]`
+    `CalcJobNode | None`
         The associated monitor calcjob node, `None` if not found.
     """
 
@@ -134,7 +138,7 @@ def get_node_monitor_calcjob(node: CalcJobNode) -> Optional[CalcJobNode]:
     return results[0] if results else None
 
 
-def convert_to_new_monitor_format(monitor: CalcJobNode) -> Dict[str, dict]:
+def convert_to_new_monitor_format(monitor: CalcJobNode) -> dict[str, dict]:
     """Convert monitor calcjob attributes to AiiDA 2.x format.
 
     For more details, see
@@ -148,7 +152,7 @@ def convert_to_new_monitor_format(monitor: CalcJobNode) -> Dict[str, dict]:
 
     Returns
     -------
-    `Dict[str, dict]`
+    `dict[str, dict]`
         The formatted monitor dictionary.
     """
 
@@ -182,7 +186,7 @@ def convert_to_new_monitor_format(monitor: CalcJobNode) -> Dict[str, dict]:
     }
 
 
-def add_monitor_details(monitors: Dict[str, dict]) -> str:
+def add_monitor_details(monitors: dict[str, dict]) -> str:
     """Return monitor details.
 
     Details include the following:
@@ -194,7 +198,7 @@ def add_monitor_details(monitors: Dict[str, dict]) -> str:
 
     Parameters
     ----------
-    `monitors` : `Dict[str, dict]`
+    `monitors` : `dict[str, dict]`
         A dictionary of monitors.
 
     Returns
@@ -207,9 +211,7 @@ def add_monitor_details(monitors: Dict[str, dict]) -> str:
 
     for label, params in monitors.items():
         details += f"\nMonitor:              {label}\n"
-        entry_point = params.get("entry_point", "aiida-calcmonitor plugin")
         refresh_rate = params.get("minimum_poll_interval", 600)
-        details += f"  Entry point:        {entry_point}\n"
         details += f"  Interval (s):       {refresh_rate}\n"
 
         if "kwargs" in params:
@@ -255,7 +257,7 @@ def add_monitor_settings(
     return _settings
 
 
-def process_data(node: CalcJobNode) -> Tuple[dict, str]:
+def process_data(node: CalcJobNode) -> tuple[dict, str, Styler | str]:
     """Analyze the results of the cycling experiment.
 
     The analysis is performed on the results `ArrayNode`, if one
@@ -272,20 +274,20 @@ def process_data(node: CalcJobNode) -> Tuple[dict, str]:
 
     Returns
     -------
-    `Tuple[dict, str]`
-        Post-processed data and an analysis report.
+    `tuple[dict, str, Styler | str]`
+        Post-processed data, warning, and analysis | error message.
     """
 
     if node.process_state and "finished" not in node.process_state.value:
-        return {}, f"Job terminated with message '{node.process_status}'"
+        return {}, f"Job terminated with message '{node.process_status}'", ""
 
-    report = ""
+    warning = ""
 
     if node.exit_status:
-        report += "WARNING: "
+        warning += "WARNING: "
         generic = "job killed by monitor"
-        report += f"{node.exit_message}" if node.exit_message else generic
-        report += "\n\n"
+        warning += f"{node.exit_message}" if node.exit_message else generic
+        warning += "\n\n"
 
     if "results" in node.outputs:
         data = get_data_from_results(node.outputs.results)
@@ -298,10 +300,7 @@ def process_data(node: CalcJobNode) -> Tuple[dict, str]:
     else:
         data = {}
 
-    # TODO extract data summary/statistics
-    report += add_analysis(data)
-
-    return data, report
+    return data, warning, add_analysis(data)
 
 
 def get_data_from_file(source: SinglefileData) -> dict:
@@ -347,7 +346,7 @@ def get_data_from_remote(source: RemoteData) -> dict:
         return {}
 
 
-def add_analysis(data: dict) -> str:
+def add_analysis(data: dict) -> Styler | str:
     """Return analysis details.
 
     Parameters
@@ -357,8 +356,29 @@ def add_analysis(data: dict) -> str:
 
     Returns
     -------
-    `str`
+    `Styler | str`
         The details of the analysis.
     """
-    # TODO replace str(data) with something insightful, and clean!
-    return str(data) if data else "ERROR! Failed to find or parse output"
+
+    if data:
+
+        COLUMNS = {
+            "time": "Time (s)",
+            "I": "I (A)",
+            "Ewe": "Ewe (V)",
+        }
+
+        selected_keys = {key: data[key] for key in COLUMNS}
+        df = DataFrame(selected_keys).rename(columns=COLUMNS)
+
+        return df.style.set_properties(width="100vw").set_table_styles([
+            dict(
+                selector="th, td",
+                props=[
+                    ("text-align", "center"),
+                ],
+            ),
+        ]).hide(axis="index")
+
+    else:
+        return "ERROR! Failed to find or parse output"

aiida_aurora/utils/parsers.py

@@ -1,12 +1,15 @@
 import numpy as np
+from scipy.integrate import cumtrapz
 
 from aiida.orm import ArrayData
 
 
-def get_data_from_raw(jsdata):
+def get_data_from_raw(jsdata) -> dict:
     "Extract raw data from json file."
+
     if not isinstance(jsdata, dict):
         raise TypeError('jsdata should be a dictionary')
+
     if len(jsdata["steps"]) > 1:
         raise NotImplementedError('Analysis of multiple steps is not implemented.')
 
@@ -17,32 +20,12 @@ def get_data_from_raw(jsdata):
     Ewe = np.array([ts["raw"]["Ewe"]["n"] for ts in raw_data])
     I = np.array([ts["raw"]["I"]["n"] for ts in raw_data])
 
-    # find indices of sign changes in I
-    idx = np.where(np.diff(np.sign(I)) != 0)[0]
+    return post_process_data(t, Ewe, I)
 
-    # integrate and store charge and discharge currents
-    Qc, Qd = [], []
-    for ii in range(len(idx) - 1):
-        i0, ie = idx[ii], idx[ii + 1]
-        q = np.trapz(I[i0:ie], t[i0:ie])
-        if q > 0:
-            Qc.append(q)
-        else:
-            Qd.append(abs(q))
 
-    return {
-        'time': t,
-        'Ewe': Ewe,
-        'I': I,
-        'cn': len(Qd),
-        'time-cycles': t[idx[2::2]],
-        'Qd': np.array(Qd),
-        'Qc': np.array(Qc),
-    }
-
-
-def get_data_from_results(array_node):
+def get_data_from_results(array_node) -> dict:
     "Extract data from parsed ArrayData node."
+
     if not isinstance(array_node, ArrayData):
         raise TypeError('array_node should be an ArrayData')
 
@@ -52,13 +35,24 @@ def get_data_from_results(array_node):
     Ewe = array_node.get_array('step0_Ewe_n')
     I = array_node.get_array('step0_I_n')
 
-    # find indices of sign changes in I
+    return post_process_data(t, Ewe, I)
+
+
+def post_process_data(t: np.ndarray, Ewe: np.ndarray, I: np.ndarray) -> dict:
+    """docstring"""
+
+    # find half-cycle markers
+    # add last point if not already a marker
     idx = np.where(np.diff(np.sign(I)) != 0)[0]
+    if (final := len(I) - 1) not in idx:
+        idx = np.append(idx, final)
 
     # integrate and store charge and discharge currents
     Qc, Qd = [], []
     for ii in range(len(idx) - 1):
         i0, ie = idx[ii], idx[ii + 1]
+        if ie - i0 < 10:
+            continue
         q = np.trapz(I[i0:ie], t[i0:ie])
         if q > 0:
             Qc.append(q)
@@ -71,6 +65,7 @@ def get_data_from_results(array_node):
         'I': I,
         'cn': len(Qd),
         'time-cycles': t[idx[2::2]],
-        'Qd': np.array(Qd),
-        'Qc': np.array(Qc),
+        'Q': cumtrapz(I, t, axis=0, initial=0) / 3.6,
+        'Qd': np.array(Qd) / 3.6,
+        'Qc': np.array(Qc) / 3.6,
     }