PTAModel: Turn states, transitions, and states_and_transitions into attributes

6 files changed, 81 insertions, 91 deletions

diff --git a/bin/analyze-archive.py b/bin/analyze-archive.py
index c222a21..3344d8a 100755
--- a/bin/analyze-archive.py
+++ b/bin/analyze-archive.py
@@ -186,8 +186,8 @@ def print_text_model_data(model, pm, pq, lm, lq, am, ai, aq):
 
 
 def print_html_model_data(raw_data, model, pm, pq, lm, lq, am, ai, aq):
-    state_attributes = model.attributes(model.states()[0])
-    trans_attributes = model.attributes(model.transitions()[0])
+    state_attributes = model.attributes(model.states[0])
+    trans_attributes = model.attributes(model.transitions[0])
 
     print("# Setup")
     print("* Input files: `", " ".join(raw_data.filenames), "`")
@@ -198,7 +198,7 @@ def print_html_model_data(raw_data, model, pm, pq, lm, lq, am, ai, aq):
     print()
     print("# States")
 
-    for state in model.states():
+    for state in model.states:
         print()
         print(f"## {state}")
         print()
@@ -231,7 +231,7 @@ def print_html_model_data(raw_data, model, pm, pq, lm, lq, am, ai, aq):
     print()
     print("# Transitions")
 
-    for trans in model.transitions():
+    for trans in model.transitions:
         print()
         print(f"## {trans}")
         print()
@@ -268,7 +268,7 @@ def print_html_model_data(raw_data, model, pm, pq, lm, lq, am, ai, aq):
         + "</th><th>".join(state_attributes)
         + "</th></tr>"
     )
-    for state in model.states():
+    for state in model.states:
         print("<tr>", end="")
         print("<td>{}</td>".format(state), end="")
         for attribute in state_attributes:
@@ -284,7 +284,7 @@ def print_html_model_data(raw_data, model, pm, pq, lm, lq, am, ai, aq):
         print("</tr>")
     print("</table>")
 
-    trans_attributes = model.attributes(model.transitions()[0])
+    trans_attributes = model.attributes(model.transitions[0])
     if "rel_energy_prev" in trans_attributes:
         trans_attributes.remove("rel_energy_next")
 
@@ -293,7 +293,7 @@ def print_html_model_data(raw_data, model, pm, pq, lm, lq, am, ai, aq):
         + "</th><th>".join(trans_attributes)
         + "</th></tr>"
     )
-    for trans in model.transitions():
+    for trans in model.transitions:
         print("<tr>", end="")
         print("<td>{}</td>".format(trans), end="")
         for attribute in trans_attributes:
@@ -677,7 +677,7 @@ if __name__ == "__main__":
         xv = CrossValidator(PTAModel, by_name, parameters, arg_count)
 
     if args.info:
-        for state in model.states():
+        for state in model.states:
             print("{}:".format(state))
             print(f"""    Number of Measurements: {len(by_name[state]["power"])}""")
             for param in model.parameters:
@@ -689,7 +689,7 @@ if __name__ == "__main__":
                         ].stats.distinct_values_by_param_name[param],
                     )
                 )
