properly handle static submodel attributes

TODO: fitting and submodel usage in parent

3 files changed, 75 insertions, 55 deletions

diff --git a/bin/analyze-archive.py b/bin/analyze-archive.py
index 193f151..1b37b89 100755
--- a/bin/analyze-archive.py
+++ b/bin/analyze-archive.py
@@ -339,6 +339,32 @@ def plot_traces(preprocessed_data, sot_name):
     )
 
 
+def print_static(model, static_model, name, attribute):
+    unit = "  "
+    if attribute == "power":
+        unit = "µW"
+    elif attribute == "duration":
+        unit = "µs"
+    elif attribute == "substate_count":
+        unit = "su"
+    print(
+        "{:10s}: {:.0f} {:s}  ({:.2f})".format(
+            name,
+            static_model(name, attribute),
+            unit,
+            model.attr_by_name[name][attribute].stats.generic_param_dependence_ratio(),
+        )
+    )
+    for param in model.parameters:
+        print(
+            "{:10s}  dependence on {:15s}: {:.2f}".format(
+                "",
+                param,
+                model.attr_by_name[name][attribute].stats.param_dependence_ratio(param),
+            )
+        )
+
+
 if __name__ == "__main__":
 
     ignored_trace_indexes = []
@@ -670,31 +696,14 @@ if __name__ == "__main__":
     if "static" in show_models or "all" in show_models:
         for state in model.states():
             for attribute in model.attributes(state):
