turbo-design 1.0.0__py2.py3-none-any.whl

turbodesign/loss/turbine/craigcox.py

@@ -0,0 +1,189 @@
+import pickle, os
+from typing import Dict
+from ...bladerow import BladeRow, sutherland
+from ...lossinterp import LossInterp
+from ...enums import RowType, LossType
+import numpy as np
+import pathlib
+from ..losstype import LossBaseClass
+
+class CraigCox(LossBaseClass):
+    
+    def __init__(self):
+        """Craig and Cox used to estimate loss for subsonic higher mach number flows in axial turbines. Assumes suction side has low convex surface close to throat. 
+
+        Reference:
+            Craig, H. R. M., and H. J. A. Cox. "Performance estimation of axial flow turbines." Proceedings of the Institution of Mechanical Engineers 185.1 (1970): 407-424.
+            
+        """
+        super().__init__(LossType.Enthalpy)
+        path = pathlib.Path(os.path.join(os.environ['TD3_HOME'],"craigcox"+".pkl"))
+        
+        if not path.exists():
+            print('Download file if doesn\'t exist')    
+        
+        with open(path.absolute(),'rb') as f:
+            self.data = pickle.load(f) # type: ignore
+        
+        self.C = 1/(200*32.2*778.16) # https://www.sciencedirect.com/science/article/pii/S2666202721000574 
+    
+    
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """Craig and Cox uses the enthalpy definition of loss to calculate the loss of a turbine stage. 
+        
+        Note: 
+            Losses are organized as Group 1 which include profile losses and secondary flows. 
+            Group 2 losses include rotor tip leakage, balance losses, guide gland losses, lacing wire losses.
+            
+            All equation numbers are from the craig cox paper
+            Craig, H. R. M., and H. J. A. Cox. "Performance estimation of axial flow turbines." Proceedings of the Institution of Mechanical Engineers 185.1 (1970): 407-424.
+        
+        Equations:
+            Eta_t = (Work done - Group 2 losses) / (Work done + Group 1 Losses) 
+            
+            Group1 Losses = (Xp + Xs + Xa)*C1**2/(200gJ) + (Xp + Xs + Xa)*W2**2/(200gJ)
+            Group1 Losses = Stator Component + Rotor Component where C1 and W2 are exit velocities for stator and rotor 
+            
+            i+i_stall = (i+i_stall)_basic + (\delta i + stall)_sb + (\delta i + stall)_cb 
+
+            (i+i_stall)_basic from Figure 11
+            (delta incidence + stall)_sb + (delta incidence + stall)_cb from Figure 12
+
+            Profile Loss
+            Xp = x_pb N_pr N_pi N_pt + (\delta x_p)_t + (\delta x_p)_s/e + (\delta x_p)_m
+
+            - x_pb from Figure 5 but use Figure 4 to calculate Fl. Fl*x*s/b is the x axis for Figure 5 
+            - N_pr from figure 3 
+            - N_pi from Figure 10
+            - N_pt from Figure 6
+            - (\delta x_p)_t 
+            - (\delta x_p)_s/e from Figure 9
+            - (\delta x_p)_m from Figure 8
+
+        Args:
+            upstream (BladeRow): Upstream blade row
+            row (BladeRow): downstream blade row
+
+        Returns:
+            float: Stage Efficiency
+        """
+        if row.row_type == RowType.Stator:
+            return 0
+        else:
+            V_inlet = upstream.V.mean()
+            V = row.W.mean()
+        
+        def lookup_constants(currentRow:BladeRow):
+            # Contraction Ratio find s/b and use Fig07
+            s_b = currentRow.pitch/currentRow.camber
+            if currentRow.row_type == RowType.Stator:
+                V = currentRow.V.mean()
+                # See weird velocity triangle in Figure 1
+                inlet_flow_angle = 90-np.abs(np.degrees(currentRow.alpha1).mean())
+                outlet_flow_angle =90-np.abs(np.degrees(currentRow.alpha2).mean())
+                incidence_angle = np.degrees(currentRow.alpha1 - currentRow.beta1_metal).mean()
+                M_out = currentRow.M.mean()
+            else:
+                V = currentRow.W.mean()
+                inlet_flow_angle = 90-np.abs(np.degrees(currentRow.beta1).mean())
+                outlet_flow_angle =90-np.abs(np.degrees(currentRow.beta2).mean())
+                incidence_angle = np.degrees(currentRow.beta1 - currentRow.beta1_metal).mean()
+                M_out = currentRow.M_rel.mean()
+                
+            Re =  V * currentRow.rho*currentRow.chord / sutherland(currentRow.T.mean())
+            Re = Re.mean()
+            
+            if currentRow.beta1_fixed:
+                blade_inlet_angle = 90-np.abs(np.degrees(currentRow.beta1_metal.mean())) # Alpha
+            else:
+                if currentRow.row_type == RowType.Stator:
+                    blade_inlet_angle = 90-np.abs(np.degrees(currentRow.alpha1.mean())) # Alpha1
+                else:
+                    blade_inlet_angle = 90-np.abs(np.degrees(currentRow.beta1.mean())) # beta1
+                
+            te = currentRow.te_pitch * currentRow.pitch
+            e_s = 0.3 # Pitch to back radius ratio, assumed. lower value = less loss
+            if currentRow.beta1_fixed:
+                imin = 90-currentRow.beta1_metal.mean()
+            else:
+                imin = 90-currentRow.beta1.mean() # Incidence required for minimum loss
+            
+            asin_os = np.degrees(np.arcsin(currentRow.throat/currentRow.pitch))
+            
+            N_pr = self.data['Fig03'](Re,0.05) # use a good finish for the geometry
+            if (inlet_flow_angle-imin < 10):
+                Fl = 13
+            else:
+                Fl = self.data['Fig04'](outlet_flow_angle,inlet_flow_angle-imin)
+            
+            x = 1-np.sin(np.radians(outlet_flow_angle))/np.sin(np.radians(inlet_flow_angle))
+            contraction_ratio = self.data['Fig07'](x,s_b) # contraction ratio
+
+            X_pb = self.data['Fig05'](Fl*s_b,contraction_ratio)
+            delta_X_pt = self.data['Fig06_delta_Xpt'](currentRow.te_pitch)
+            N_pt = self.data['Fig06_Npt'](currentRow.te_pitch,outlet_flow_angle)
+            delta_Xpm = self.data['Fig08'](M_out,np.degrees(np.arcsin((currentRow.throat+te)/currentRow.pitch)))
+            delta_Xp_se = self.data['Fig09'](e_s,M_out) 
+            
+            Fi = self.data['Fig15'](blade_inlet_angle,s_b)
+            # Incidence Effects 
+            if currentRow.beta1_fixed:
+                if incidence_angle>0: # Positive incidence
+                    stall_incidence_angle = self.data['Fig11'](currentRow.beta1.mean(),asin_os)
+                    
+                    incidence_ratio = (incidence_angle - imin)/(stall_incidence_angle-imin)
+
+                    i_plus_istall_sb = self.data['Fig12_sb'](s_b,asin_os)
+                    i_plus_istall_cor = self.data['Fig12_cr'](contraction_ratio,asin_os)
+                    
+                    if blade_inlet_angle<=90:
+                        i_plus_istall_basic = self.data['Fig11'](inlet_flow_angle,asin_os)
+                        i_plus_istall = i_plus_istall_basic + i_plus_istall_sb + i_plus_istall_cor # Eqn 5 
+                    else:
+                        i_plus_istall_basic = self.data["Fig14_i+istall"](blade_inlet_angle,asin_os)
+                        i_plus_istall = i_plus_istall_basic + (1-(blade_inlet_angle-90)/(90-asin_os))*(i_plus_istall_sb + i_plus_istall_cor) # Eqn 7 
+                else:
+                    i_minus_istall_sb = self.data['Fig13'](s_b,asin_os)
+
+                    if blade_inlet_angle<=90: 
+                        i_minus_istall_basic = self.data['Fig13_alpha1'](s_b,asin_os)
+                        i_minus_istall = i_minus_istall_basic + i_minus_istall_sb # Eqn 6
+                    else:
+                        i_minus_istall_basic = self.data["Fig14_i-istall"](blade_inlet_angle,asin_os)
+                        i_minus_istall = i_minus_istall_basic + (1-(blade_inlet_angle - 90)/(90-asin_os)) * i_minus_istall_sb   # Eqn 8 
+                        
+                imin = (i_plus_istall + Fi * (i_minus_istall))/(1+Fi) # type: ignore # Eqn 9
+                N_pi = self.data['Fig10'](imin,incidence_ratio)
+            else:
+                N_pi = 1 # No effect
+            
+            Xp = X_pb*N_pr*N_pi*N_pt + delta_X_pt + delta_Xp_se + delta_Xpm # Eqn 10
+            
+            # Secondary Loss 
+            Ns_hb = self.data['Fig17'](1/currentRow.aspect_ratio)
+            x_sb = self.data['Fig18']((V_inlet/V)**2,s_b*Fl)
+                
+            Nsr = 1 # N_pr # I have no clue about this. Craig Cox doesn't describe. setting it to 1 for now.
+            Xs = Nsr*Ns_hb*x_sb 
+            # Annulus Loss Factor
+            Xa = 0            
+            return Xp, Xs, Xa 
+        
+
+        Xp1,Xs1,Xa1 = lookup_constants(upstream)
+        Xp2,Xs2,Xa2 = lookup_constants(row)
+        Group1_Loss = (Xp1 + Xs1 + Xa1) * V_inlet**2 *3.28**2 * self.C + (Xp2 + Xs2 + Xa2*V_inlet**2/V**2) *  V**2 *3.28**2 * self.C # type: ignore
+                # Eqn 4, convert V from m^2/s^2to ft^2/s^2
+                
+        # According to Equation 3, Group 1 loss is an enthalpy loss Cp*T0 Btu/lb. Need to convert to Pressure Loss
+        
+        # Btu/lbf to J/Kg
+       
+        T0_Loss = Group1_Loss * 2326 / row.Cp # Eqn 3 in Kelvin
+        T0_T = (row.T0/row.T).mean() 
+        T02 = row.T0.mean()-T0_Loss # P02 Changes 
+        
+        # According to Equation 3, Group 1 loss is an enthalpy loss Cp*T0. Need to convert to Pressure Loss
+        eta_total = (upstream.T0.mean() - row.T0.mean())/(upstream.T0.mean()-(row.T0.mean()-T0_Loss))
+        return eta_total
+        