-        for transition in model.transitions():
+        for transition in model.transitions:
             print("{}:".format(transition))
             print(
                 f"""    Number of Measurements: {len(by_name[transition]["duration"])}"""
@@ -730,18 +730,18 @@ if __name__ == "__main__":
         print("--- simple static model ---")
     static_model = model.get_static()
     if "static" in show_models or "all" in show_models:
-        for state in model.states():
+        for state in model.states:
             for attribute in model.attributes(state):
                 print_static(model, static_model, state, attribute)
         if args.with_substates:
             for submodel in model.submodel_by_name.values():
-                for substate in submodel.states():
+                for substate in submodel.states:
                     for subattribute in submodel.attributes(substate):
                         print_static(
                             submodel, submodel.get_static(), substate, subattribute
                         )
 
-        for trans in model.transitions():
+        for trans in model.transitions:
             if "energy" in model.attributes(trans):
                 try:
                     print(
@@ -866,7 +866,7 @@ if __name__ == "__main__":
     # print(model.assess(substate_model, ref=model.sc_by_name))
 
     if "paramdetection" in show_models or "all" in show_models:
-        for state in model.states_and_transitions():
+        for state in model.states_and_transitions:
             for attribute in model.attributes(state):
                 info = param_info(state, attribute)
                 print(
@@ -912,7 +912,7 @@ if __name__ == "__main__":
                             )
 
     if "param" in show_models or "all" in show_models:
-        for state in model.states():
+        for state in model.states:
             for attribute in model.attributes(state):
                 info = param_info(state, attribute)
                 if type(info) is AnalyticInfo:
@@ -921,7 +921,7 @@ if __name__ == "__main__":
                     print_splitinfo(
                         model.parameters, info, f"{state:10s} {attribute:15s}"
                     )
-        for trans in model.transitions():
+        for trans in model.transitions:
             for attribute in model.attributes(trans):
                 info = param_info(trans, attribute)
                 if type(info) is AnalyticInfo:
@@ -933,7 +933,7 @@ if __name__ == "__main__":
         if args.with_substates:
             for submodel in model.submodel_by_name.values():
                 sub_param_model, sub_param_info = submodel.get_fitted()
-                for substate in submodel.states():
+                for substate in submodel.states:
                     for subattribute in submodel.attributes(substate):
                         info = sub_param_info(substate, subattribute)
                         if type(info) is AnalyticInfo:
@@ -1020,14 +1020,14 @@ if __name__ == "__main__":
             )
         )
         distrib = dict()
-        num_states = len(model.states())
+        num_states = len(model.states)
         p95_state = None
-        for state in model.states():
+        for state in model.states:
             distrib[state] = 1.0 / num_states
 
-        if "STANDBY1" in model.states():
+        if "STANDBY1" in model.states:
             p95_state = "STANDBY1"
-        elif "SLEEP" in model.states():
+        elif "SLEEP" in model.states:
             p95_state = "SLEEP"
 
         if p95_state is not None:
diff --git a/bin/eval-outlier-removal.py b/bin/eval-outlier-removal.py
index c03266d..d6c905c 100755
--- a/bin/eval-outlier-removal.py
+++ b/bin/eval-outlier-removal.py
@@ -105,7 +105,7 @@ if __name__ == "__main__":
     print("--- simple static model ---")
     static_m1 = m1.get_static()
     static_m2 = m2.get_static()
-    # for state in model.states():
+    # for state in model.states:
     #    print('{:10s}: {:.0f} µW  ({:.2f})'.format(
     #        state,
     #        static_model(state, 'power'),
@@ -115,7 +115,7 @@ if __name__ == "__main__":
     #            '',
     #            param,
     #            model.param_dependence_ratio(state, 'power', param)))
-    # for trans in model.transitions():
+    # for trans in model.transitions:
     #    print('{:10s}: {:.0f} / {:.0f} / {:.0f} pJ  ({:.2f} / {:.2f} / {:.2f})'.format(
     #        trans, static_model(trans, 'energy'),
     #        static_model(trans, 'rel_energy_prev'),
@@ -137,7 +137,7 @@ if __name__ == "__main__":
 
     print("--- param model ---")
     param_m1, param_i1 = m1.get_fitted()
-    for state in m1.states():
+    for state in m1.states:
         for attribute in ["power"]:
             if param_i1(state, attribute):
                 print(
@@ -150,7 +150,7 @@ if __name__ == "__main__":
                         "", param_i1(state, attribute)["function"].model_args
                     )
                 )
-    for trans in m1.transitions():
+    for trans in m1.transitions:
         for attribute in [
             "energy",
             "rel_energy_prev",
@@ -172,7 +172,7 @@ if __name__ == "__main__":
                     )
                 )
     param_m2, param_i2 = m2.get_fitted()
