fixed unit tests for required dims

Author: peterhollender

notebooks/test_solution_analysis.py

@@ -22,8 +22,9 @@
 # +
 f0 = 400e3
 pulse = Pulse(frequency=f0, duration=10/f0, amplitude=1)
-sequence = Sequence(pulse_interval=0.1, pulse_count=10, pulse_train_interval=0, pulse_train_count=1)
+sequence = Sequence(pulse_interval=0.1, pulse_count=9, pulse_train_interval=0, pulse_train_count=1)
 focal_pattern = focal_patterns.SinglePoint(target_pressure=1.2e6)
+focal_pattern = focal_patterns.Wheel(center=False, spoke_radius=5, num_spokes=3, target_pressure=1.2e6)
 apod_method = apod_methods.MaxAngle(30)
 sim_setup = SimSetup(x_extent=[-30,30], y_extent=[-30,30], z_extent=[-4,70])
 protocol = Protocol(
@@ -44,11 +45,15 @@
     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/bf/focal_patterns/wheel.py

@@ -17,12 +17,12 @@ class Wheel(FocalPattern):
     :ivar center: Whether to include the center point of the wheel pattern
     :ivar num_spokes: Number of spokes in the wheel pattern
     :ivar spoke_radius: Radius of the spokes in the wheel pattern
-    :ivar units: Units of the wheel pattern parameters
+    :ivar spoke_units: Units of the wheel pattern parameters
     """
     center: bool = True
     num_spokes: int = 4
     spoke_radius: float = 1.0 # mm
-    units: str = "mm"
+    spoke_units: str = "mm"
 
     def get_targets(self, target: Point):
         """
@@ -45,7 +45,7 @@ def get_targets(self, target: Point):
             spoke = Point(id=f"{target.id}_{np.rad2deg(theta):.0f}deg",
                               name=f"{target.name} ({np.rad2deg(theta):.0f}°)",
                               position=position,
-                              units=self.units,
+                              units=self.spoke_units,
                               radius=target.radius)
             targets.append(spoke)
         return targets

src/openlifu/plan/protocol.py

@@ -110,7 +110,7 @@ def to_dict(self):
             "delay_method": self.delay_method.to_dict(),
             "apod_method": self.apod_method.to_dict(),
             "seg_method": self.seg_method.to_dict(),
-            "param_constraints": self.param_constraints,
+            "param_constraints": {id: pc.to_dict() for id, pc in self.param_constraints.items()},
             "target_constraints": self.target_constraints,
             "virtual_fit_options": self.virtual_fit_options.to_dict(),
             "analysis_options": self.analysis_options,

src/openlifu/plan/solution.py

@@ -216,7 +216,7 @@ def analyze(self,
             solution_analysis.p0_MPa += [1e-6*np.max(p0_Pa)]
         solution_analysis.TIC = np.mean(TIC)
         solution_analysis.power_W = np.mean(power_W)
-        solution_analysis.MI = (solution_analysis.mainlobe_pnp_MPa/np.sqrt(self.pulse.frequency*1e-6)).item()
+        solution_analysis.MI = (np.max(solution_analysis.mainlobe_pnp_MPa)/np.sqrt(self.pulse.frequency*1e-6))
         solution_analysis.global_ispta_mWcm2 = float((ita_mWcm2*z_mask).max())
         solution_analysis.param_constraints = param_constraints
         return solution_analysis

src/openlifu/plan/solution_analysis.py

@@ -31,7 +31,7 @@
     "p0_MPa": ["max", "0.3f", "MPa", "Emitted Pressure"],
     "power_W": [None, "0.3f", "W", "Emitted Power"],
     "TIC": [None, "0.3f", "", "TIC"],
-    "MI": ["max", "0.3f", "", "MI"]}
+    "MI": [None, "0.3f", "", "MI"]}
 
 @dataclass
 class SolutionAnalysis(DictMixin):

tests/test_protocol.py

@@ -104,14 +104,14 @@ def test_calc_solution_use_gpu(
     """Test that the correct value of use_gpu is passed to the simulation runner"""
     example_simulation_output = xa.Dataset(
         {
-            'p_min': xa.DataArray(data=np.empty((3, 2, 3)), dims=["x", "y", "z"], attrs={'units': "Pa"}),
-            'p_max': xa.DataArray(data=np.empty((3, 2, 3)),dims=["x", "y", "z"],attrs={'units': "Pa"}),
-            'intensity': xa.DataArray(data=np.empty((3, 2, 3)),dims=["x", "y", "z"],attrs={'units': "W/cm^2"}),
+            'p_min': xa.DataArray(data=np.empty((3, 2, 3)), dims=["lat", "ele", "ax"], attrs={'units': "Pa"}),
+            'p_max': xa.DataArray(data=np.empty((3, 2, 3)),dims=["lat", "ele", "ax"],attrs={'units': "Pa"}),
+            'intensity': xa.DataArray(data=np.empty((3, 2, 3)),dims=["lat", "ele", "ax"],attrs={'units': "W/cm^2"}),
         },
         coords={
-            'x': xa.DataArray(dims=["x"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
-            'y': xa.DataArray(dims=["y"], data=np.linspace(0, 1, 2), attrs={'units': "m"}),
-            'z': xa.DataArray(dims=["z"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
+            'lat': xa.DataArray(dims=["lat"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
+            'ele': xa.DataArray(dims=["ele"], data=np.linspace(0, 1, 2), attrs={'units': "m"}),
+            'ax': xa.DataArray(dims=["ax"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
         },
     )
     mocker.patch(

tests/test_solution.py

@@ -71,9 +71,9 @@ def example_solution() -> Solution:
                 )
             },
             coords={
-                'x': xa.DataArray(dims=["x"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
-                'y': xa.DataArray(dims=["y"], data=np.linspace(0, 1, 2), attrs={'units': "m"}),
-                'z': xa.DataArray(dims=["z"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
+                'lat': xa.DataArray(dims=["lat"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
+                'ele': xa.DataArray(dims=["ele"], data=np.linspace(0, 1, 2), attrs={'units': "m"}),
+                'ax': xa.DataArray(dims=["ax"], data=np.linspace(0, 1, 3), attrs={'units': "m"}),
                 'focal_point_index': [0]
             }
         )