add dataref export

4 files changed, 75 insertions, 0 deletions

diff --git a/bin/analyze-archive.py b/bin/analyze-archive.py
index a9ee5cf..e7027ed 100755
--- a/bin/analyze-archive.py
+++ b/bin/analyze-archive.py
@@ -500,6 +500,12 @@ if __name__ == "__main__":
         "Creates a JSON file for each state and transition.",
     )
     parser.add_argument(
+        "--export-dref",
+        metavar="FILE",
+        type=str,
+        help="Export model and model quality to LaTeX dataref file",
+    )
+    parser.add_argument(
         "--filter-param",
         metavar="<parameter name>=<parameter value>[,<parameter name>=<parameter value>...]",
         type=str,
@@ -1078,6 +1084,19 @@ if __name__ == "__main__":
                 extra_function=function,
             )
 
+    if args.export_dref:
+        dref = raw_data.to_dref()
+        dref.update(model.to_dref(static_quality, lut_quality, analytic_quality))
+        with open(args.export_dref, "w") as f:
+            for k, v in dref.items():
+                if type(v) is not tuple:
+                    v = (v, None)
+                if v[1] is None:
+                    prefix = r"\drefset{"
+                else:
+                    prefix = r"\drefset" + f"[unit={v[1]}]" + "{"
+                print(f"{prefix}{k}" + "}{" + str(v[0]) + "}", file=f)
+
     if args.export_energymodel:
         if not pta:
             print(
diff --git a/lib/loader.py b/lib/loader.py
index c0aa105..f5c6306 100644
--- a/lib/loader.py
+++ b/lib/loader.py
@@ -372,6 +372,16 @@ class RawData:
             }
             json.dump(cache_data, f)
 
+    def to_dref(self) -> dict:
+        return {
+            "raw measurements/valid": self.preprocessing_stats["num_valid"],
+            "raw measurements/total": self.preprocessing_stats["num_runs"],
+            "static state duration/mean": (
+                np.mean(list(map(lambda x: x["state_duration"], self.setup_by_fileno))),
+                r"\milli\second",
+            ),
+        }
+
     def _state_is_too_short(self, online, offline, state_duration, next_transition):
         # We cannot control when an interrupt causes a state to be left
         if next_transition["plan"]["level"] == "epilogue":
diff --git a/lib/model.py b/lib/model.py
index 527a19e..85cda71 100644
--- a/lib/model.py
+++ b/lib/model.py
@@ -311,6 +311,48 @@ class AnalyticModel:
 
         return {"by_name": detailed_results}
 
+    def to_dref(self, static_quality, lut_quality, model_quality) -> dict:
+        ret = dict()
+        for name in self.names:
+            for attr_name, attr in self.attr_by_name[name].items():
+                e_static = static_quality["by_name"][name][attr_name]
+                e_lut = lut_quality["by_name"][name][attr_name]
+                e_model = model_quality["by_name"][name][attr_name]
+                unit = None
+                if "power" in attr.attr:
+                    unit = r"\micro\watt"
+                elif "energy" in attr.attr:
+                    unit = r"\pico\joule"
+                elif attr.attr == "duration":
+                    unit = r"\micro\second"
+                for k, v in attr.to_dref(unit).items():
+                    ret[f"data/{name}/{attr_name}/{k}"] = v
+                ret[f"error/static/{name}/{attr_name}/mae"] = (e_static["mae"], unit)
+                ret[f"error/lut/{name}/{attr_name}/mae"] = (e_lut["mae"], unit)
+                ret[f"error/model/{name}/{attr_name}/mae"] = (e_model["mae"], unit)
+                ret[f"error/static/{name}/{attr_name}/smape"] = (
+                    e_static["smape"],
+                    r"\percent",
+                )
+                ret[f"error/lut/{name}/{attr_name}/smape"] = (
+                    e_lut["smape"],
+                    r"\percent",
+                )
+                ret[f"error/model/{name}/{attr_name}/smape"] = (
+                    e_model["smape"],
+                    r"\percent",
+                )
+                ret[f"error/static/{name}/{attr_name}/mape"] = (
+                    e_static["mape"],
+                    r"\percent",
+                )
+                ret[f"error/lut/{name}/{attr_name}/mape"] = (e_lut["mape"], r"\percent")
+                ret[f"error/model/{name}/{attr_name}/mape"] = (
+                    e_model["mape"],
+                    r"\percent",
+                )
+        return ret
+
     def to_json(self) -> dict:
         """
         Return JSON encoding of this AnalyticModel.
diff --git a/lib/parameters.py b/lib/parameters.py
index 5fd44c3..ac67c2a 100644
--- a/lib/parameters.py
+++ b/lib/parameters.py
@@ -616,6 +616,10 @@ class ModelAttribute:
         }
         return ret
 
+    def to_dref(self, unit=None):
+        ret = {"mean": (self.mean, unit), "median": (self.median, unit)}
+        return ret
+
     @staticmethod
     def from_json(cls, name, attr, data):
         param_names = data["paramNames"]