Added focus_index to analysis.to_table

Author: peterhollender

notebooks/test_solution_analysis.py

@@ -16,6 +16,7 @@
 from openlifu.bf import Pulse, Sequence, apod_methods, focal_patterns
 from openlifu.geo import Point
 from openlifu.plan import Protocol
+from openlifu.plan.param_constraint import ParameterConstraint
 from openlifu.sim import SimSetup
 from openlifu.xdc import Transducer
 
@@ -38,22 +39,17 @@
 
 target = Point(position=(0,0,50), units="mm", radius=2)
 trans = Transducer.gen_matrix_array(nx=8, ny=8, pitch=4, kerf=0.5, id="m3", name="openlifu", impulse_response=1e6/10)
+# -
+
 solution, sim_res, scaled_analysis = protocol.calc_solution(
     target=target,
     transducer=trans,
     simulate=True,
     scale=True)
-# -
-
-solution.analyze(transducer=trans).to_dict()
-
-from openlifu.plan.param_constraint import ParameterConstraint
 
 pc = {"MI":ParameterConstraint('<', 1.8, 1.85), "TIC":ParameterConstraint('<', 2.0), 'global_isppa_Wcm2':ParameterConstraint('within', error_value=(49, 190))}
 scaled_analysis.to_table(constraints=pc).set_index('Param')[['Value', 'Units', 'Status']]
 
-solution
-
 protocol = Protocol.from_file('../tests/resources/example_db/protocols/example_protocol/example_protocol.json')
 solution, sim_res, analysis = protocol.calc_solution(
     target=target,

src/openlifu/plan/solution_analysis.py

@@ -55,7 +55,7 @@ class SolutionAnalysis(DictMixin):
     global_ispta_mWcm2: float | None = None
     param_constraints: Dict[str, ParameterConstraint] = field(default_factory=dict)
 
-    def to_table(self, constraints:Dict[str,ParameterConstraint]|None=None) -> pd.DataFrame:
+    def to_table(self, constraints:Dict[str,ParameterConstraint]|None=None, focus_index=None) -> pd.DataFrame:
         records = []
         if constraints is None:
             constraints = self.param_constraints
@@ -64,28 +64,38 @@ def to_table(self, constraints:Dict[str,ParameterConstraint]|None=None) -> pd.Da
                 raise ValueError(f"Unknown parameter constraint for '{p}'. Must be one of: {list(PARAM_FORMATS.keys())}")
         for param, fmt in PARAM_FORMATS.items():
             if fmt[0] is None:
-                pval = self.__dict__[param]
+                value_by_focus = None
+                agg_value = self.__dict__[param]
             elif fmt[0] == "max":
-                pval = max(self.__dict__[param])
+                value_by_focus = self.__dict__[param]
+                agg_value = max(value_by_focus)
             elif fmt[0] == "mean":
-                pval = np.mean(self.__dict__[param])
-            if pval is not None:
+                value_by_focus = self.__dict__[param]
+                agg_value = np.mean(value_by_focus)
+            if agg_value is not None:
                 record = {"id": param,
                           "Param": fmt[3],
                           "Value" : "",
                           "Units" : fmt[2],
                           "Status": "",
-                          "_value" : pval,
+                          "_value" : agg_value,
+                          "_value_by_focus": value_by_focus,
                           "_warning": False,
                           "_error": False}
-                if np.isnan(pval):
+                if np.isnan(agg_value):
                     record["Value"] = "NaN"
                 else:
-                    record["Value"] = f"{pval:{fmt[1]}}"
+                    if focus_index is None:
+                        record["Value"] = f"{agg_value:{fmt[1]}}"
+                    elif value_by_focus is None:
+                        record["Value"] = "N/A"
+                    else:
+                        value = value_by_focus[focus_index]
+                        record["Value"] = f"{value:{fmt[1]}}"
                     if param in constraints:
-                        record['_warning'] = constraints[param].is_warning(pval)
-                        record['_error'] = constraints[param].is_error(pval)
-                        record["Status"] = PARAM_STATUS_SYMBOLS[constraints[param].get_status(pval)]
+                        record['_warning'] = constraints[param].is_warning(agg_value)
+                        record['_error'] = constraints[param].is_error(agg_value)
+                        record["Status"] = PARAM_STATUS_SYMBOLS[constraints[param].get_status(agg_value)]
                 records.append(record)
         return pd.DataFrame.from_records(records)