turbodesign/loss/turbine/fixedefficiency.py

@@ -0,0 +1,29 @@
+from ...bladerow import BladeRow, sutherland
+from ...enums import RowType, LossType
+from ..losstype import LossBaseClass
+
+class FixedEfficiency(LossBaseClass):
+    efficiency:float
+    
+    def __init__(self,efficiency:float):
+        """Fixed Efficiency Loss 
+        """
+        super().__init__(LossType.Enthalpy)
+        self.efficiency = efficiency
+    
+    
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """Fixed efficiency loss 
+        
+        Args:
+            upstream (BladeRow): Upstream blade row
+            row (BladeRow): downstream blade row
+
+        Returns:
+            float: Stage Efficiency
+        """
+        if row.row_type == RowType.Stator:
+            return 0
+        else:
+            return self.efficiency
+        

turbodesign/loss/turbine/fixedpressureloss.py

@@ -0,0 +1,25 @@
+from ...bladerow import BladeRow
+from ..losstype import LossBaseClass
+from ...enums import LossType
+
+class FixedPressureLoss(LossBaseClass):
+    pressure_loss:float
+    
+    def __init__(self,pressure_loss:float):
+        """Fixed Pressure Loss
+        """
+        super().__init__(LossType.Pressure)
+        self.pressure_loss = pressure_loss
+    
+    
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """Outputs the fixed Pressure Loss
+        
+        Args:
+            upstream (BladeRow): Upstream blade row
+            row (BladeRow): downstream blade row
+
+        Returns:
+            float: Pressure Loss 
+        """
+        return self.pressure_loss