-    for state in m2.states():
+    for state in m2.states:
         for attribute in ["power"]:
             if param_i2(state, attribute):
                 print(
@@ -185,7 +185,7 @@ if __name__ == "__main__":
                         "", param_i2(state, attribute)["function"].model_args
                     )
                 )
-    for trans in m2.transitions():
+    for trans in m2.transitions:
         for attribute in [
             "energy",
             "rel_energy_prev",
diff --git a/bin/eval-rel-energy.py b/bin/eval-rel-energy.py
index aeaf88c..cec1576 100755
--- a/bin/eval-rel-energy.py
+++ b/bin/eval-rel-energy.py
@@ -91,7 +91,7 @@ if __name__ == "__main__":
 
         lut_quality = model.assess(model.get_param_lut())
 
-        for trans in model.transitions():
+        for trans in model.transitions:
             absolute_quality = lut_quality["by_name"][trans]["energy"]
             relative_quality = lut_quality["by_name"][trans]["rel_energy_prev"]
             if absolute_quality["mae"] < relative_quality["mae"]:
diff --git a/bin/test_corrcoef.py b/bin/test_corrcoef.py
index 755c927..49944cd 100755
--- a/bin/test_corrcoef.py
+++ b/bin/test_corrcoef.py
@@ -189,7 +189,7 @@ if __name__ == "__main__":
     static_model = model.get_static()
     ref_static_model = ref_model.get_static()
     if "static" in show_models or "all" in show_models:
-        for state in model.states():
+        for state in model.states:
             print(
                 "{:10s}: {:.0f} µW  ({:.2f})".format(
                     state,
@@ -203,7 +203,7 @@ if __name__ == "__main__":
                         "", param, model.param_dependence_ratio(state, "power", param)
                     )
                 )
-        for trans in model.transitions():
+        for trans in model.transitions:
             print(
                 "{:10s}: {:.0f} / {:.0f} / {:.0f} pJ  ({:.2f} / {:.2f} / {:.2f})".format(
                     trans,
@@ -237,7 +237,7 @@ if __name__ == "__main__":
     print("")
     print("")
     print("state_or_trans attribute param stddev_ratio corrcoef")
-    for state in model.states():
+    for state in model.states:
         for attribute in model.attributes(state):
             for param in model.parameters:
                 print(
@@ -249,7 +249,7 @@ if __name__ == "__main__":
                         model.param_dependence_ratio(state, attribute, param),
                     )
                 )
-    for trans in model.transitions():
+    for trans in model.transitions:
         for attribute in model.attributes(trans):
             for param in model.parameters:
                 print(
diff --git a/lib/model.py b/lib/model.py
index 003ca16..5979c70 100644
--- a/lib/model.py
+++ b/lib/model.py
@@ -394,7 +394,23 @@ class PTAModel(AnalyticModel):
         self.by_name = by_name
         self.attr_by_name = dict()
         self.by_param = by_name_to_by_param(by_name)
+
         self.names = sorted(by_name.keys())
+        self.states = sorted(
+            list(
+                filter(lambda k: self.by_name[k]["isa"] == "state", self.by_name.keys())
+            )
+        )
+        self.transitions = sorted(
+            list(
+                filter(
+                    lambda k: self.by_name[k]["isa"] == "transition",
+                    self.by_name.keys(),
+                )
+            )
+        )
+        self.states_and_transitions = self.states + self.transitions
+
         self._parameter_names = sorted(parameters)
         self.parameters = sorted(parameters)
         self._num_args = arg_count
@@ -429,8 +445,8 @@ class PTAModel(AnalyticModel):
         np.seterr("raise")
 
     def __repr__(self):
-        states = ", ".join(self.states())
-        transitions = ", ".join(self.transitions())
+        states = ", ".join(self.states)
+        transitions = ", ".join(self.transitions)
         return f"PTAModel<states=[{states}], transitions=[{transitions}]>"
 
     def _aggregate_to_ndarray(self, aggregate):
@@ -468,7 +484,7 @@ class PTAModel(AnalyticModel):
                 if i == substate_count - 1:
                     if "duration" in kwargs:
                         sub_duration = kwargs["duration"] - total_duration
-                    elif name in self.states() and state_duration is not None:
+                    elif name in self.states and state_duration is not None:
                         sub_duration = state_duration - total_duration
 
                 cumulative_energy += sub_power * sub_duration
@@ -761,7 +777,7 @@ class PTAModel(AnalyticModel):
         analytic_quality = self.assess(param_model)
         pta = self.pta
         if pta is None:
-            pta = PTA(self.states(), parameters=self._parameter_names)
+            pta = PTA(self.states, parameters=self._parameter_names)
         pta.update(
             static_model,
             param_info,
@@ -770,31 +786,6 @@ class PTAModel(AnalyticModel):
         )
         return pta.to_json()
 
-    def states(self):
-        """Return sorted list of state names."""
-        return sorted(
-            list(
-                filter(lambda k: self.by_name[k]["isa"] == "state", self.by_name.keys())
-            )
-        )
-
-    def transitions(self):
-        """Return sorted list of transition names."""
-        return sorted(
-            list(
-                filter(
-                    lambda k: self.by_name[k]["isa"] == "transition",
-                    self.by_name.keys(),
-                )
-            )
-        )
-
-    def states_and_transitions(self):
-        """Return list of states and transition names."""
-        ret = self.states()
-        ret.extend(self.transitions())
-        return ret
-
     def assess(self, model_function, ref=None):
         """
         Calculate MAE, SMAPE, etc. of model_function for each by_name entry.
@@ -840,9 +831,9 @@ class PTAModel(AnalyticModel):
         # TODO calculate mean power draw for distribution and use it to
         # calculate relative error from MAE combination
         model_quality = self.assess(model_function)
-        num_states = len(self.states())
+        num_states = len(self.states)
         if distribution is None:
-            distribution = dict(map(lambda x: [x, 1 / num_states], self.states()))
+            distribution = dict(map(lambda x: [x, 1 / num_states], self.states))
 
         if not np.isclose(sum(distribution.values()), 1):
             raise ValueError(
@@ -851,7 +842,7 @@ class PTAModel(AnalyticModel):
 
         # total_value = None
         # try:
-        #     total_value = sum(map(lambda x: model_function(x, model_attribute) * distribution[x], self.states()))
+        #     total_value = sum(map(lambda x: model_function(x, model_attribute) * distribution[x], self.states))
         # except KeyError:
         #     pass
 
@@ -862,7 +853,7 @@ class PTAModel(AnalyticModel):
                         model_quality["by_name"][x][model_attribute]["mae"]
                         * distribution[x]
                     ),
-                    self.states(),
+                    self.states,
                 )
             )
         )
diff --git a/test/test_ptamodel.py b/test/test_ptamodel.py
index a8fc89f..e571dcc 100755
--- a/test/test_ptamodel.py
+++ b/test/test_ptamodel.py
@@ -463,9 +463,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "POWERDOWN RX STANDBY1 TX".split(" "))
+        self.assertEqual(model.states, "POWERDOWN RX STANDBY1 TX".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "begin epilogue powerDown powerUp setDataRate_num setPALevel_num startListening stopListening write_nb".split(
                 " "
             ),
@@ -673,9 +673,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "RX STANDBY1".split(" "))
+        self.assertEqual(model.states, "RX STANDBY1".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "setAutoAck setDataRate setPALevel setup startListening stopListening write".split(
                 " "
             ),
@@ -796,10 +796,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "STANDBY1".split(" "))
+        self.assertEqual(model.states, "STANDBY1".split(" "))
         self.assertEqual(
-            model.transitions(),
-            "setAutoAck setPALevel setRetries setup write".split(" "),
+            model.transitions, "setAutoAck setPALevel setRetries setup write".split(" ")
         )
         static_model = model.get_static()
         self.assertAlmostEqual(static_model("STANDBY1", "power"), 130, places=0)
@@ -1395,8 +1394,8 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "OFF ON".split(" "))
-        self.assertEqual(model.transitions(), "off setBrightness".split(" "))
+        self.assertEqual(model.states, "OFF ON".split(" "))
+        self.assertEqual(model.transitions, "off setBrightness".split(" "))
         static_model = model.get_static()
         self.assertAlmostEqual(static_model("OFF", "power"), 7124, places=0)
         self.assertAlmostEqual(static_model("ON", "power"), 17866, places=0)
@@ -1442,9 +1441,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "P14MW P235UW P3_4MW SLEEP".split(" "))
+        self.assertEqual(model.states, "P14MW P235UW P3_4MW SLEEP".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "nop10K nop1K0 nop3K3 setup switchTo3K3 switchTo47K switchTo750 switchToNone".split(
                 " "
             ),
@@ -1476,9 +1475,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "IDLE".split(" "))
+        self.assertEqual(model.states, "IDLE".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "setup trans100u trans10m trans1m trans2m trans5m".split(" "),
         )
         static_model = model.get_static()
@@ -1501,9 +1500,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "IDLE".split(" "))
+        self.assertEqual(model.states, "IDLE".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "setup trans100u trans10m trans1m trans2m trans5m".split(" "),
         )
         static_model = model.get_static()
@@ -1526,9 +1525,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "IDLE".split(" "))
+        self.assertEqual(model.states, "IDLE".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "setup trans100u trans10m trans1m trans2m trans5m".split(" "),
         )
         static_model = model.get_static()
@@ -1551,9 +1550,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "IDLE".split(" "))
+        self.assertEqual(model.states, "IDLE".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "setup trans100u trans10m trans1m trans2m trans5m".split(" "),
         )
         static_model = model.get_static()
@@ -1580,9 +1579,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "ACTIVE POWEROFF".split(" "))
+        self.assertEqual(model.states, "ACTIVE POWEROFF".split(" "))
         self.assertEqual(
-            model.transitions(), "getTemp setHyst setOS shutdown start".split(" ")
+            model.transitions, "getTemp setHyst setOS shutdown start".split(" ")
         )
         static_model = model.get_static()
         self.assertAlmostEqual(static_model("ACTIVE", "power"), 332, places=0)
@@ -1640,9 +1639,9 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "DISABLED ENABLED".split(" "))
+        self.assertEqual(model.states, "DISABLED ENABLED".split(" "))
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "clear disable enable ioInit sendLine toggleVCOM".split(" "),
         )
         static_model = model.get_static()
@@ -1702,8 +1701,8 @@ class TestFromFile(unittest.TestCase):
         preprocessed_data = raw_data.get_preprocessed_data()
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
-        self.assertEqual(model.states(), "B G OFF R".split(" "))
-        self.assertEqual(model.transitions(), "blue green off red".split(" "))
+        self.assertEqual(model.states, "B G OFF R".split(" "))
+        self.assertEqual(model.transitions, "blue green off red".split(" "))
         static_model = model.get_static()
         self.assertAlmostEqual(static_model("B", "power"), 29443, places=0)
         self.assertAlmostEqual(static_model("G", "power"), 29432, places=0)
@@ -1757,10 +1756,10 @@ class TestFromFile(unittest.TestCase):
         by_name, parameters, arg_count = pta_trace_to_aggregate(preprocessed_data)
         model = PTAModel(by_name, parameters, arg_count)
         self.assertEqual(
-            model.states(), "IDLE RX SLEEP SLEEP_EWOR SYNTH_ON TX XOFF".split(" ")
+            model.states, "IDLE RX SLEEP SLEEP_EWOR SYNTH_ON TX XOFF".split(" ")
         )
         self.assertEqual(
-            model.transitions(),
+            model.transitions,
             "crystal_off eWOR idle init prepare_xmit receive send setSymbolRate setTxPower sleep txDone".split(
                 " "
             ),