refactor model generation from Analytic/PTAModel into ModelAttribute class

Iteration over states/transitions and model attributes is no longer hardcoded
into most model generation code. This should make support for decision trees
and sub-states much easier.

3 files changed, 91 insertions, 48 deletions

diff --git a/test/test_parameters.py b/test/test_parameters.py
index e36b1a1..a40ebfe 100755
--- a/test/test_parameters.py
+++ b/test/test_parameters.py
@@ -20,7 +20,7 @@ class TestModels(unittest.TestCase):
             }
         }
         self.assertEqual(
-            parameters.distinct_param_values(by_name, "TX"),
+            parameters.distinct_param_values(by_name["TX"]["param"]),
             [list(range(5)), list(range(7))],
         )
 
@@ -44,16 +44,20 @@ class TestModels(unittest.TestCase):
                 "attributes": ["power"],
             }
         }
-        by_param = by_name_to_by_param(by_name)
-        stats = parameters.ParamStats(by_name, by_param, parameter_names, dict())
 
-        self.assertEqual(stats.depends_on_param("TX", "power", "p_mod5"), False)
-        self.assertEqual(stats.depends_on_param("TX", "power", "p_linear"), True)
+        stats = parameters.ParamStats(
+            parameters._compute_param_statistics(
+                by_name["TX"]["power"], parameter_names, by_name["TX"]["param"]
+            )
+        )
+
+        self.assertEqual(stats.depends_on_param("p_mod5"), False)
+        self.assertEqual(stats.depends_on_param("p_linear"), True)
 
         # Fit individual functions for each parameter (only "p_linear" in this case)
 
-        paramfit = ParallelParamFit(by_param)
-        paramfit.enqueue("TX", "power", 1, "p_linear")
+        paramfit = ParallelParamFit()
+        paramfit.enqueue(("TX", "power", "p_linear"), (stats.by_param, 1, False))
         paramfit.fit()
 
         fit_result = paramfit.get_result("TX", "power")
@@ -73,7 +77,7 @@ class TestModels(unittest.TestCase):
             "0 + reg_param[0] + reg_param[1] * model_param[1]",
         )
 
-        combined_fit.fit(by_param, "TX", "power")
+        combined_fit.fit(stats.by_param)
 
         self.assertEqual(combined_fit.fit_success, True)
 
@@ -123,22 +127,33 @@ class TestModels(unittest.TestCase):
             }
         }
         by_param = by_name_to_by_param(by_name)
-        stats = parameters.ParamStats(by_name, by_param, parameter_names, dict())
-
-        self.assertEqual(stats.depends_on_param("someKey", "lls", "lin_lin"), True)
-        self.assertEqual(stats.depends_on_param("someKey", "lls", "log_inv"), True)
-        self.assertEqual(stats.depends_on_param("someKey", "lls", "square_none"), True)
-
-        self.assertEqual(stats.depends_on_param("someKey", "ll", "lin_lin"), True)
-        self.assertEqual(stats.depends_on_param("someKey", "ll", "log_inv"), True)
-        self.assertEqual(stats.depends_on_param("someKey", "ll", "square_none"), False)
-
-        paramfit = ParallelParamFit(by_param)
-        paramfit.enqueue("someKey", "lls", 0, "lin_lin")
-        paramfit.enqueue("someKey", "lls", 1, "log_inv")
-        paramfit.enqueue("someKey", "lls", 2, "square_none")
-        paramfit.enqueue("someKey", "ll", 0, "lin_lin")
-        paramfit.enqueue("someKey", "ll", 1, "log_inv")
+        lls_stats = parameters.ParamStats(
+            parameters._compute_param_statistics(
+                by_name["someKey"]["lls"], parameter_names, by_name["someKey"]["param"]
+            )
+        )
+        ll_stats = parameters.ParamStats(
+            parameters._compute_param_statistics(
+                by_name["someKey"]["ll"], parameter_names, by_name["someKey"]["param"]
+            )
+        )
+
+        self.assertEqual(lls_stats.depends_on_param("lin_lin"), True)
+        self.assertEqual(lls_stats.depends_on_param("log_inv"), True)
+        self.assertEqual(lls_stats.depends_on_param("square_none"), True)
+
+        self.assertEqual(ll_stats.depends_on_param("lin_lin"), True)
+        self.assertEqual(ll_stats.depends_on_param("log_inv"), True)
+        self.assertEqual(ll_stats.depends_on_param("square_none"), False)
+
+        paramfit = ParallelParamFit()
+        paramfit.enqueue(("someKey", "lls", "lin_lin"), (lls_stats.by_param, 0, False))
+        paramfit.enqueue(("someKey", "lls", "log_inv"), (lls_stats.by_param, 1, False))
+        paramfit.enqueue(
+            ("someKey", "lls", "square_none"), (lls_stats.by_param, 2, False)
+        )
+        paramfit.enqueue(("someKey", "ll", "lin_lin"), (ll_stats.by_param, 0, False))
+        paramfit.enqueue(("someKey", "ll", "log_inv"), (ll_stats.by_param, 1, False))
         paramfit.fit()
 
         fit_lls = paramfit.get_result("someKey", "lls")
