turbo-design 1.0.10__py3-none-any.whl → 1.1.0__py3-none-any.whl

{turbo_design-1.0.10.dist-info → turbo_design-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: turbo-design
-Version: 1.0.10
+Version: 1.1.0
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: cantera
 Requires-Dist: findiff
 Requires-Dist: matplotlib

{turbo_design-1.0.10.dist-info → turbo_design-1.1.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
 turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
-turbodesign/bladerow.py,sha256=F94KAARzGd4edOgs2Cd6dSRteyYCR5U45687anYY-As,24042
+turbodesign/bladerow.py,sha256=-Oym4HhX9Wx6i6Nv7Krb6xdZWSxLiEVMb7xg2K5rR0w,24239
 turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
 turbodesign/compressorspool.py,sha256=z8ZVczJ-EdZvIqqZArC6UdwC5MbU2SZh_MT2CGq5avY,2600
 turbodesign/coolant.py,sha256=nuj7ryUXuBhuOPt2jHjHwtEM_LVno7A8Wm14P0lJn-8,436
@@ -20,14 +20,14 @@ turbodesign/loss/turbine/kackerokapuu.py,sha256=hUmZdyA1hAhN3_xbwBhka2dyk0Aq9rqq
 turbodesign/loss/turbine/traupel.py,sha256=aZxFE9JDcCfi1gy-fqS1SxjjlhuDG-H-g3LPurty1M0,4164
 turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
 turbodesign/outlet.py,sha256=SwTwoL6XnWlsrE5A6wLxu3qXkydDDUsdKKeBbJm4mrQ,2069
-turbodesign/passage.py,sha256=9cRSCZIS4LqlIcO8mOeePN42hmcc4g8tFDZ3F86WM7E,7594
-turbodesign/radeq.py,sha256=4unpFad6hvgaYwYLBNI8o9bszyvoNiizYjMqRX0Mjcc,10012
+turbodesign/passage.py,sha256=eZGaB5Gq9Frm80TTDJaLm1TxJV2-_fHHIeqjPuvtb8E,9550
+turbodesign/radeq.py,sha256=RCsiQzcHvR5dozK6XG0eysAhXYewF0BY_qX0f1knURo,10091
 turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
 turbodesign/solve_radeq.py,sha256=2VGzFSVkyN0rTPFHaCQiD3v166cdEs39x7x7RuzLgmw,1886
-turbodesign/spool.py,sha256=FImXUwB4bJSAFroae-Y0fL5T7hBCiHg17Uo2zRvcFnA,13864
+turbodesign/spool.py,sha256=h4m--HR5g8o01Kkhl4Mbvx7WORQez3YpncDE7XxbNaw,14172
 turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
-turbodesign/td_math.py,sha256=28cGzmTMs2evC0vMEp0oN6UmSJDHsKfXw51XJSMxmo8,17370
-turbodesign/turbinespool.py,sha256=s9cZpK9245pjUYI5hOo81SsO8UqG-TVUJlSN7SQu7yw,25877
-turbo_design-1.0.10.dist-info/METADATA,sha256=jQ5YdRxxq3NcYV-B7beGfmgTGTsGhMzE8PC8Y3W23QU,684
-turbo_design-1.0.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-turbo_design-1.0.10.dist-info/RECORD,,
+turbodesign/td_math.py,sha256=K_LyxcgDWNjR9vOA4wfofzlmJlsDn_y64Rj1wi0FTZo,17489
+turbodesign/turbinespool.py,sha256=OJZsucQpGiAHSQOmi7FcagN3jP8dai8umtwC0jBVZGM,25959
+turbo_design-1.1.0.dist-info/METADATA,sha256=feg_7pDPWUK07MJJR8jhx8g6ixlSiEZerhcdKJQ9GBk,734
+turbo_design-1.1.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+turbo_design-1.1.0.dist-info/RECORD,,

{turbo_design-1.0.10.dist-info → turbo_design-1.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

turbodesign/bladerow.py

@@ -117,7 +117,7 @@ class BladeRow:
     _te_s:float = 0.08
     _tip_clearance:float = 0 # Clearance as a percentage of span or blade height
 
-    _inlet_to_outlet_pratio = [0.06,0.7]
+    _inlet_to_outlet_pratio = [0.06,0.95]
         
     @property
     def inlet_to_outlet_pratio(self) -> Tuple[float,float]:
@@ -432,7 +432,10 @@ class BladeRow:
             val (float): new trailing edge to pitch ratio
         """
         self._te_s = val
-        
+    
+    def __repr__(self):
+        return f"{self.row_type.name:0.2f}' P0:{np.mean(self.P0):0.2f} T0:{np.mean(self.T0):0.2f} P:{np.mean(self.P):0.2f} massflow:{self.total_massflow_no_coolant}:0.3f"
+    
     def to_dict(self):
         
         data = {

turbodesign/passage.py

@@ -104,26 +104,42 @@ class Passage:
 
         """
         phi = np.zeros(shape=x_streamline.shape)
-        rm = phi.copy()
-        r  = phi.copy()
-            
-        d_dx = FinDiff(0,x_streamline,1)
-        d2_dx2 = FinDiff(0,x_streamline,2)
-        dr_dx = d_dx(r_streamline)
-        d2r_dx2 = d2_dx2(r_streamline)    
+        r  = np.zeros(shape=x_streamline.shape)
+        radius_curvature = np.zeros(shape=x_streamline.shape)
+        # Have to make sure there isn't a divide by zero which could happen if there is a vertical line somewhere
+        indices = np.where(np.abs(np.diff(x_streamline))>np.finfo(float).eps)[0]
+    
+        d_dx = FinDiff(0,x_streamline[indices[0]:indices[-1]],1)
+        d2_dx2 = FinDiff(0,x_streamline[indices[0]:indices[-1]],2)
+        dr_dx = d_dx(r_streamline[indices[0]:indices[-1]])
+        d2r_dx2 = d2_dx2(r_streamline[indices[0]:indices[-1]])    
             
-        radius_curvature = np.power((1+np.power(dr_dx,2)),1.5)
-        radius_curvature = np.divide(radius_curvature, np.abs(d2r_dx2))
+        radius_curvature[indices[0]:indices[-1]] = np.power((1+np.power(dr_dx,2)),1.5)
+        radius_curvature[indices[0]:indices[-1]] = np.divide(radius_curvature[indices[0]:indices[-1]], np.abs(d2r_dx2))
         radius_curvature = np.nan_to_num(radius_curvature,nan=0)
         
+        def vertical_line_phi(start:int,end:int):
+            # Lets get the phi and slope for the vertical parts 
+            for i in range(start,end):     
+                dx = x_streamline[i] - x_streamline[i-1]
+                dr = r_streamline[i] - r_streamline[i-1]
+                if (dr < 0) & (np.abs(dx) < np.finfo(float).eps):
+                    phi[i-1] = -np.pi/2
+                elif (dr > 0) & (np.abs(dx) < np.finfo(float).eps):
+                    phi[i-1] = np.pi/2
+                radius_curvature[i-1] = 1000000 # Initialize to high number, used in radeq. 
+                
+        vertical_line_phi(1,indices[0])
+        vertical_line_phi(indices[1],len(x_streamline))
+        
         rm = radius_curvature     # https://www.cuemath.com/radius-of-curvature-formula/ should be 1/curvature
-        phi = np.arctan(dr_dx)
+        phi[indices[0]:indices[-1]] = np.arctan(dr_dx)
         r = r_streamline
             
         return phi, rm, r
         
     def get_cutting_line(self, t_hub:float) -> line2D:
-        """Gets the cutting line between hub and shroud 
+        """Gets the cutting line perpendicular to hub and shroud 
 
         Args:
             t_hub (float): percentage along the axial direction 
@@ -168,6 +184,27 @@ class Passage:
         rshroud = self.rshroud(t_shroud)
         return line2D([xhub,rhub],[xshroud,rshroud]), t_hub, t_shroud
     
+    def get_xr_slice(self,t_span:float,axial_location:float):
+        """Returns the xr coordinates of a streamline, a line that is parallel to both hub and shroud
+            
+        Args:
+            t_span (float): _description_
+            axial_location (float): _description_
+
+        Returns:
+            np.NDArray: _description_
+        """
+        t_hub = np.linspace(0,axial_location,100)
+        
+        shroud_pts_cyl = np.vstack([self.xshroud(t_hub),self.rshroud(t_hub)]).transpose()
+        hub_pts_cyl = np.vstack([self.xhub(t_hub),self.rhub(t_hub)]).transpose()
+        n = len(t_hub)
+            
+        xr = np.zeros((n,2))
+        for j in range(n):
+            l = line2D(hub_pts_cyl[j,:],shroud_pts_cyl[j,:])
+            xr[j,0],xr[j,1] = l.get_point(t_span)
+        return xr
         
     @property
     def hub_length(self):
@@ -186,7 +223,7 @@ class Passage:
         
         plt.figure(num=1,clear=True,dpi=150,figsize=(15,10))
         plt.plot(self.xhub_pts,self.rhub_pts,label='hub',linestyle='solid',linewidth=2,color='black')
-        plt.plot(self.xshroud_pts,self.rshroud_pts,label='hub',linestyle='solid',linewidth=2,color='black')
+        plt.plot(self.xshroud_pts,self.rshroud_pts,label='shroud',linestyle='solid',linewidth=2,color='black')
         for p in percent_axial:
             cut,_,_ = self.get_cutting_line(p)
             x,r = cut.get_point(np.linspace(0,1,10))

turbodesign/radeq.py

@@ -52,12 +52,12 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
         gamma = row.gamma
 
         # Solve the Radial Equlibrium 
-        Vt = Vm*np.cos(phi)*np.tan(alpha)
+        Vt = Vm*np.tan(alpha)
         Vr = Vm*np.sin(phi)
         # Estimations 
         dVm_dr = float(interp1d(row_radius, np.gradient(row.Vm, row_radius))(r))
-        dVt_dr = dVm_dr*np.cos(phi)*np.tan(alpha)
-        dVr_dr = 0 #dVm_dr*np.sin(phi)
+        dVt_dr = dVm_dr*np.tan(alpha)
+        dVr_dr = dVm_dr*np.sin(phi)
 
         # Upstream 
         dT0up_dr = float(interp1d(upstream.percent_hub_shroud, np.gradient(upstream.T0,up_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get the T0 upstream value
@@ -74,7 +74,9 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
         # if row.loss_function.LossType == LossType.Pressure: # type: ignore
         #     dP0_dr = dP0up_dr-row.Yp*(dP0up_dr - dP_dr)     # Eqn 9
 
-        C = Vm**2*(1+np.cos(phi)**2 * np.tan(alpha)**2)/(2*Cp*T0)
+        C = Vm**2*(1+np.tan(alpha)**2)/(2*Cp*T0)
+        if (C>1) & ((gamma/(gamma-1))<2):
+            raise Exception("Invalid value of C {C}, change reduce alpha or Vm")
         B = (1-C)**(gamma/(gamma-1))      
         A = P0 * gamma/(gamma-1) * (1-C)**(1/(gamma-1))
         dVm_dr = 1/(2*Vm*A) * (rho*(Vt/r - Vm**2/rm * np.cos(phi) - Vr*dVr_dr) - dP0_dr*B) + 1/(2*T0) *dT0_dr  # Eqn 6

turbodesign/spool.py

@@ -87,6 +87,8 @@ class Spool:
             new_gas (ct.Solution.Solution): New gas mixture
         """
         self._fluid = newFluid
+        for i in range(len(self.blade_rows)):
+            self.blade_rows[i].fluid = self.fluid
 
     @property
     def adjust_streamlines(self) -> bool:
@@ -249,7 +251,7 @@ class Spool:
             plt.figure(num=1,clear=True)
             for i in range(1,len(self.blade_rows)-1): # Don't plot inlet or outlet 
                 row = self.blade_rows[i]
-                x_end = x_start + row.Vx.mean()
+                x_end = x_start + row.Vm.mean()
                 dx = x_end - x_start
                 
                 Vt = row.Vt[j]
@@ -285,9 +287,15 @@ class Spool:
                     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"})
 
-                plt.text((x_start+x_end)/2,-y_max*0.95,row.row_type.name,fontdict={"fontsize":"xx-large"})
-                x_start += row.Vx[j]
+                if -np.sign(Vt)>0:
+                    y = y_min 
+                else:
+                    y = 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)
     

turbodesign/td_math.py

@@ -4,6 +4,7 @@ import math
 import numpy.typing as npt
 from .bladerow import BladeRow, compute_gas_constants
 from .enums import RowType, LossType
+from scipy.integrate import trapezoid
 
 def T0_coolant_weighted_average(row:BladeRow) -> float:
     """Calculate the new weighted Total Temperature array considering coolant
@@ -99,7 +100,7 @@ def compute_power(row:BladeRow,upstream:BladeRow) -> None:
         row.eta_static = row.power/ (row.massflow[-1]*row.Cp*(upstream.T0.mean()-row.T0_is.mean()))
         row.eta_total = row.power / (row.massflow[-1]*row.Cp * (upstream.T0.mean()-row.T0_is.mean()))
         row.stage_loading = row.Cp*(upstream.T0.mean() - row.T0.mean())/row.U.mean()**2
-        row.euler_power = (row.massflow[-1]*((row.U+upstream.U)/2).mean()*(upstream.Vt-row.Vt).mean())
+        row.euler_power = row.massflow[-1]* (upstream.U*upstream.Vt - row.U*row.Vt).mean()
     
 def compute_quantities(row:BladeRow,upstream:BladeRow):
     """Calculation of all quantites after radial equilibrium has been solved assuming we know the static pressure at the exit.
@@ -254,21 +255,18 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,calculat
         row.T0 = upstream.T0 - T0_coolant_weighted_average(row)
         row.T = row.T0/T0_T
         row.V = row.M*np.sqrt(row.gamma*row.R*row.T)
-        VV = row.V*np.cos(row.phi)
-        row.Vx = VV*np.cos(row.alpha2)
-        row.Vt = VV*np.sin(row.alpha2)
+        row.Vx = row.Vm*np.cos(row.phi)
         row.Vr = row.V*np.sin(row.phi)
         row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
-    else: # We know Vm, P0, T0
+        row.Vt = row.Vm*np.tan(row.alpha2)
+    else: # We know Vm, P0, T0, P
         row.Vx = row.Vm*np.cos(row.phi)
         row.Vr = row.Vm*np.sin(row.phi)
-        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
+        row.Vt = row.Vm*np.tan(row.alpha2)
         row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
-        for _ in range(3): # Mach is a function of T and T is a function of Mach
-            row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
-            T0_T = (1+(row.gamma-1)/2 * row.M**2)
-            row.P = row.P0 *(1/T0_T)**(row.gamma/(row.gamma-1))
-            row.T = row.T0 * (1/T0_T)
+        
+        row.T = row.P/(row.R*row.rho)   # We know P, this is a guess
+        row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
         
     if upstream.row_type == RowType.Rotor:
         row.alpha1 = upstream.alpha2 # Upstream rotor absolute frame flow angle
@@ -296,13 +294,14 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     upstream.U = upstream.rpm*np.pi/30 * upstream_radius # rad/s 
     upstream.Wt = upstream.Vt - upstream.U
     upstream.W = np.sqrt(upstream.Vx**2 + upstream.Wt**2 + upstream.Vr**2)
-    upstream.beta2 = np.arctan2(upstream.Wt,upstream.Vx)
+    upstream.beta2 = np.arctan2(upstream.Wt,upstream.Vm)
     upstream.T0R = upstream.T+upstream.W**2/(2*upstream.Cp)
     upstream.P0R = upstream.P * (upstream.T0R/upstream.T)**((upstream.gamma)/(upstream.gamma-1))      
     upstream.M_rel = upstream.W/np.sqrt(upstream.gamma*upstream.R*upstream.T)
     
     upstream_rothalpy = upstream.T0R*upstream.Cp - 0.5*upstream.U**2 # H01R - 1/2 U1^2 
-
+    if np.any(upstream_rothalpy < 0):
+        print('U is too high, reduce RPM or radius')
     # Rotor Exit Calculations
     row.beta1 = upstream.beta2
     #row.Yp # Evaluated earlier 
@@ -319,26 +318,26 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
             # Need to adjust T
             print(f'nan detected: check flow path. Turbine inlet cut should be horizontal')
         row.Vr = row.W*np.sin(row.phi)
-        row.Wt = np.sqrt(row.W**2 - row.Vr**2) * np.sin(row.beta2)
+        row.Vm = row.W*np.cos(row.beta2)
+        row.Wt = row.W*np.sin(row.beta2)
+        row.Vx = row.Vm*np.cos(row.phi)
         row.Vt = row.Wt + row.U 
-        ww = row.W*np.cos(row.phi)
-        row.Vx = ww*np.cos(row.beta2)
         row.V = np.sqrt(row.Vr**2+row.Vt**2+row.Vx**2)
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
         row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
         row.T0 = row.T + row.V**2/(2*row.Cp)
         row.P0 = row.P*(row.T0/row.T)**(row.gamma/(row.gamma-1))
-        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+        row.alpha2 = np.arctan2(row.Vt,row.Vm)
     else: # We know Vm, P0, T0
         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 = np.sqrt(row.W**2 - row.Vr**2) * np.sin(row.beta2) 
+        row.Wt = row.W*np.sin(row.beta2)
         row.U = row.omega * row.r 
         row.Vt = row.Wt+row.U
         
-        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+        row.alpha2 = np.arctan2(row.Vt,row.Vm)
         row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
         
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
@@ -365,7 +364,7 @@ def inlet_calc(row:BladeRow):
     row.P = row.P0 
     row.rho = row.P/(row.T*row.R)
     total_area = 0 
-    for _ in range(5): # Lets converge the Mach and Total and Static pressures
+    for iter in range(5): # Lets converge the Mach and Total and Static pressures
         for j in range(1,len(row.percent_hub_shroud)):
             rho = row.rho[j]
             tube_massflow = row.massflow[j]-row.massflow[j-1]
@@ -379,6 +378,11 @@ def inlet_calc(row:BladeRow):
                 area[j] = 2*np.pi*C*(S/2*dx**2+row.r[j-1]*dx)
                 total_area += area[j]
                 row.Vm[j] = tube_massflow/(rho*area[j])
+        avg_mach = np.mean(row.M)
+        if np.mean(row.M)>0.5:
+            print(f"High inlet mach can lead to errors iter:{iter} Mach:{avg_mach}")
+        if np.mean(row.M)<0.01:
+            print(f"Unusually slow flow:{iter} Mach:{avg_mach}")
         row.Vm[0] = 1/(len(row.Vm)-1)*row.Vm[1:].sum() # Initialize the value at the hub to not upset the mean
         row.Vr = row.Vm*np.sin(row.phi)
         row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)

turbodesign/turbinespool.py

@@ -206,7 +206,9 @@ class TurbineSpool(Spool):
                             sign*=-1
                 if len(stage_ids) % 2 == 1:
                     massflow_stage.append(massflow_stage[-1]*sign)
-                
+            deviation = np.std(total_massflow)*2
+            if deviation>1.0:
+                print("high massflow deviation detected")
             return np.std(total_massflow)*2 # + abs(sum(massflow_stage))  # Equation 28
             
         # Balance the massflow between Stages
@@ -229,27 +231,27 @@ class TurbineSpool(Spool):
             Returns:
                 _type_: _description_
             """
-            try:
-                if balance_mean_pressure:
-                    for j in range(self.num_streamlines):                
-                        Ps_range = outlet_pressure(x0,P0[j],P[j])
-                        for i in range(1,len(blade_rows)-1):
-                            blade_rows[i].P[j] = Ps_range[i-1]
-                    blade_rows[-1].P = P
-                else:
+            # try:
+            if balance_mean_pressure:
+                for j in range(self.num_streamlines):                
+                    Ps_range = outlet_pressure(x0,P0[j],P[j])
                     for i in range(1,len(blade_rows)-1):
-                        for j in range(self.num_streamlines):
-                            blade_rows[i].P[j] = P[j]*x0[(i-1)*self.num_streamlines+j]    # x0 size = num_streamlines -1 
-                    
-                calculate_massflows(blade_rows,True)
-                print(x0)
-                return calculate_error(blade_rows)
-            except:
+                        blade_rows[i].P[j] = Ps_range[i-1]
+                blade_rows[-1].P = P
+            else:
                 for i in range(1,len(blade_rows)-1):
                     for j in range(self.num_streamlines):
-                        blade_rows[i].P[j] = P[j]
-                calculate_massflows(blade_rows,True)
-                return 10
+                        blade_rows[i].P[j] = P[j]*x0[(i-1)*self.num_streamlines+j]    # x0 size = num_streamlines -1 
+                
+            calculate_massflows(blade_rows,True)
+            print(x0)
+            return calculate_error(blade_rows)
+            # except:
+            #     for i in range(1,len(blade_rows)-1):
+            #         for j in range(self.num_streamlines):
+            #             blade_rows[i].P[j] = P[j]
+            #     calculate_massflows(blade_rows,True)
+            #     return 10
         # Break apart the rows to stages
         outlet_P=list(); outlet_P_guess = list() # Outlet P is the bounds, outlet_p_guess is the guessed values 
         
@@ -534,11 +536,11 @@ def outlet_pressure(percents:List[float],inletP0:float,outletP:float) -> npt.NDA
     maxP = inletP0
     minP = outletP
     if isinstance(percents, float):
-        Ps = [percents*(minP-maxP)+maxP]
+        Ps = [percents*(maxP-minP)+minP]
     else:
         Ps = np.zeros(shape=(len(percents),1)); i = 0
         for p in percents:
-            Ps[i] = p*(minP-maxP)+maxP
+            Ps[i] = p*(maxP - minP) + minP
             maxP = Ps[i]
             i+=1
     return Ps