turbodesign/loss/turbine/kackerokapuu.py

@@ -0,0 +1,124 @@
+import pickle, os
+from typing import Dict
+from ...bladerow import BladeRow, sutherland
+from ...lossinterp import LossInterp
+from ...enums import RowType, LossType
+import numpy as np
+import pathlib
+from ..losstype import LossBaseClass
+
+class KrackerOkapuu(LossBaseClass):
+
+    def __init__(self):
+        """KackerOkapuu model is an improvement to the Ainley Mathieson model. 
+        
+        Limitations:
+            - Doesn't factor incidence loss 
+            - For steam turbines and impulse turbines
+            
+        Reference:
+            Kacker, S. C., and U. Okapuu. "A mean line prediction method for axial flow turbine efficiency." (1982): 111-119.
+            
+        """
+        super().__init__(LossType.Pressure)
+        path = pathlib.Path(os.path.join(os.environ['TD3_HOME'],"kackerokapuu"+".pkl"))
+        
+        if not path.exists():
+            print('Download file if doesn\'t exist')    
+        
+        with open(path.absolute(),'rb') as f:
+            self.data = pickle.load(f) # type: ignore
+    
+        
+    
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """Kacker Okapuu is an updated version of Ainley Mathieson and Dunham Came. This tool uses the pressure loss definition. 
+
+        Note: 
+            All equation numbers are from the Kacker Okapuu paper
+        
+        Reference:
+            Kacker, S. C., and U. Okapuu. "A mean line prediction method for axial flow turbine efficiency." (1982): 111-119.
+        
+        Args:
+            upstream (BladeRow): Upstream blade row
+            row (BladeRow): downstream blade row
+
+        Returns:
+            float: Pressure Loss 
+        """
+        if upstream.row_type == RowType.Stator:
+            M1 = upstream.M
+        else:
+            M1 = upstream.M_rel 
+        
+        c = row.chord
+        b = row.axial_chord
+        if row.row_type == RowType.Stator:
+            alpha1 = np.degrees(row.alpha1)
+            beta1 = np.degrees(row.beta1_metal)
+            alpha2 = np.degrees(row.alpha2)
+            M2 = row.M
+            h = 0
+            Rec = row.V*row.rho*row.chord / sutherland(row.T)
+        else:
+            h = row.tip_clearance * (row.r[-1]-row.r[0])
+            alpha1 = np.degrees(row.beta1)
+            beta1 = row.beta1_metal 
+            alpha2 = np.degrees(row.beta2)
+            M2 = row.M_rel
+            Rec = row.W*row.rho*row.chord / sutherland(row.T)
+            
+        Yp_beta0 = self.data['Fig01'](row.pitch_to_chord, alpha2)
+        Yp_beta1_alpha2 = self.data['Fig02'](row.pitch_to_chord, alpha2)
+        t_max_c = self.data['Fig04'](np.abs(beta1)+np.abs(alpha2))
+        
+        Yp_amdc = (Yp_beta0 + np.abs(beta1/alpha2) *beta1/alpha2 * (Yp_beta1_alpha2-Yp_beta0)) * ((t_max_c)/0.2)**(beta1/alpha2) # Eqn 2, AMDC = Ainley Mathieson Dunham Came
+        
+        # Shock Loss
+        dP_q1_hub = 0.75*(M1-0.4)**1.75 # Eqn 4, this is at the hub
+        dP_q1_shock = row.r[-1]/row.r[0] * dP_q1_hub # Eqn 5
+        Y_shock = dP_q1_shock * upstream.P/row.P * (1-(1+(upstream.gamma-1)/2*M1**2))/(1-(1+(row.gamma-1)/2*M2**2)) # Eqn 6
+        
+        K1 = self.data['Fig08_K1'](M2)
+        K2 = (M1/M2)**2 
+        Kp = 1-K2*(1-K1)
+        
+        CFM = 1+60*(M2-1)**2    # Eqn 9 
+        
+        Yp = 0.914 * (2/3*Yp_amdc *Kp + Y_shock) # Eqn 8 Subsonic regime 
+        if M2>1:
+            Yp = Yp*CFM
+        
+        f_ar = (1-0.25*np.sqrt(2-h/c)) / (h/c) if h/c<=2 else 1/(h/c)
+        alpham = np.arctan(0.5*(np.tan(alpha1) - np.tan(alpha2)))
+        Cl_sc = 2*(np.tan(alpha1)+np.tan(alpha2))*np.cos(alpham)
+        Ys_amdc = 0.0334 *f_ar *np.cos(alpha2)/np.cos(beta1) * (Cl_sc)**2 * np.cos(alpha2)**2 / np.cos(alpham)**3
+        # Secondary Loss 
+        K3 = 1/(h/(b))**2     # Fig 13, it's actually bx in the picture which is the axial chord
+        Ks = 1-K3*(1-Kp)        # Eqn 15
+        Ys = 1.2*Ys_amdc*Ks     # Eqn 16
+        
+        # Trailing Edge
+        if np.abs(alpha1-alpha2)<5:
+            delta_phi2 = self.data['Fig14_Impulse'](row.te_pitch*row.pitch / row.throat)
+        else:
+            delta_phi2 = self.data['Fig14_Axial_Entry'](row.te_pitch*row.pitch / row.throat)
+        
+        Ytet = (1-(row.gamma-1)/2 - M2**2 * (1/(1-delta_phi2)-1))**(-row.gamma/(row.gamma-1))-1
+        Ytet = Ytet / (1-(1+(row.gamma-1)/2*M2**2)**(-row.gamma/(row.gamma-1)))
+        
+        # Tip Clearance
+        kprime = row.tip_clearance/(3)**0.42 # Number of seals 
+        Ytc = 0.37*c/h * (kprime/c)**0.78 * Cl_sc**2 * np.cos(alpha2)**2 / np.cos(alpham)**3
+        
+        if Rec <= 2E5:
+            f_re = (Rec/2E5)**-0.4 
+        elif Rec<1E6:
+            f_re = 1 
+        else:
+            f_re = (Rec/1E6)**-0.2
+        
+        Yt = Yp*f_re + Ys + Ytet + Ytc 
+        return Yt
+        

