turbo-design 1.3.9__tar.gz → 1.3.10__tar.gz

{turbo_design-1.3.9 → turbo_design-1.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turbo-design
-Version: 1.3.9
+Version: 1.3.10
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov

{turbo_design-1.3.9 → turbo_design-1.3.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "turbo-design"
-version = "1.3.9"
+version = "1.3.10"
 description = "TurboDesign is a library used to design turbines and compressors using radial equilibrium."
 authors = ["Paht Juangphanich <paht.juangphanich@nasa.gov>"]
 packages = [

{turbo_design-1.3.9 → turbo_design-1.3.10}/turbodesign/bladerow.py

@@ -38,6 +38,7 @@ class BladeRow:
     total_massflow: float = 0    # Massflow spool + all upstream cooling flow [kg/s]
     massflow: npt.NDArray = field(default_factory=lambda: np.array([0]))  # Massflow per radii
     total_massflow_no_coolant: float = 0     # Inlet massflow
+    massflow_target: Optional[npt.NDArray] = None  # Custom massflow distribution for angle matching [kg/s]
     # ----------------------------------
 
     # Streamline Properties 

{turbo_design-1.3.9 → turbo_design-1.3.10}/turbodesign/compressor_math.py

@@ -244,11 +244,12 @@ def rotor_calc(
         deviation_rad = np.radians(deviation_val)
 
         P0R_local = upstream.P0R - row.Yp * (upstream.P0R - upstream.P)
-        T0R_local = upstream.T0R
-        
-        P_local = P0R_local / IsenP(M_rel, row.gamma)
+        # Use rothalpy conservation: I = Cp*T0R - U^2/2 = const across rotor
         U_local = row.omega * row.r
-        
+        T0R_local = (upstream_rothalpy + 0.5 * U_local ** 2) / row.Cp
+
+        P_local = P0R_local / IsenP(M_rel, row.gamma)
+
         P0R_P = P0R_local / P_local
         T0R_T = P0R_P ** ((row.gamma - 1) / row.gamma)
         T_local = T0R_local / T0R_T
@@ -351,24 +352,35 @@ def rotor_calc(
             solve_massflow_for_current_loss()
         else:
             solve_massflow_for_current_loss()
-    else: # We know Vm, P0, T0
+    else: # We know Vm from radeq, beta2 from blade angle, T0R from rothalpy
         deviation_func = getattr(row, "deviation_function", None)
         deviation_val = deviation_func(row, upstream) if callable(deviation_func) else 0.0
         deviation_rad = np.radians(deviation_val)
         beta2_eff = row.beta2 + deviation_rad
-        row.Vr = row.Vm*np.sin(row.phi)
-        row.Vx = row.Vm*np.cos(row.phi)
-        row.W = np.sqrt(2*row.Cp*(row.T0R-row.T))
-        row.Wt = row.W*np.sin(beta2_eff)
-        row.Vt = row.Wt+row.U
-        
-        row.alpha2 = np.arctan2(row.Vt,row.Vm)
-        row.V = np.sqrt(row.Vm**2*(1+np.tan(row.alpha2)**2))
-        
-        row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
-        T0_T = (1+(row.gamma-1)/2 * row.M**2)
-        row.P0 = row.P * T0_T**(row.gamma/(row.gamma-1))
-    
-    row.M_rel = row.W/np.sqrt(row.gamma*row.R*row.T)
-    row.T0 = row.T+row.V**2/(2*row.Cp)
+
+        row.U = row.omega * row.r
+        row.T0R = (upstream_rothalpy + 0.5 * row.U ** 2) / row.Cp
+        row.P0R = upstream.P0R - row.Yp * (upstream.P0R - upstream.P)
+
+        row.Vr = row.Vm * np.sin(row.phi)
+        row.Vx = row.Vm * np.cos(row.phi)
+
+        # Compute W from velocity triangle (geometric closure)
+        row.W = row.Vm / np.cos(beta2_eff)
+        row.Wt = row.W * np.sin(beta2_eff)
+        row.Vt = row.Wt + row.U
+
+        row.alpha2 = np.arctan2(row.Vt, row.Vm)
+        row.V = np.sqrt(row.Vm ** 2 * (1 + np.tan(row.alpha2) ** 2))
+
+        # Update T from energy conservation in rotating frame
+        row.T = row.T0R - row.W ** 2 / (2 * row.Cp)
+
+        row.M = row.V / np.sqrt(row.gamma * row.R * row.T)
+
+    # Compute T0 first, then derive P0 from P0R to keep the velocity triangle consistent.
+    # P0/P0R = (T0/T0R)^(gamma/(gamma-1)) always holds since both reference the same static state.
+    row.M_rel = row.W / np.sqrt(row.gamma * row.R * row.T)
+    row.T0 = row.T + row.V ** 2 / (2 * row.Cp)
+    row.P0 = row.P0R * (row.T0 / row.T0R) ** (row.gamma / (row.gamma - 1))
     compute_gas_constants(row)

{turbo_design-1.3.9 → turbo_design-1.3.10}/turbodesign/compressor_spool.py

@@ -99,6 +99,7 @@ class CompressorSpool:
         # Previously this used dataclasses.field on a non-dataclass; do it explicitly
         self.t_streamline = np.zeros((10,), dtype=float)
         self._adjust_streamlines = True
+        self.convergence_history: List[Dict] = []
 
         # Assign IDs, RPMs, and axial chords where appropriate
         for i, br in enumerate(self._all_rows()):
@@ -437,6 +438,7 @@ class CompressorSpool:
         loop_iter = 0
         max_iter = 10
         prev_err = 1e9
+        self.convergence_history = []  # Reset convergence history
         while loop_iter < max_iter:
             for i in range(1, len(rows) - 1):
                 row = rows[i]
@@ -482,6 +484,15 @@ class CompressorSpool:
             loop_iter += 1
             print(f"Loop {loop_iter} massflow convergence error:{err}")
 
+            # Store convergence history
+            self.convergence_history.append({
+                'iteration': loop_iter,
+                'massflow_std': float(err),
+                'massflow_change': float(abs(err - prev_err)),
+                'relative_change': float(abs((err - prev_err) / max(err, 1e-6))),
+                'massflow': float(rows[1].total_massflow_no_coolant)
+            })
+
             denom = max(err, 1e-6)
             if abs((err - prev_err) / denom) <= 0.05:
                 break
@@ -505,7 +516,10 @@ class CompressorSpool:
     def _angle_match(self) -> None:
         """Match massflow between streamtubes by tweaking exit angles."""
         blade_rows = self._all_rows()
-        for _ in range(3):
+        self.convergence_history = []  # Reset convergence history
+        prev_err = 1e9
+
+        for iter_num in range(3):
             for i, row in enumerate(blade_rows):
                 # Only adjust blade rows; skip inlet/outlet and other utility rows
                 if row.row_type not in (RowType.Rotor, RowType.Stator):
@@ -526,7 +540,7 @@ class CompressorSpool:
                         match_massflow_objective,
                         bounds=bounds,
                         args=(j, row, upstream, downstream, self.fluid),
-                        tol=1e-3,
+                        options={'xatol': 1e-3},
                         method="bounded",
                     )
                     if row.row_type == RowType.Rotor:
@@ -540,8 +554,19 @@ class CompressorSpool:
                 compute_massflow(row)
                 compute_power(row, upstream, is_compressor=True)
 
+            # Track convergence history
+            err = self._massflow_std(blade_rows[1:-1])
+            self.convergence_history.append({
+                'iteration': iter_num + 1,
+                'massflow_std': float(err),
+                'massflow_change': float(abs(err - prev_err)),
+                'relative_change': float(abs((err - prev_err) / max(err, 1e-6))),
+                'massflow': float(blade_rows[1].total_massflow_no_coolant)
+            })
+            prev_err = err
+            print(f"Angle match iteration {iter_num + 1}, massflow std: {err:.6f}")
+
 
-        
     # ------------------------------
     # Export / Plotting
     # ------------------------------
@@ -791,6 +816,85 @@ class CompressorSpool:
             plt.title(f"Velocity Triangles for Streamline {j}")
             plt.savefig(f"streamline_{j:04d}.png", transparent=False, dpi=150)
 
+    def save_convergence_history(self, filename: str = "convergence_history.jsonl") -> None:
+        """Save convergence history to JSONL file.
+
+        Writes the convergence history collected during solve() to a JSON Lines file,
+        where each line is a JSON object representing one iteration.
+
+        Args:
+            filename: Output JSONL file path (default: "convergence_history.jsonl")
+
+        Returns:
+            None. Writes JSONL file to specified path.
+
+        Example:
+            >>> spool.solve()
+            >>> spool.save_convergence_history("compressor_convergence.jsonl")
+        """
+        import json
+        from pathlib import Path
+
+        output_path = Path(filename)
+        with open(output_path, 'w') as f:
+            for entry in self.convergence_history:
+                f.write(json.dumps(entry) + '\n')
+        print(f"Convergence history saved to {output_path}")
+
+    def plot_convergence(self, save_to_file: Optional[Union[bool, str]] = None) -> None:
+        """Plot convergence history showing massflow error vs iteration.
+
+        Displays a semi-log plot of the massflow standard deviation error across
+        iterations. If convergence history is empty, warns user.
+
+        Args:
+            save_to_file: If True, saves to "convergence.png". If string, saves to that filename.
+                         If None/False, displays plot without saving.
+
+        Returns:
+            None. Either displays plot or saves to file.
+
+        Example:
+            >>> spool.solve()
+            >>> spool.plot_convergence()  # Display plot
+            >>> spool.plot_convergence(save_to_file=True)  # Save to convergence.png
+            >>> spool.plot_convergence(save_to_file="my_convergence.png")  # Save to custom file
+        """
+        if not self.convergence_history:
+            print("Warning: No convergence history available. Run solve() first.")
+            return
+
+        iterations = [entry['iteration'] for entry in self.convergence_history]
+        massflow_std = [entry['massflow_std'] for entry in self.convergence_history]
+        relative_change = [entry['relative_change'] for entry in self.convergence_history]
+
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
+
+        # Plot massflow std deviation
+        ax1.semilogy(iterations, massflow_std, 'o-', linewidth=2, markersize=8)
+        ax1.set_xlabel('Iteration', fontsize=12)
+        ax1.set_ylabel('Massflow Std Dev [kg/s]', fontsize=12)
+        ax1.set_title('Convergence History: Massflow Standard Deviation', fontsize=14, fontweight='bold')
+        ax1.grid(True, alpha=0.3)
+
+        # Plot relative change
+        ax2.semilogy(iterations, relative_change, 's-', color='orange', linewidth=2, markersize=8)
+        ax2.set_xlabel('Iteration', fontsize=12)
+        ax2.set_ylabel('Relative Change', fontsize=12)
+        ax2.set_title('Convergence History: Relative Change', fontsize=14, fontweight='bold')
+        ax2.axhline(y=0.05, color='r', linestyle='--', label='Convergence Threshold (0.05)')
+        ax2.legend()
+        ax2.grid(True, alpha=0.3)
+
+        plt.tight_layout()
+
+        if save_to_file:
+            filename = "convergence.png" if save_to_file is True else str(save_to_file)
+            plt.savefig(filename, dpi=150, bbox_inches='tight')
+            print(f"Convergence plot saved to {filename}")
+        else:
+            plt.show()
+
 
 def outlet_pressure(percents: List[float], inletP0: float, outletP: float) -> npt.NDArray:
     """Linearly interpolate total pressure values along the spool."""

{turbo_design-1.3.9 → turbo_design-1.3.10}/turbodesign/flow_math.py

@@ -132,8 +132,7 @@ def compute_power(row: BladeRow, upstream: BladeRow | None = None, downstream: B
         row.P0_ratio = P0_ratio_actual
         setattr(row, "P0_ratio_actual", float(P0_ratio_actual))
         row.T_is = ref.T0 * (1 / P0_P) ** ((row.gamma - 1) / row.gamma)
-        a = np.sqrt(row.gamma * row.R * row.T_is)
-        row.T0_is = row.T_is * (1 + (row.gamma - 1) / 2 * (row.V / a) ** 2)
+        row.T0_is = ref.T0 * (row.P0 / ref.P0) ** ((row.gamma - 1) / row.gamma)
 
         comp_mode = is_compressor
         if comp_mode is None:
@@ -156,4 +155,4 @@ def compute_power(row: BladeRow, upstream: BladeRow | None = None, downstream: B
         if is_compressor:
             row.stage_loading *= -1 # Stage_loading will be negative 
         row.euler_power = mdot * (ref.U * ref.Vt - row.U * row.Vt).mean()
-        row.flow_coefficient = float(np.mean(row.Vm) / max(row.U.mean(), 1e-9))
+        row.flow_coefficient = abs(float(np.mean(row.Vm / row.U)))

{turbo_design-1.3.9 → turbo_design-1.3.10}/turbodesign/turbine_math.py

@@ -21,7 +21,7 @@ def compute_reynolds(rows:List[BladeRow],passage:Passage):
         passage (Passage): Passage 
     """
     
-    for i in range(1,len(rows)):
+    for i in range(1,len(rows)-1):
         row = rows[i]
         xr = passage.get_xr_slice(0.5,(rows[i-1].location,row.percent_hub))
         dx = np.diff(xr[:,0])
@@ -36,7 +36,7 @@ def compute_reynolds(rows:List[BladeRow],passage:Passage):
             V = row.V.mean()
         rho = row.rho.mean()
         mu = row.mu
-        row.Reynolds = c*V*rho/mu
+        row.Reynolds = row.axial_chord*V*rho/mu
         row.mprime = mp
         row.axial_chord = max(c,1E-12) # Axial chord
         # row.num_blades = int(2*np.pi*row.r.mean() / row.pitch_to_chord * row.axial_chord)
@@ -236,7 +236,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True,outlet_type
     T0_coolant = 0 
     if row.coolant is not None:
         T0_coolant = T0_coolant_weighted_average(row)
-    row.T0R = upstream.T0R - T0_coolant # (upstream_rothalpy + 0.5*row.U**2)/row.Cp # - T0_coolant_weighted_average(row) 
+    row.T0R = (upstream_rothalpy + 0.5*row.U**2)/row.Cp - T0_coolant
     P0R_P = row.P0R / row.P
     T0R_T = P0R_P**((row.gamma-1)/row.gamma)
     row.T = (row.T0R/T0R_T)     # Exit static temperature
@@ -254,8 +254,8 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True,outlet_type
                 reason += "; Yp > 0.3 This could be a problem with the loss model;"
             _log_rotor_failure(reason)
             raise ValueError(f'nan detected')
-        row.Vr = row.W*np.sin(row.phi)
         row.Vm = row.W*np.cos(row.beta2)
+        row.Vr = row.Vm*np.sin(row.phi)
         row.Wt = row.W*np.sin(row.beta2)
         row.Vx = row.Vm*np.cos(row.phi)
         row.Vt = row.Wt + row.U 
@@ -264,25 +264,33 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True,outlet_type
         row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
         row.T0 = row.T + row.V**2/(2*row.Cp)
         row.alpha2 = np.arctan2(row.Vt,row.Vm)
-    else: # We know Vm, P0, T0
+    else: # We know Vm from radeq, beta2 from blade angle, T0R from rothalpy
         row.Vr = row.Vm*np.sin(row.phi)
         row.Vx = row.Vm*np.cos(row.phi)
-        
-        row.W = np.sqrt(2*row.Cp*(row.T0R-row.T))
+
+        # Compute W from velocity triangle (not thermodynamics) to close the triangle
+        row.W = row.Vm / np.cos(row.beta2)
         row.Wt = row.W*np.sin(row.beta2)
-        row.U = row.omega * row.r 
+        row.U = row.omega * row.r
         row.Vt = row.Wt + row.U
-        
+
         row.alpha2 = np.arctan2(row.Vt,row.Vm)
         row.V = np.sqrt(row.Vm**2*(1+np.tan(row.alpha2)**2))
-        
+
+        # Update T from energy conservation in rotating frame
+        row.T = row.T0R - row.W**2 / (2*row.Cp)
+
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
-    T0_T = (1+(row.gamma-1)/2 * row.M**2)
-    row.P0 = row.P * T0_T**(row.gamma/(row.gamma-1))
+
+    # Compute T0 first, then derive P0 from P0R to keep the velocity triangle consistent.
+    # P0/P0R = (T0/T0R)^(gamma/(gamma-1)) always holds since both reference the same static state.
+    # Using P0R (from the loss model) avoids dependence on the boundary-condition P, which may
+    # not be consistent with T after radeq adjusts Vm.
+    row.T0 = row.T + row.V**2/(2*row.Cp)
+    row.P0 = row.P0R * (row.T0 / row.T0R) ** (row.gamma / (row.gamma - 1))
     row.P0_P = (row.P0_stator_inlet/row.P).mean()
 
     row.M_rel = row.W/np.sqrt(row.gamma*row.R*row.T)
-    row.T0 = row.T+row.V**2/(2*row.Cp)
 
 def inlet_calc(row:BladeRow):
     """Calculates the conditions for the Inlet 

{turbo_design-1.3.9 → turbo_design-1.3.10}/turbodesign/turbine_spool.py

@@ -91,7 +91,7 @@ class TurbineSpool:
         self.passage = passage
         self.massflow = massflow
         self.num_streamlines = num_streamlines
-        self._fluid = fluid if fluid is not None else Solution("air.yaml")
+        self._fluid = fluid
         self.rpm = rpm
 
         self.inlet = inlet
@@ -101,6 +101,7 @@ class TurbineSpool:
         self.rows = rows
         self.t_streamline = np.zeros((10,), dtype=float)
         self._adjust_streamlines = True
+        self.convergence_history: List[Dict] = []
 
         # Assign IDs, RPMs, and axial chords where appropriate
         for i, br in enumerate(self._all_rows()):
@@ -110,8 +111,9 @@ class TurbineSpool:
                 br.axial_chord = br.hub_location * self.passage.hub_length
 
         # Propagate initial fluid to rows
-        for br in self._all_rows():
-            br.fluid = self._fluid
+        if self._fluid is not None:
+            for br in self._all_rows():
+                br.fluid = self._fluid
 
     def _all_rows(self) -> List[BladeRow]:
         """Convenience to iterate inlet + interior rows + outlet."""
@@ -272,7 +274,9 @@ class TurbineSpool:
         inlet = self.inlet
         if self.fluid:
             inlet.__initialize_fluid__(self.fluid)  # type: ignore[arg-type]
-        else:
+        elif inlet.gamma is not None:
+            inlet.__initialize_fluid__(R=inlet.R, gamma=inlet.gamma, Cp=inlet.Cp)  # type: ignore[call-arg]
+        elif blade_rows[1].gamma is not None:
             inlet.__initialize_fluid__(  # type: ignore[call-arg]
                 R=blade_rows[1].R,
                 gamma=blade_rows[1].gamma,
@@ -453,11 +457,24 @@ class TurbineSpool:
         """Match massflow between streamtubes by tweaking exit angles."""
         rows = self._all_rows()
         massflow_target = np.linspace(0,rows[-1].total_massflow,self.num_streamlines)
-        for _ in range(3):
+
+        self.convergence_history = []  # Reset convergence history
+        past_err = -100.0
+        loop_iter = 0
+        err = 1e-3
+
+        print("Looping to converge massflow (angle matching)")
+        while (np.abs((err - past_err) / err) > 0.05) and (loop_iter < 10):
             for i in range(1,len(rows)-1):
                 upstream = rows[i - 1] if i > 0 else rows[i]
                 downstream = rows[i + 1] if i < len(rows) - 1 else None
 
+                # Use custom massflow target if defined, otherwise use default
+                if rows[i].massflow_target is not None:
+                    current_massflow_target = rows[i].massflow_target
+                else:
+                    current_massflow_target = massflow_target
+
                 if rows[i].row_type == RowType.Stator:
                     bounds = [0, 80]
                 elif rows[i].row_type == RowType.Rotor:
@@ -469,8 +486,8 @@ class TurbineSpool:
                     res = minimize_scalar(
                         massflow_loss_function,
                         bounds=bounds,
-                        args=(j, rows[i], upstream, massflow_target[j], downstream),
-                        tol=1e-4,
+                        args=(j, rows[i], upstream, current_massflow_target[j], downstream),
+                        options={'xatol': 1e-4},
                         method="bounded",
                     )
                     if rows[i].row_type == RowType.Rotor:
@@ -481,9 +498,32 @@ class TurbineSpool:
                         rows[i].alpha2[0] = 1 / (len(rows[i].alpha2) - 1) * rows[i].alpha2[1:].sum()
                 compute_gas_constants(upstream, self.fluid)
                 compute_gas_constants(rows[i], self.fluid)
-            
+
+            # Adjust inlet to match massflow found at first blade row
+            target = rows[1].total_massflow_no_coolant
+            self.inlet.massflow = np.array([target]) if self.num_streamlines == 1 else (np.linspace(0, 1, self.num_streamlines) * target)
+            self.inlet.total_massflow_no_coolant = rows[1].total_massflow_no_coolant
+            self.inlet.total_massflow = rows[1].total_massflow_no_coolant
+            self.inlet.calculated_massflow = self.inlet.total_massflow_no_coolant
+            inlet_calc(self.inlet)
+
             if self.adjust_streamlines:
                 adjust_streamlines(rows, self.passage)
+
+            # Track convergence history
+            past_err = err
+            err = self.__massflow_std__(rows[1:-1])
+            loop_iter += 1
+
+            self.convergence_history.append({
+                'iteration': loop_iter,
+                'massflow_std': float(err),
+                'massflow_change': float(abs(err - past_err)),
+                'relative_change': float(abs((err - past_err) / max(err, 1e-6))),
+                'massflow': float(rows[1].total_massflow_no_coolant)
+            })
+            print(f"Angle match iteration {loop_iter}, massflow std: {err:.6f}")
+
         compute_reynolds(rows, self.passage)
 
     @staticmethod
@@ -522,14 +562,18 @@ class TurbineSpool:
     def _balance_pressure(self) -> None:
         """Balance massflow between rows using radial equilibrium."""
         rows = self._all_rows()
-
+        past_err = -100.0
+        loop_iter = 0
+        err = 1e-3
+        self.convergence_history = []  # Reset convergence history
+        
         def balance_loop(
             x0: List[float],
             rows: List[BladeRow],
             P0: List[float],
             P_or_P0: List[float],
         ) -> float:
-            """Runs through the calclulation and outputs the standard deviation of massflow 
+            """Runs through the calclulation and outputs the standard deviation of massflow
 
             Args:
                 x0 (List[float]): Array of percent breakdown (P0 to P) or (P0 to P0_exit)
@@ -540,6 +584,7 @@ class TurbineSpool:
             Returns:
                 float: _description_
             """
+            nonlocal err, past_err, loop_iter
             static_defined = (self.outlet.outlet_type == OutletType.static_pressure)
             P_exit = P_or_P0
             for j in range(self.num_streamlines):
@@ -607,6 +652,20 @@ class TurbineSpool:
                         compute_massflow(row)
                         compute_power(row,upstream)
             print(x0)
+            
+            past_err = err
+            err = self.__massflow_std__(rows[1:-1])
+            loop_iter += 1
+            
+            # Store convergence history
+            self.convergence_history.append({
+                'iteration': loop_iter,
+                'massflow_std': float(err),
+                'massflow_change': float(abs(err - past_err)),
+                'relative_change': float(abs((err - past_err) / max(err, 1e-6))),
+                'massflow': float(rows[1].total_massflow_no_coolant)
+            })
+            
             return self.__massflow_std__(rows[1:-1])
 
         pressure_ratio_ranges: List[tuple] = []
@@ -620,9 +679,6 @@ class TurbineSpool:
             raise ValueError("For turbine calculations, please define outlet using init_static")
         
         print("Looping to converge massflow")
-        past_err = -100.0
-        loop_iter = 0
-        err = 1e-3
         while (np.abs((err - past_err) / err) > 0.05) and (loop_iter < 10):
             if len(pressure_ratio_ranges) == 1: # Single stage, use minimize scalar 
                 x = minimize_scalar(
@@ -656,10 +712,6 @@ class TurbineSpool:
             self.outlet.transfer_quantities(rows[-2])  # outlet
             self.outlet.P = self.outlet.get_static_pressure(self.outlet.percent_hub_shroud)
 
-            past_err = err
-            err = self.__massflow_std__(rows)
-            loop_iter += 1
-            print(f"Loop {loop_iter} massflow convergenced error:{err}")
 
         compute_reynolds(rows, self.passage)
 
@@ -744,10 +796,6 @@ class TurbineSpool:
             "rpm": self.rpm,
             "r_streamline": r_streamline.tolist(),
             "x_streamline": x_streamline.tolist(),
-            "rhub": self.passage.rhub_pts.tolist(),
-            "rshroud": self.passage.rshroud_pts.tolist(),
-            "xhub": self.passage.xhub_pts.tolist(),
-            "xshroud": self.passage.xshroud_pts.tolist(),
             "num_streamlines": self.num_streamlines,
             "euler_power": euler_power,
             "euler_power_hp": euler_power_hp,
@@ -781,136 +829,325 @@ class TurbineSpool:
                     return obj.tolist()
                 return super().default(obj)
 
-        with open(filename, "w") as f:
-            json.dump(data, f, indent=4, cls=NumpyEncoder)
+        with open(filename, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=4, cls=NumpyEncoder, ensure_ascii=False)
 
     def plot(self) -> None:
-        """Plot hub/shroud and streamlines."""
+        """Plot hub/shroud and streamlines with improved labels and formatting."""
         blade_rows = self._all_rows()
-        plt.figure(num=1, clear=True, dpi=150, figsize=(15, 10))
-        plt.plot(
+        fig, ax = plt.subplots(1, 1, figsize=(16, 8), dpi=150)
+
+        # Plot hub and shroud with thicker lines
+        ax.plot(
             self.passage.xhub_pts,
             self.passage.rhub_pts,
-            label="hub",
+            label="Hub",
             linestyle="solid",
-            linewidth=2,
+            linewidth=3,
             color="black",
+            zorder=10
         )
-        plt.plot(
+        ax.plot(
             self.passage.xshroud_pts,
             self.passage.rshroud_pts,
-            label="shroud",
+            label="Shroud",
             linestyle="solid",
-            linewidth=2,
+            linewidth=3,
             color="black",
+            zorder=10
         )
 
         hub_length = np.sum(
             np.sqrt(np.diff(self.passage.xhub_pts) ** 2 + np.diff(self.passage.rhub_pts) ** 2)
         )
+
+        # Prepare streamline data
         x_streamline = np.zeros((self.num_streamlines, len(blade_rows)))
         r_streamline = np.zeros((self.num_streamlines, len(blade_rows)))
         for i in range(len(blade_rows)):
             x_streamline[:, i] = blade_rows[i].x
             r_streamline[:, i] = blade_rows[i].r
 
+        # Plot streamlines connecting blade rows
         for i in range(1, len(blade_rows) - 1):
-            plt.plot(x_streamline[:, i], r_streamline[:, i], "--b", linewidth=1.5)
+            ax.plot(x_streamline[:, i], r_streamline[:, i],
+                   linestyle="--", linewidth=1.2, color="gray", alpha=0.6, zorder=1)
 
-        for i, row in enumerate(blade_rows):
-            plt.plot(row.x, row.r, linestyle="dashed", linewidth=1.5, color="blue", alpha=0.4)
-            plt.plot(x_streamline[:, i], r_streamline[:, i], "or")
+        # Track label positions to avoid overlaps
+        label_positions = []
 
-            if i == 0:
-                pass
-            else:
-                upstream = blade_rows[i - 1]
-                if upstream.row_type == RowType.Inlet:
-                    cut_line1, _, _ = self.passage.get_cutting_line(
-                        (row.hub_location * hub_length + (0.5 * row.blade_to_blade_gap * row.axial_chord) - row.axial_chord)
-                        / hub_length
-                    )
-                else:
-                    cut_line1, _, _ = self.passage.get_cutting_line(
-                        (upstream.hub_location * hub_length) / hub_length
+        for i, row in enumerate(blade_rows):
+            # Plot blade row exit locations
+            ax.plot(row.x, row.r, linestyle="none", marker="o",
+                   markersize=6, color="red", alpha=0.7, zorder=5)
+
+            # Label inlet
+            if row.row_type == RowType.Inlet:
+                x_pos = row.x.mean()
+                r_pos = row.r.mean()
+                ax.axvline(x=x_pos, color='green', linestyle=':', linewidth=2, alpha=0.7, zorder=2)
+                ax.text(x_pos, self.passage.rshroud_pts.max() * 1.05, 'INLET',
+                       fontsize=12, fontweight='bold', ha='center', va='bottom',
+                       bbox=dict(boxstyle='round,pad=0.5', facecolor='lightgreen', alpha=0.7))
+                label_positions.append((x_pos, 'INLET'))
+
+            # Plot blade rows with proper labels
+            elif row.row_type in [RowType.Stator, RowType.Rotor]:
+                if i > 0:
+                    upstream = blade_rows[i - 1]
+                    if upstream.row_type == RowType.Inlet:
+                        cut_line1, _, _ = self.passage.get_cutting_line(
+                            (row.hub_location * hub_length + (0.5 * row.blade_to_blade_gap * row.axial_chord) - row.axial_chord)
+                            / hub_length
+                        )
+                    else:
+                        cut_line1, _, _ = self.passage.get_cutting_line(
+                            (upstream.hub_location * hub_length) / hub_length
+                        )
+                    cut_line2, _, _ = self.passage.get_cutting_line(
+                        (row.hub_location * hub_length - (0.5 * row.blade_to_blade_gap * row.axial_chord)) / hub_length
                     )
-                cut_line2, _, _ = self.passage.get_cutting_line(
-                    (row.hub_location * hub_length - (0.5 * row.blade_to_blade_gap * row.axial_chord)) / hub_length
-                )
 
-            if row.row_type == RowType.Stator:
-                x1, r1 = cut_line1.get_point(np.linspace(0, 1, 10))
-                plt.plot(x1, r1, "m")
-                x2, r2 = cut_line2.get_point(np.linspace(0, 1, 10))
-                plt.plot(x2, r2, "m")
-                x_text = (x1 + x2) / 2
-                r_text = (r1 + r2) / 2
-                plt.text(x_text.mean(), r_text.mean(), "Stator", fontdict={"fontsize": "xx-large"})
-            elif row.row_type == RowType.Rotor:
-                x1, r1 = cut_line1.get_point(np.linspace(0, 1, 10))
-                plt.plot(x1, r1, color="brown")
-                x2, r2 = cut_line2.get_point(np.linspace(0, 1, 10))
-                plt.plot(x2, r2, color="brown")
-                x_text = (x1 + x2) / 2
-                r_text = (r1 + r2) / 2
-                plt.text(x_text.mean(), r_text.mean(), "Rotor", fontdict={"fontsize": "xx-large"})
-
-        plt.axis("scaled")
-        plt.savefig("Meridional.png", transparent=False, dpi=150)
+                    # Plot blade leading and trailing edges
+                    if row.row_type == RowType.Stator:
+                        color = 'purple'
+                        label = f'Stator {row.stage_id + 1}'
+                    else:
+                        color = 'brown'
+                        label = f'Rotor {row.stage_id + 1}'
+
+                    x1, r1 = cut_line1.get_point(np.linspace(0, 1, 10))
+                    ax.plot(x1, r1, color=color, linewidth=2.5, alpha=0.8, zorder=3)
+                    x2, r2 = cut_line2.get_point(np.linspace(0, 1, 10))
+                    ax.plot(x2, r2, color=color, linewidth=2.5, alpha=0.8, zorder=3)
+
+                    # Mark exit location with vertical line
+                    x_exit = row.x.mean()
+                    ax.axvline(x=x_exit, color=color, linestyle='--',
+                             linewidth=1.5, alpha=0.5, zorder=2)
+
+                    # Add exit label at top
+                    ax.text(x_exit, self.passage.rshroud_pts.max() * 1.02, f'{label} Exit',
+                           fontsize=10, ha='center', va='bottom', rotation=0,
+                           color=color, fontweight='bold')
+
+            # Label outlet
+            elif row.row_type == RowType.Outlet:
+                x_pos = row.x.mean()
+                ax.axvline(x=x_pos, color='blue', linestyle=':', linewidth=2, alpha=0.7, zorder=2)
+                ax.text(x_pos, self.passage.rshroud_pts.max() * 1.05, 'OUTLET',
+                       fontsize=12, fontweight='bold', ha='center', va='bottom',
+                       bbox=dict(boxstyle='round,pad=0.5', facecolor='lightblue', alpha=0.7))
+
+        # Formatting
+        ax.set_xlabel('Axial Distance [m]', fontsize=13, fontweight='bold')
+        ax.set_ylabel('Radial Distance [m]', fontsize=13, fontweight='bold')
+        ax.set_title(f'Meridional View - {self.num_streamlines} Streamlines',
+                    fontsize=14, fontweight='bold', pad=40)
+        ax.grid(True, alpha=0.3, linestyle=':', linewidth=0.5)
+        ax.legend(loc='upper left', fontsize=11, framealpha=0.9)
+        ax.set_aspect('equal', adjustable='box')
+
+        plt.tight_layout()
+        plt.savefig("Meridional.png", transparent=False, dpi=200, bbox_inches='tight')
         plt.show()
 
     def plot_velocity_triangles(self) -> None:
-        """Plot velocity triangles for each blade row (turbines).
-        """
+        """Plot velocity triangles for each blade row with improved styling and annotations."""
         blade_rows = self._all_rows()
-        prop = dict(arrowstyle="-|>,head_width=0.4,head_length=0.8", shrinkA=0, shrinkB=0)
+
+        # Define arrow properties for different velocity types
+        prop_V = dict(arrowstyle="-|>,head_width=0.5,head_length=1.0",
+                     shrinkA=0, shrinkB=0, color='blue', lw=2.5)
+        prop_W = dict(arrowstyle="-|>,head_width=0.5,head_length=1.0",
+                     shrinkA=0, shrinkB=0, color='red', lw=2.5)
+        prop_U = dict(arrowstyle="-|>,head_width=0.5,head_length=1.0",
+                     shrinkA=0, shrinkB=0, color='green', lw=2.5)
+        prop_component = dict(arrowstyle="-|>,head_width=0.4,head_length=0.8",
+                             shrinkA=0, shrinkB=0, color='gray', lw=1.5, linestyle='--')
 
         for j in range(self.num_streamlines):
             x_start = 0.0
             y_max = 0.0
             y_min = 0.0
-            plt.figure(num=1, clear=True)
+
+            fig, ax = plt.subplots(1, 1, figsize=(14, 8), dpi=150)
+
             for i in range(1, len(blade_rows) - 1):
                 row = blade_rows[i]
-                x_end = x_start + row.Vm.mean()
+                x_end = x_start + row.Vm[j]
                 dx = x_end - x_start
 
                 Vt = row.Vt[j]
                 Wt = row.Wt[j]
                 U = row.U[j]
+                Vm = row.Vm[j]
+
+                y_max = max(y_max, Vt, Wt, U + Wt, U + Vt)
+                y_min = min(y_min, Vt, Wt, 0)
+
+                # Draw absolute velocity V (blue)
+                ax.annotate("", xy=(x_end, Vt), xytext=(x_start, 0), arrowprops=prop_V, zorder=5)
+                v_mag = np.sqrt(Vm**2 + Vt**2)
+                ax.text((x_start + x_end) / 2, Vt / 2 + np.sign(Vt) * 15,
+                       f"V={v_mag:.1f}", fontsize=12, fontweight='bold',
+                       ha='center', color='blue',
+                       bbox=dict(boxstyle='round,pad=0.3', facecolor='lightblue', alpha=0.7))
+
+                # Draw relative velocity W (red)
+                ax.annotate("", xy=(x_end, Wt), xytext=(x_start, 0), arrowprops=prop_W, zorder=5)
+                w_mag = np.sqrt(Vm**2 + Wt**2)
+                ax.text((x_start + x_end) / 2, Wt / 2 - np.sign(Wt) * 15,
+                       f"W={w_mag:.1f}", fontsize=12, fontweight='bold',
+                       ha='center', color='red',
+                       bbox=dict(boxstyle='round,pad=0.3', facecolor='lightcoral', alpha=0.7))
+
+                # Draw velocity components and U
+                if abs(Vt) > abs(Wt):
+                    # Draw Wt component
+                    ax.annotate("", xy=(x_end, Wt), xytext=(x_end, 0), arrowprops=prop_component, zorder=3)
+                    ax.text(x_end + dx * 0.08, Wt / 2, f"Wt={Wt:.1f}",
+                           fontsize=10, ha='left', color='gray')
+
+                    # Draw U (blade speed)
+                    ax.annotate("", xy=(x_end, U + Wt), xytext=(x_end, Wt), arrowprops=prop_U, zorder=4)
+                    ax.text(x_end + dx * 0.08, (Wt + U + Wt) / 2, f"U={U:.1f}",
+                           fontsize=11, ha='left', fontweight='bold', color='green',
+                           bbox=dict(boxstyle='round,pad=0.3', facecolor='lightgreen', alpha=0.7))
+                else:
+                    # Draw Vt component
+                    ax.annotate("", xy=(x_end, Vt), xytext=(x_end, 0), arrowprops=prop_component, zorder=3)
+                    ax.text(x_end + dx * 0.08, Vt / 2, f"Vt={Vt:.1f}",
+                           fontsize=10, ha='left', color='gray')
+
+                    # Draw U (blade speed)
+                    ax.annotate("", xy=(x_end, Wt), xytext=(x_end, Vt), arrowprops=prop_U, zorder=4)
+                    ax.text(x_end + dx * 0.08, (Vt + Wt) / 2, f"U={U:.1f}",
+                           fontsize=11, ha='left', fontweight='bold', color='green',
+                           bbox=dict(boxstyle='round,pad=0.3', facecolor='lightgreen', alpha=0.7))
+
+                # Draw Vm component (dashed horizontal)
+                ax.plot([x_start, x_end], [0, 0], 'k--', linewidth=1.5, alpha=0.5, zorder=2)
+                ax.text((x_start + x_end) / 2, -5, f"Vm={Vm:.1f}",
+                       fontsize=10, ha='center', va='top', color='black')
+
+                # Add blade row label
+                label_y = y_min - (y_max - y_min) * 0.15 if Vt > 0 else y_max + (y_max - y_min) * 0.15
+                stage_label = f"{row.row_type.name} {row.stage_id + 1}"
+                ax.text((x_start + x_end) / 2, label_y, stage_label,
+                       fontsize=13, ha='center', fontweight='bold',
+                       bbox=dict(boxstyle='round,pad=0.5',
+                               facecolor='lightyellow' if row.row_type == RowType.Stator else 'lightcoral',
+                               edgecolor='black', linewidth=2))
+
+                # Add separation line between blade rows
+                if i < len(blade_rows) - 2:
+                    ax.axvline(x=x_end, color='gray', linestyle=':', linewidth=1, alpha=0.5, zorder=1)
+
+                x_start = x_end
+
+            # Formatting
+            margin = (y_max - y_min) * 0.2
+            ax.set_ylim([y_min - margin, y_max + margin])
+            ax.set_xlim([0, x_end * 1.1])
+
+            ax.set_ylabel('Tangential Velocity [m/s]', fontsize=13, fontweight='bold')
+            ax.set_xlabel('Meridional Velocity Vm [m/s]', fontsize=13, fontweight='bold')
+            ax.set_title(f'Velocity Triangles - Streamline {j} (r={blade_rows[1].r[j]:.4f} m)',
+                        fontsize=14, fontweight='bold', pad=20)
+
+            ax.grid(True, alpha=0.3, linestyle=':', linewidth=0.5)
+            ax.axhline(y=0, color='black', linewidth=1.5, zorder=2)
+
+            # Add legend
+            from matplotlib.patches import FancyArrow
+            legend_elements = [
+                plt.Line2D([0], [0], color='blue', linewidth=2.5, label='V (Absolute Velocity)'),
+                plt.Line2D([0], [0], color='red', linewidth=2.5, label='W (Relative Velocity)'),
+                plt.Line2D([0], [0], color='green', linewidth=2.5, label='U (Blade Speed)')
+            ]
+            ax.legend(handles=legend_elements, loc='upper right', fontsize=10, framealpha=0.9)
+
+            plt.tight_layout()
+            plt.savefig(f"streamline_{j:04d}.png", transparent=False, dpi=200, bbox_inches='tight')
+            plt.close()
+
+    def save_convergence_history(self, filename: str = "convergence_history.jsonl") -> None:
+        """Save convergence history to JSONL file.
+
+        Writes the convergence history collected during solve() to a JSON Lines file,
+        where each line is a JSON object representing one iteration.
+
+        Args:
+            filename: Output JSONL file path (default: "convergence_history.jsonl")
+
+        Returns:
+            None. Writes JSONL file to specified path.
 
-                y_max = max(y_max, Vt, Wt)
-                y_min = min(y_min, Vt, Wt)
+        Example:
+            >>> spool.solve()
+            >>> spool.save_convergence_history("turbine_convergence.jsonl")
+        """
+        import json
+        from pathlib import Path
 
-                # V
-                plt.annotate("", xy=(x_end, Vt), xytext=(x_start, 0), arrowprops=prop)
-                plt.text((x_start + x_end) / 2, Vt / 2 * 1.1, "V", fontdict={"fontsize": "xx-large"})
+        output_path = Path(filename)
+        with open(output_path, 'w') as f:
+            for entry in self.convergence_history:
+                f.write(json.dumps(entry) + '\n')
+        print(f"Convergence history saved to {output_path}")
 
-                # W
-                plt.annotate("", xy=(x_end, Wt), xytext=(x_start, 0), arrowprops=prop)
-                plt.text((x_start + x_end) / 2, Wt / 2 * 1.1, "W", fontdict={"fontsize": "xx-large"})
+    def plot_convergence(self, save_to_file: Optional[Union[bool, str]] = None) -> None:
+        """Plot convergence history showing massflow error vs iteration.
 
-                if abs(Vt) > abs(Wt):
-                    plt.annotate("", xy=(x_end, Wt), xytext=(x_end, 0), arrowprops=prop)  # Wt
-                    plt.text(x_end + dx * 0.1, Wt / 2, "Wt", fontdict={"fontsize": "xx-large"})
+        Displays a semi-log plot of the massflow standard deviation error across
+        iterations. If convergence history is empty, warns user.
 
-                    plt.annotate("", xy=(x_end, U + Wt), xytext=(x_end, Wt), arrowprops=prop)  # U
-                    plt.text(x_end + dx * 0.1, (Wt + U) / 2, "U", fontdict={"fontsize": "xx-large"})
-                else:
-                    plt.annotate("", xy=(x_end, Vt), xytext=(x_end, 0), arrowprops=prop)  # Vt
-                    plt.text(x_end + dx * 0.1, Vt / 2, "Vt", fontdict={"fontsize": "xx-large"})
+        Args:
+            save_to_file: If True, saves to "convergence.png". If string, saves to that filename.
+                         If None/False, displays plot without saving.
 
-                    plt.annotate("", xy=(x_end, Wt + U), xytext=(x_end, Wt), arrowprops=prop)  # U
-                    plt.text(x_end + dx * 0.1, Wt + U / 2, "U", fontdict={"fontsize": "xx-large"})
+        Returns:
+            None. Either displays plot or saves to file.
 
-                y = y_min if -np.sign(Vt) > 0 else y_max
-                plt.text((x_start + x_end) / 2, -np.sign(Vt) * y * 0.95, row.row_type.name, fontdict={"fontsize": "xx-large"})
-                x_start += row.Vm[j]
-                plt.axis([0, x_end + dx, y_min, y_max])
-            plt.ylabel("Tangental Velocity [m/s]")
-            plt.xlabel("Vm [m/s]")
-            plt.title(f"Velocity Triangles for Streamline {j}")
-            plt.savefig(f"streamline_{j:04d}.png", transparent=False, dpi=150)
+        Example:
+            >>> spool.solve()
+            >>> spool.plot_convergence()  # Display plot
+            >>> spool.plot_convergence(save_to_file=True)  # Save to convergence.png
+            >>> spool.plot_convergence(save_to_file="my_convergence.png")  # Save to custom file
+        """
+        if not self.convergence_history:
+            print("Warning: No convergence history available. Run solve() first.")
+            return
+
+        iterations = [entry['iteration'] for entry in self.convergence_history]
+        massflow_std = [entry['massflow_std'] for entry in self.convergence_history]
+        relative_change = [entry['relative_change'] for entry in self.convergence_history]
+
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
+
+        # Plot massflow std deviation
+        ax1.semilogy(iterations, massflow_std, 'o-', linewidth=2, markersize=8)
+        ax1.set_xlabel('Iteration', fontsize=16)
+        ax1.set_ylabel('2× Massflow Std Dev [kg/s]', fontsize=16)
+        ax1.set_title('Convergence History: Massflow Standard Deviation', fontsize=14, fontweight='bold')
+        ax1.grid(True, alpha=0.3)
+
+        # Plot relative change
+        ax2.semilogy(iterations, relative_change, 's-', color='orange', linewidth=2, markersize=8)
+        ax2.set_xlabel('Iteration', fontsize=16)
+        ax2.set_ylabel(r'Massflow Residual $\left|\frac{err_{n-1} - err_n}{err_n}\right|$', fontsize=16)
+        ax2.set_title('Convergence History: Relative Error Change', fontsize=14, fontweight='bold')
+        ax2.grid(True, alpha=0.3)
+
+        plt.tight_layout()
+
+        if save_to_file:
+            filename = "convergence.png" if save_to_file is True else str(save_to_file)
+            plt.savefig(filename, dpi=150, bbox_inches='tight')
+            print(f"Convergence plot saved to {filename}")
+        else:
+            plt.show()
 
 
 # ------------------------------
@@ -966,9 +1203,7 @@ def massflow_loss_function(
     compute_power(row, upstream)
 
     if row.row_type != RowType.Inlet:
-        T3_is = upstream.T0 * (1 / row.P0_P) ** ((row.gamma - 1) / row.gamma)
-        a = np.sqrt(row.gamma * row.R * T3_is)
-        T03_is = T3_is * (1 + (row.gamma - 1) / 2 * (row.V / a) ** 2)
+        T03_is = upstream.T0 * (row.P0 / upstream.P0) ** ((row.gamma - 1) / row.gamma)
         row.eta_total = (upstream.T0.mean() - row.T0.mean()) / (upstream.T0.mean() - T03_is.mean())
 
     return float(np.abs(massflow_target - row.massflow[index]))