test for sim results serialization

Author: hmonroedd

src/sparging/model.py

@@ -22,6 +22,9 @@
 from sparging.inputs import SimulationInput
 import pint
 from collections.abc import Callable
+import logging
+
+logger = logging.getLogger(__name__)
 
 hours_to_seconds = 3600
 days_to_seconds = 24 * hours_to_seconds
@@ -103,25 +106,25 @@ def serialize_output(self):
             output["simulation parameters"][key] = str(value)
         output["results"] = self.__dict__.copy()
 
-        # remove c_T2_solutions and y_T2_solutions from results to avoid dumping large arrays in yaml, they can be saved separately if needed
+        # remove objects incompatible with serialization
         for key in self.keys_to_ignore_results:
             output["results"].pop(key, None)
 
         for key, value in output.items():
             if isinstance(value, np.ndarray):
                 # convert numpy arrays to lists for JSON serialization
                 output[key] = value.tolist()
-                print(
+                logger.verbose(
                     "found list in results, converting to list for JSON serialization"
                 )
             if isinstance(value, pint.Quantity):
                 # convert pint.Quantity to string for JSON serialization
                 output[key] = value.to_base_units().magnitude
-                print(
+                logger.verbose(
                     "found pint.Quantity in results, converting to magnitude for JSON serialization"
                 )
             else:
-                print(
+                logger.verbose(
                     f"{key} is of type {type(value)}, no conversion needed for JSON serialization"
                 )
 
@@ -131,7 +134,7 @@ def serialize_output(self):
                 output["results"][k] = {"value": v.magnitude, "units": units}
 
                 if isinstance(v.magnitude, np.ndarray):
-                    print(
+                    logger.verbose(
                         f"found pint.Quantity with numpy array magnitude in results[{k}], converting to list for JSON serialization"
                     )
                     output["results"][k]["value"] = v.magnitude.tolist()

test/test_simulation_results.py

@@ -0,0 +1,65 @@
+from sparging.model import Simulation, SimulationResults
+from sparging.inputs import (
+    LIBRA_PI_GEOM,
+    LIBRA_PI_MAT,
+    LIBRA_PI_OPERATING_PARAMS,
+    LIBRA_PI_SPARGING_PARAMS,
+    SimulationInput,
+    ureg,
+)
+import numpy as np
+from pathlib import Path
+
+
+def test_simulation_results_serialization(tmp_path):
+    # BUILD
+    my_input = SimulationInput.from_parameters(
+        LIBRA_PI_GEOM,
+        LIBRA_PI_MAT,
+        LIBRA_PI_OPERATING_PARAMS,
+        LIBRA_PI_SPARGING_PARAMS,
+    )
+
+    my_sim = Simulation(
+        my_input,
+        t_final=2 * ureg.hour,
+    )
+
+    res = my_sim.solve(fast_solve=True)
+
+    # RUN
+    # serialization
+    path_json = Path(tmp_path).joinpath("results.json")
+    path_pkl = Path(tmp_path).joinpath("results.pkl")
+    res.to_json(path_json)
+    res.to_pickle(path_pkl)
+
+    # deserialization
+    new_res_json = SimulationResults.from_json(path_json)
+    new_res_pickle = SimulationResults.from_pickle(path_pkl)
+
+    # TEST
+    assert len(res.times) == len(new_res_json.times), (
+        "JSON Times arrays have different lengths"
+    )
+    assert len(res.c_T2_solutions) == len(new_res_json.c_T2_solutions), (
+        "JSON c_T2_solutions arrays have different lengths"
+    )
+
+    assert np.allclose(res.times, new_res_json.times), "JSON Times arrays are not close"
+    assert np.allclose(res.c_T2_solutions, new_res_json.c_T2_solutions), (
+        "JSON c_T2_solutions arrays are not close"
+    )
+
+    assert len(res.times) == len(new_res_pickle.times), (
+        "Pickle Times arrays have different lengths"
+    )
+    assert len(res.c_T2_solutions) == len(new_res_pickle.c_T2_solutions), (
+        "Pickle c_T2_solutions arrays have different lengths"
+    )
+    assert np.allclose(res.times, new_res_pickle.times), (
+        "Pickle Times arrays are not close"
+    )
+    assert np.allclose(res.c_T2_solutions, new_res_pickle.c_T2_solutions), (
+        "Pickle c_T2_solutions arrays are not close"
+    )