turbodesign/loss/turbine/traupel.py

@@ -0,0 +1,95 @@
+import pickle, os
+from typing import Dict
+from ...bladerow import BladeRow, sutherland
+from ...lossinterp import LossInterp
+from ...enums import RowType, LossType
+import numpy as np
+import pathlib
+from ..losstype import LossBaseClass
+
+class Traupel(LossBaseClass):
+    def __init__(self):
+        super().__init__(LossType.Enthalpy)
+        path = pathlib.Path(os.path.join(os.environ['TD3_HOME'],"traupel"+".pkl"))
+
+        if not path.exists():
+            print('Download file if doesn\'t exist')    
+        
+        with open(path.absolute(),'rb') as f:
+            self.data = pickle.load(f) # type: ignore
+        
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """Enthalpy loss is computed for the entire stage. 
+
+        Args:
+            upstream (BladeRow): Stator Row
+            row (BladeRow): Rotor Row
+
+        Returns:
+            float: Efficiency
+        """
+        
+        alpha1 = 90-np.degrees(upstream.alpha1.mean())
+        alpha2 = 90-np.degrees(upstream.alpha2.mean())
+        beta2 = 90 - np.degrees(row.beta1.mean())
+        beta3 = 90 - np.degrees(row.beta2.mean())
+            
+        g = upstream.pitch # G is the pitch 
+        h_stator = upstream.r[-1] - upstream.r[0]
+        h_rotor = row.r[-1] - row.r[0]
+
+        if row.row_type == RowType.Rotor:
+            turning = np.abs(np.degrees(upstream.beta2-row.beta2).mean())
+            F = self.data['Fig06']((upstream.W/row.W).mean(),turning) # Inlet velocity
+        else:
+            turning = np.abs(np.degrees(upstream.alpha2-row.alpha2).mean())
+            F = self.data['Fig06']((upstream.V/row.V).mean(),turning) # Inlet velocity
+
+        H = self.data['Fig07'](alpha1-beta2,alpha2-beta3)
+        
+        zeta_s = F*g/h_stator  # (h1-h1s)/(0.5*c1s**2) # no idea what h1s or h2s is
+        zeta_r = F*g/h_rotor # (h2-h2s)/(0.5*w2s**2)
+        x_p_stator = self.data['Fig01'](alpha1,alpha2) # not sure if this is the right figure
+        x_p_rotor = self.data['Fig01'](beta2,beta3) # not sure if this is the right figure
+        zeta_p_stator = self.data['Fig02'](alpha1,alpha2)
+        x_m_stator = self.data['Fig03_0'](upstream.M)
+        zeta_p_rotor = self.data['Fig02'](beta2,beta3)
+        x_m_rotor = self.data['Fig03_0'](row.M_rel)
+        
+        
+        e_te = upstream.te_pitch * g
+        o = upstream.throat 
+        ssen_alpha2 = e_te/o # Thickness of Trailing edge divide by throat 
+        ssen_beta2 = row.te_pitch*g / row.throat
+        
+        x_delta_stator = self.data['Fig05'](ssen_alpha2,alpha2)
+        zeta_delta_stator = self.data['Fig04'](ssen_alpha2,alpha2)
+        x_delta_rotor = self.data['Fig05'](ssen_beta2,beta3)
+        zeta_delta_rotor = self.data['Fig04'](ssen_beta2,beta3)
+        
+        Dm = 2* (upstream.r[-1] + upstream.r[0])/2 # Is this the mean diameter? I dont know
+        zeta_f = 0.5 * (h_stator/Dm)**2
+        
+        zeta_pr_stator = zeta_p_stator * x_p_stator * x_m_stator * x_delta_stator + zeta_delta_stator + zeta_f
+        
+        Dm = 2* (row.r[-1] + row.r[0])/2 # Is this the mean diameter? I dont know
+        zeta_f = 0.5 * (h_rotor/Dm)**2
+        
+        zeta_pr_rotor = zeta_p_rotor * x_p_rotor * x_m_rotor * x_delta_rotor + zeta_delta_rotor + zeta_f
+        
+        if row.row_type == RowType.Stator:
+            zeta_cl = 0 
+        else:
+            zeta_cl = self.data['Fig08'](row.tip_clearance) # For simplicity assume unshrouded blade 
+            
+        zeta_z = 0 # Do not factor this in, a bit complicated
+        # 1 - (internal) - (external) 
+        zeta_v = 0 
+        zeta_off = 0 
+        eta_stator = 1- (zeta_pr_stator + zeta_s + 0 + zeta_z) - (zeta_r+zeta_v) - zeta_off # Presentation slide 9
+        eta_rotor = 1 - (zeta_pr_rotor + zeta_r + zeta_cl + zeta_z) - (zeta_r+zeta_v) - zeta_off
+        return eta_stator+eta_rotor
+        
+        
+        
+        