-                unit = "  "
-                if attribute == "power":
-                    unit = "µW"
-                elif attribute == "substate_count":
-                    unit = "su"
-                print(
-                    "{:10s}: {:.0f} {:s}  ({:.2f})".format(
-                        state,
-                        static_model(state, attribute),
-                        unit,
-                        model.attr_by_name[state][
-                            attribute
-                        ].stats.generic_param_dependence_ratio(),
-                    )
-                )
-                for param in model.parameters:
-                    print(
-                        "{:10s}  dependence on {:15s}: {:.2f}".format(
-                            "",
-                            param,
-                            model.attr_by_name[state][
-                                attribute
-                            ].stats.param_dependence_ratio(param),
+                print_static(model, static_model, state, attribute)
+        if args.with_substates:
+            for submodel in model.submodel_by_nc.values():
+                for substate in submodel.states():
+                    for subattribute in submodel.attributes(substate):
+                        print_static(
+                            submodel, submodel.get_static(), substate, subattribute
                         )
-                    )
 
         for trans in model.transitions():
             if "energy" in model.attributes(trans):
diff --git a/lib/model.py b/lib/model.py
index c5908e3..9ac4560 100644
--- a/lib/model.py
+++ b/lib/model.py
@@ -353,6 +353,10 @@ class ModelAttribute:
         self.function_override = None
         self.param_model = None
 
+    def __repr__(self):
+        mean = np.mean(self.data)
+        return f"ModelAttribute<{self.name}, {self.attr}, mean={mean}>"
+
     def get_static(self, use_mean=False):
         if use_mean:
             return np.mean(self.data)
@@ -517,6 +521,10 @@ class AnalyticModel:
 
         self._compute_stats(by_name)
 
+    def __repr__(self):
+        names = ", ".join(self.by_name.keys())
+        return f"AnalyticModel<names=[{names}]>"
+
     def _compute_stats(self, by_name):
         paramstats = ParallelParamStats()
 
@@ -703,6 +711,12 @@ class AnalyticModel:
         # TODO
         pass
 
+    def predict(self, trace, with_fitted=True, wth_lut=False):
+        pass
+        # TODO trace= ( (name, duration), (name, duration), ...)
+        # -> Return predicted (duration, mean power, cumulative energy) for trace
+        # Achtung: Teilweise schon in der PTA-Klasse implementiert. Am besten diese mitbenutzen.
+
 
 class PTAModel(AnalyticModel):
     """
@@ -783,6 +797,7 @@ class PTAModel(AnalyticModel):
         self._use_corrcoef = use_corrcoef
         self.traces = traces
         self.function_override = function_override.copy()
+        self.submodel_by_nc = dict()
 
         self.fit_done = False
 
@@ -791,6 +806,7 @@ class PTAModel(AnalyticModel):
 
             self.pelt = PELT(**pelt)
             self.find_substates()
+            print(self.submodel_by_nc)
         else:
             self.pelt = None
 
@@ -802,6 +818,11 @@ class PTAModel(AnalyticModel):
         self.pta = pta
         self.ignore_trace_indexes = ignore_trace_indexes
 
+    def __repr__(self):
+        states = ", ".join(self.states())
+        transitions = ", ".join(self.transitions())
+        return f"PTAModel<states=[{states}], transitions=[{transitions}]>"
+
     def _aggregate_to_ndarray(self, aggregate):
         for elem in aggregate.values():
             for key in elem["attributes"]:
@@ -923,8 +944,6 @@ class PTAModel(AnalyticModel):
                 substate_counts_by_name[k[0]] = set()
             substate_counts_by_name[k[0]].add(num_substates)
 
-        print(substate_counts_by_name)
-
         for name in self.names:
             for substate_count in substate_counts_by_name[name]:
                 data = list()
@@ -961,40 +980,30 @@ class PTAModel(AnalyticModel):
     # ...
     def mk_submodel(self, name, substate_count, data):
         paramstats = ParallelParamStats()
+        by_name = dict()
         sub_states = list()
         for substate_index in range(substate_count):
-            sub_name = f"{name}.{substate_index}"
+            sub_name = f"{name}.{substate_index+1}({substate_count})"
             durations = list()
             powers = list()
             param_values = list()
             for param, run in data:
-                durations.extend(run[substate_index]["duration"])
-                powers.extend(run[substate_index]["power"])
+                # data units are s / W, models use µs / µW
+                durations.extend(np.array(run[substate_index]["duration"]) * 1e6)
+                powers.extend(np.array(run[substate_index]["power"]) * 1e6)
                 param_values.extend([param for i in run[substate_index]["duration"]])
-            power_attr = ModelAttribute(
-                sub_name, "power", powers, param_values, self.parameters, 0
-            )
-            duration_attr = ModelAttribute(
-                sub_name, "duration", durations, param_values, self.parameters, 0
-            )
-            sub_states.append((duration_attr, power_attr))
-            print(f"{sub_name} mean power: {power_attr.get_static()}")
-            print(f"{sub_name} mean duration: {duration_attr.get_static()}")
-            paramstats.enqueue((sub_name, "power"), power_attr)
-            paramstats.enqueue((sub_name, "duration"), duration_attr)
 
-        paramstats.compute()
+            by_name[sub_name] = {
+                "isa": "state",
+                "param": param_values,
+                "attributes": ["duration", "power"],
+                "duration": durations,
+                "power": powers,
+            }
 
-        for substate_index in range(substate_count):
-            sub_name = f"{name}.{substate_index}"
-            duration_attr, power_attr = sub_states[substate_index]
-            for param in self.parameters:
-                print(
-                    f"{sub_name:16s} duration dependence on {param:15s}: {duration_attr.stats.param_dependence_ratio(param):.2f}"
-                )
-                print(
-                    f"{sub_name:16s} power    dependence on {param:15s}: {power_attr.stats.param_dependence_ratio(param):.2f}"
-                )
+        self.submodel_by_nc[(name, substate_count)] = PTAModel(
+            by_name, self.parameters, dict()
+        )
 
     def get_substates(self):
         states = self.states()
diff --git a/lib/parameters.py b/lib/parameters.py
index e8347a3..078fa7a 100644
--- a/lib/parameters.py
+++ b/lib/parameters.py
@@ -81,7 +81,7 @@ def _reduce_param_matrix(matrix: np.ndarray, parameter_names: list) -> list:
 
 
 def _std_by_param(n_by_param, all_param_values, param_index):
-    u"""
+    """
     Calculate standard deviations for a static model where all parameters but `param_index` are constant.
 
     :param n_by_param: measurements of a specific model attribute partitioned by parameter values.
@@ -501,8 +501,8 @@ class ParamStats:
         if self.use_corrcoef:
             return 1 - np.abs(self.corr_by_param[param])
         if self.std_by_param[param] == 0:
-            if self.std_param_lut != 0:
-                raise RuntimeError("wat")
+            # if self.std_param_lut != 0:
+            #    raise RuntimeError(f"wat: std_by_param[{param}]==0, but std_param_lut=={self.std_param_lut} ≠ 0")
             # In general, std_param_lut < std_by_param. So, if std_by_param == 0, std_param_lut == 0 follows.
             # This means that the variation of param does not affect the model quality -> no influence, return 1
             return 1.0
@@ -526,7 +526,9 @@ class ParamStats:
             return 1 - np.abs(self.corr_by_arg[arg_index])
         if self.std_by_arg[arg_index] == 0:
             if self.std_param_lut != 0:
-                raise RuntimeError("wat")
+                raise RuntimeError(
+                    f"wat: std_by_arg[{arg_index}]==0, but std_param_lut=={self.std_param_lut} ≠ 0"
+                )
             # In general, std_param_lut < std_by_arg. So, if std_by_arg == 0, std_param_lut == 0 follows.
             # This means that the variation of arg does not affect the model quality -> no influence, return 1
             return 1