@@ -159,7 +174,7 @@ class TestModels(unittest.TestCase):
             " + regression_arg(7) * parameter(lin_lin) * np.log(parameter(log_inv)) * (parameter(square_none))**2",
         )
 
-        combined_fit_lls.fit(by_param, "someKey", "lls")
+        combined_fit_lls.fit(lls_stats.by_param)
 
         self.assertEqual(combined_fit_lls.fit_success, True)
 
@@ -200,7 +215,7 @@ class TestModels(unittest.TestCase):
             " + regression_arg(3) * parameter(lin_lin) * 1/(parameter(log_inv))",
         )
 
-        combined_fit_ll.fit(by_param, "someKey", "ll")
+        combined_fit_ll.fit(ll_stats.by_param)
 
         self.assertEqual(combined_fit_ll.fit_success, True)
 
diff --git a/test/test_ptamodel.py b/test/test_ptamodel.py
index fb4f7e9..bcbb19a 100755
--- a/test/test_ptamodel.py
+++ b/test/test_ptamodel.py
@@ -567,54 +567,76 @@ class TestFromFile(unittest.TestCase):
         self.assertAlmostEqual(static_model("write_nb", "duration"), 510, places=0)
 
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("POWERDOWN", "power", "datarate"),
+            model.attr_by_name["POWERDOWN"]["power"].stats.param_dependence_ratio(
+                "datarate"
+            ),
             0,
             places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("POWERDOWN", "power", "txbytes"),
+            model.attr_by_name["POWERDOWN"]["power"].stats.param_dependence_ratio(
+                "txbytes"
+            ),
             0,
             places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("POWERDOWN", "power", "txpower"),
+            model.attr_by_name["POWERDOWN"]["power"].stats.param_dependence_ratio(
+                "txpower"
+            ),
             0,
             places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("RX", "power", "datarate"),
+            model.attr_by_name["RX"]["power"].stats.param_dependence_ratio("datarate"),
             0.99,
             places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("RX", "power", "txbytes"), 0, places=2
+            model.attr_by_name["RX"]["power"].stats.param_dependence_ratio("txbytes"),
+            0,
+            places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("RX", "power", "txpower"), 0.01, places=2
+            model.attr_by_name["RX"]["power"].stats.param_dependence_ratio("txpower"),
+            0.01,
+            places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("STANDBY1", "power", "datarate"),
+            model.attr_by_name["STANDBY1"]["power"].stats.param_dependence_ratio(
+                "datarate"
+            ),
             0.04,
             places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("STANDBY1", "power", "txbytes"),
+            model.attr_by_name["STANDBY1"]["power"].stats.param_dependence_ratio(
+                "txbytes"
+            ),
             0.35,
             places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("STANDBY1", "power", "txpower"),
+            model.attr_by_name["STANDBY1"]["power"].stats.param_dependence_ratio(
+                "txpower"
+            ),
             0.32,
             places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("TX", "power", "datarate"), 1, places=2