turbodesign/lossinterp.py

@@ -0,0 +1,178 @@
+from typing import List, Tuple, Union
+import pandas as pd 
+import numpy as np 
+import numpy.typing as npt
+from scipy.interpolate import bisplrep, bisplev, interp1d, LSQBivariateSpline
+import matplotlib.pyplot as plt 
+
+
+class LossInterp:
+    """Interpret the loss of an XY Graph with an additional 3rd variable 
+    """
+    df: pd.DataFrame
+    x:np.ndarray
+    y:np.ndarray
+    c:np.ndarray    
+
+    x_max_c:np.ndarray
+    x_min_c:np.ndarray
+    
+    c_max:float
+    c_min:float
+
+    fxc_max: interp1d
+    fxc_min: interp1d
+
+    weights: np.ndarray
+    xlabel:str
+    ylabel:str
+    clabel:str
+    _name:str 
+
+    is_xy:bool
+    func: interp1d
+    
+    xlogscale:bool
+    
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self,val:str):
+        self._name = val 
+
+    def __init__(self,csv_filename:str,xlabel:str="",ylabel:str="",clabel:str="",logx10:bool=False):
+        """Initialize the loss interpolation with data
+
+        Note:
+            The data contains x,y, and c. Y is predicted from x and c
+        Args:
+            csv_filename (str): csv data with 3 columns, x,y,c.
+            xlabel (str, optional): xlabel. Defaults to "".
+            ylabel (str, optional): ylabel. Defaults to "".
+            clabel (str, optional): clabel. Defaults to "".
+            logx10 (bool, optional): apply log base 10 to x axis. Defaults to False
+        """
+        self.df = pd.read_csv(csv_filename)
+        self.df = self.df.sort_values(self.df.columns[0],ascending=True)
+        self.name = csv_filename
+        data = self.df.to_numpy()
+        self.xlabel = xlabel
+        self.ylabel = ylabel
+        self.logX10 = logx10
+        if data.shape[1] == 3:    
+            self.x = data[:,0]
+            self.y = data[:,1]
+            self.c = data[:,2]
+            
+            self.clabel = clabel
+            
+            # Find the minimum x value for every item in row
+            self.x_max_c = np.zeros(shape=(len(self.df.iloc[:,2].unique()),2))
+            self.x_min_c = np.zeros(shape=(len(self.df.iloc[:,2].unique()),2))
+
+            i = 0 
+            for inlet_flow in self.df.iloc[:,2].unique():
+                df_slice = self.df[self.df.iloc[:,2] == inlet_flow]
+                df_slice = df_slice.sort_values(df_slice.columns[0],ascending=True)
+                self.x_max_c[i,0] = inlet_flow
+                self.x_max_c[i,1] = df_slice.iloc[:,0].max()
+                
+                self.x_min_c[i,0] = inlet_flow
+                self.x_min_c[i,1] = df_slice.iloc[:,0].min()
+                i+=1 
+            self.fxc_max = interp1d(self.x_max_c[:,0],self.x_max_c[:,1]) # xmax as a function of c
+            self.fxc_min = interp1d(self.x_min_c[:,0],self.x_min_c[:,1]) # xmin as a function of c
+
+            # self.weights = bisplrep(self.x,self.c,self.y,kx=5, ky=5)
+            if self.logX10:
+                self.func = LSQBivariateSpline(np.log10(self.x),self.c,self.y,np.log10(np.unique(self.x[:4])),np.unique(self.c[:4]))
+            else:
+                self.func = LSQBivariateSpline(self.x,self.c,self.y,np.unique(self.x[:3]),np.unique(self.c[:3]))
+            self.is_xy = False # 3 columns
+            self.c_max = self.df.to_numpy()[:,-1].max()
+            self.c_min = self.df.to_numpy()[:,-1].min()
+        else:
+            self.is_xy = True
+            self.x = data[:,0]
+            self.y = data[:,1]
+            if self.logX10:
+                self.func = interp1d(np.log10(self.x),self.y)
+            else:
+                self.func = interp1d(self.x,self.y)
+
+    def __call__(self,x:Union[npt.NDArray,float],c:Union[npt.NDArray,float,None]=None) -> float:
+        """Pass in an array of x and c values
+
+        Args:
+            x (Union[npt.NDArray,float]): value on x axis 
+            c (Union[npt.NDArray,float,None]): Third axis value
+
+        Returns:
+            float: y
+        """
+            
+        if self.is_xy or c==None:
+            if self.logX10:
+                x = np.log10(x)
+            if isinstance(x, np.ndarray):
+                return self.func(x)
+            elif isinstance(x, float):
+                return float(self.func(x))
+        else:
+            if isinstance(x, np.ndarray):
+                xmax = self.fxc_max(c)
+                xmin = self.fxc_min(c)
+                x[x>xmax] = xmax
+                x[x<xmin] = xmin
+                if self.logX10:
+                    y = self.func(np.log10(x),c)
+                else:
+                    y = self.func(x,c)
+            elif isinstance(x, float):
+                if (c>self.c_max):
+                    c = self.c_max
+                elif c<self.c_min:
+                    c = self.c_min
+                xmax = float(self.fxc_max(c))
+                xmin = float(self.fxc_min(c))
+                x = xmin if x<xmin else x
+                x = xmax if x>xmax else x
+                # y[j] = bisplev(x[j],cc,self.weights)
+                if self.logX10:
+                    y = self.func(np.log10(x),c)[0][0] # type: ignore
+                else:
+                    y = self.func(x,c)[0][0] # type: ignore
+        return y
+    
+    def plot(self):
+        """Plot the data with predicted values
+        """
+        plt.figure(num=1,figsize=(10,6)) 
+        if not self.is_xy:
+            c_unique = np.unique(self.c)
+            graycolors = plt.cm.gray(np.linspace(0,1,len(c_unique)))
+            coolcolors = plt.cm.cool(np.linspace(0,1,len(c_unique)))
+
+        
+            # Plot the actual data 
+            i = 0
+            for c in c_unique:
+                df2 = self.df[self.df.iloc[:,2] == c]
+                x = df2.iloc[:,0].to_numpy()
+                plt.plot(x,df2.iloc[:,1],'.-',label=f'{c}',color=graycolors[i])
+                y = self(x,c)
+                plt.plot(x,y,'o-',label=f'predicted-{c}',color=coolcolors[i])
+                i+=1
+        else:
+            x = self.df.iloc[:,0].to_numpy()            
+            plt.plot(x,self.df.iloc[:,1],'ro',linewidth=2,label='actual')
+            y = self(x)
+            plt.plot(x,y,'b-',label='predicted')
+            
+        plt.ylabel(self.ylabel)
+        plt.xlabel(self.xlabel)
+        plt.title(self.name)
+        plt.legend()
+        plt.show()