Notebook results

Author: matasovt

current_setpoints/data/machines.py

@@ -153,10 +153,6 @@ def __init__(
 
         self.machine_name = machine_name
         self.flux_values = flux_values
-        # TODO: zeptat se Lukase (podle jeho kodu)
-        # self.mat_A = (self.n_phases * self.n_ppairs / 4) * (
-        #    self.mat_crossc @ self.L_stat + self.L_stat @ self.mat_crossc.T
-        # )
 
         dim = self.n_phases - 1
         dummy_vec_curr_dq = np.zeros(dim)

current_setpoints/optimization/grid.py

@@ -227,6 +227,7 @@ def get_correction_grid(
     neural_model: torch.nn.Module,
     scaler: Any,
     device: torch.device,
+    machine: BaseMachine,
 ) -> Dict[str, Any]:
     """
     Computes the correction grid by predicting torque using the neural model
@@ -237,9 +238,7 @@ def get_correction_grid(
         neural_model: Trained PyTorch neural network for torque prediction.
         scaler: The scaler used to normalize inputs for the neural model.
         device: CPU or CUDA device.
-
-    Returns:
-        Dict: A copy of the baseline grid, appended with the 'grid_torq_neural' matrix.
+        machine: The machine instance to fetch dynamic B_tensors.
     """
     print("Computing Phase-Agnostic ML Correction Grid...")
 
@@ -248,7 +247,6 @@ def get_correction_grid(
     }
 
     dim, n_torq, n_omega = dict_grid_corr["curr_dq_grid"].shape
-
     grid_torq_neural = np.full((n_torq, n_omega), np.nan)
 
     omega_2d = np.tile(dict_grid_corr["vec_omega"], (n_torq, 1))
@@ -263,12 +261,18 @@ def get_correction_grid(
         curr_valid = curr_flat[:, valid_mask]
 
         X_in = np.vstack([omega_valid, curr_valid]).T
-
         X_scaled = scaler.transform(X_in)
         X_tensor = torch.from_numpy(X_scaled).float().to(device)
 
+        b_vecs = []
+        for i in range(len(omega_valid)):
+            machine.update_state(omega=omega_valid[i], vec_curr_dq=curr_valid[:, i])
+            b_vecs.append(machine.vec_b)
+
+        B_tensor = torch.from_numpy(np.array(b_vecs)).float().to(device).unsqueeze(-1)
+
         with torch.no_grad():
-            preds = neural_model(X_tensor).cpu().numpy().flatten()
+            preds = neural_model(X_tensor, B_tensor).cpu().numpy().flatten()
 
         torq_neural_flat = np.full(n_torq * n_omega, np.nan)
         torq_neural_flat[valid_mask] = preds

current_setpoints/optimization/optimizer.py

@@ -37,16 +37,23 @@ def _get_base_constraints(self, transform: Any) -> List[Dict[str, Any]]:
         Returns:
             List[Dict]: Scipy-compatible constraint definitions.
         """
+
+        def safe_current_constraint(vec_curr_dq):
+            self.model.machine.update_state(transform.omega, vec_curr_dq)
+            return current_constraint(vec_curr_dq, self.model.machine, transform)
+
+        def safe_voltage_constraint(vec_curr_dq):
+            self.model.machine.update_state(transform.omega, vec_curr_dq)
+            return voltage_constraint(vec_curr_dq, self.model.machine, transform)
+
         return [
             {
                 "type": "ineq",
-                "fun": current_constraint,
-                "args": (self.model.machine, transform),
+                "fun": safe_current_constraint,
             },
             {
                 "type": "ineq",
-                "fun": voltage_constraint,
-                "args": (self.model.machine, transform),
+                "fun": safe_voltage_constraint,
             },
         ]
 

current_setpoints/utils/plotting.py

@@ -8,7 +8,12 @@
 from .plot_config import PlotConfig
 
 
-def plot_grid_segments(data_obj: Any, machine: Optional[BaseMachine] = None) -> None:
+def plot_grid_segments(
+    data_obj: Any,
+    title: str = "Segments Overview",
+    machine: Optional[BaseMachine] = None,
+    override_torq_2d: Optional[np.ndarray] = None,
+) -> None:
     """
     Plots the motor operating regions.
     Expects data_obj to be the MachineData instance generated by grid_to_data.
@@ -18,15 +23,19 @@ def plot_grid_segments(data_obj: Any, machine: Optional[BaseMachine] = None) ->
 
     with plt.rc_context(PlotConfig.get_rc_params()):
         fig, ax = plt.subplots(figsize=(8, 6))
-        ax.set_title("Segments Overview")
+        ax.set_title(title)
 
         omega_rpm = data_obj.omega
         vec_torq = data_obj.torq
 
         ax.set_xlabel("Speed [r/min]")
         ax.set_ylabel("Torque [Nm]")
 
-        omega_2d, torq_2d = np.meshgrid(omega_rpm, vec_torq)
+        omega_2d, default_torq_2d = np.meshgrid(omega_rpm, vec_torq)
+
+        # Use the override array if provided, otherwise default to commanded torque
+        torq_2d = override_torq_2d if override_torq_2d is not None else default_torq_2d
+
         modes_valid = data_obj.segments
 
         valid_mask = ~np.isnan(modes_valid)
@@ -188,7 +197,9 @@ def plot_residual_torque_error(dict_grid: Dict[str, Any], machine: BaseMachine)
 
 
 def plot_current_trajectories_split(
-    dict_grid_base: Dict[str, Any], dict_grid_recalc: Dict[str, Any], machine: BaseMachine
+    dict_grid_base: Dict[str, Any],
+    dict_grid_recalc: Dict[str, Any],
+    machine: BaseMachine,
 ) -> None:
     colors_map = PlotConfig.get_colors()
     labels_map = PlotConfig.get_labels()
@@ -253,7 +264,9 @@ def plot_grid_onto_ax(ax, dict_grid, d_idx, q_idx):
 
 
 def plot_joule_losses_reduction(
-    dict_grid_base: Dict[str, Any], dict_grid_recalc: Dict[str, Any], machine: BaseMachine
+    dict_grid_base: Dict[str, Any],
+    dict_grid_recalc: Dict[str, Any],
+    machine: BaseMachine,
 ) -> None:
     omega_rpm = dict_grid_recalc["vec_omega"] * dict_grid_recalc.get(
         "const_mech_speed", 30 / (np.pi * machine.n_ppairs)