+            model.attr_by_name["TX"]["power"].stats.param_dependence_ratio("datarate"),
+            1,
+            places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("TX", "power", "txbytes"), 0.09, places=2
+            model.attr_by_name["TX"]["power"].stats.param_dependence_ratio("txbytes"),
+            0.09,
+            places=2,
         )
         self.assertAlmostEqual(
-            model.stats.param_dependence_ratio("TX", "power", "txpower"), 1, places=2
+            model.attr_by_name["TX"]["power"].stats.param_dependence_ratio("txpower"),
+            1,
+            places=2,
         )
 
         param_model, param_info = model.get_fitted()
diff --git a/test/test_timingharness.py b/test/test_timingharness.py
index 917e4e2..3e7e5bd 100755
--- a/test/test_timingharness.py
+++ b/test/test_timingharness.py
@@ -21,7 +21,9 @@ class TestModels(unittest.TestCase):
 
         for transition in "setPALevel setRetries setup write".split(" "):
             self.assertAlmostEqual(
-                model.stats.param_dependence_ratio(transition, "duration", "channel"),
+                model.attr_by_name[transition]["duration"].stats.param_dependence_ratio(
+                    "channel"
+                ),
                 0,
                 places=2,
             )
@@ -36,10 +38,10 @@ class TestModels(unittest.TestCase):
         )
 
         self.assertAlmostEqual(
-            param_info("write", "duration")["function"].model_args[0], 1163, places=0,
+            param_info("write", "duration")["function"].model_args[0], 1163, places=0
         )
         self.assertAlmostEqual(
-            param_info("write", "duration")["function"].model_args[1], 464, places=0,
+            param_info("write", "duration")["function"].model_args[1], 464, places=0
         )
         self.assertAlmostEqual(
             param_info("write", "duration")["function"].model_args[2], 1, places=0
@@ -66,7 +68,9 @@ class TestModels(unittest.TestCase):
 
         for transition in "getObserveTx setPALevel setRetries setup write".split(" "):
             self.assertAlmostEqual(
-                model.stats.param_dependence_ratio(transition, "duration", "channel"),
+                model.attr_by_name[transition]["duration"].stats.param_dependence_ratio(
+                    "channel"
+                ),
                 0,
                 places=2,
             )
@@ -82,10 +86,10 @@ class TestModels(unittest.TestCase):
         )
 
         self.assertAlmostEqual(
-            param_info("write", "duration")["function"].model_args[0], 1163, places=0,
+            param_info("write", "duration")["function"].model_args[0], 1163, places=0
         )
         self.assertAlmostEqual(
-            param_info("write", "duration")["function"].model_args[1], 464, places=0,
+            param_info("write", "duration")["function"].model_args[1], 464, places=0
         )
         self.assertAlmostEqual(
             param_info("write", "duration")["function"].model_args[2], 1, places=0
@@ -121,7 +125,9 @@ class TestModels(unittest.TestCase):
 
         for transition in "setAutoAck setPALevel setRetries setup write".split(" "):
             self.assertAlmostEqual(
-                model.stats.param_dependence_ratio(transition, "duration", "channel"),
+                model.attr_by_name[transition]["duration"].stats.param_dependence_ratio(
+                    "channel"
+                ),
                 0,
                 places=2,
             )
@@ -137,10 +143,10 @@ class TestModels(unittest.TestCase):
         )
 
         self.assertAlmostEqual(
-            param_info("write", "duration")["function"].model_args[0], 1162, places=0,
+            param_info("write", "duration")["function"].model_args[0], 1162, places=0
         )
         self.assertAlmostEqual(
-            param_info("write", "duration")["function"].model_args[1], 464, places=0,
+            param_info("write", "duration")["function"].model_args[1], 464, places=0
         )
         self.assertAlmostEqual(
             param_info("write", "duration")["function"].model_args[2], 1, places=0
@@ -149,7 +155,7 @@ class TestModels(unittest.TestCase):
             param_info("write", "duration")["function"].model_args[3], 1, places=0
         )
         self.assertAlmostEqual(
-            param_info("write", "duration")["function"].model_args[4], 1086, places=0,
+            param_info("write", "duration")["function"].model_args[4], 1086, places=0
         )