//  [python]
def fun_LUTplot(self):
    #=================================plot OCV    
        plt.figure()
        if self.status_LUTinterp=='Interp':
            SoC=np.linspace(-0.1, 1.1, 100);   T=np.linspace(self.LUT_T[1,0]-self.LUT_T[1,0]/100, self.LUT_T[-2,0]+self.LUT_T[-2,0]/100, 100)
            X,Y = np.meshgrid(SoC,T)
            f = interpolate.interp2d(self.LUT_SoC[1:-1], self.LUT_T[1:-1], self.LUT_OCV_PerA[1:-1,1:-1,0], kind=self.status_scipy_interpkind)
            OCV=f(SoC,T)
            if self.status_scipy_interpkind != 'linear':                              #Saturation is used when cubic interpolation is used. Because runge phenomenon may happen causing minus or unreasonably high value
                OCV[OCV < self.LUT_OCV_Cell_min]=self.LUT_OCV_Cell_min; OCV[OCV > self.LUT_OCV_Cell_max]=self.LUT_OCV_Cell_max;                            #saturation condition, out-of-range value (especially minus) is not physical
        if self.status_LUTinterp=='Fitting':
            SoC=np.linspace(self.LUT_SoC[-2], self.LUT_SoC[1], 100);   T=np.linspace(self.LUT_T[1], self.LUT_T[-2], 100)
            X,Y = np.meshgrid(SoC,T)
            OCV=self.fun_OCV_Fitted(X,Y)
        ax = plt.axes(projection='3d')
        ax.plot_surface(X, Y, OCV, rstride=1, cstride=1,cmap='winter', edgecolor='none',alpha=0.5)          #plot interpolated or fitted surface
        
        X_LUT,Y_LUT = np.meshgrid(self.LUT_SoC[1:-1],self.LUT_T[1:-1])
        x= X_LUT.reshape(-1); y=Y_LUT.reshape(-1); z=self.LUT_OCV_PerA[1:-1,1:-1,0].reshape(-1) 
        ax.scatter3D(x, y, z,color='r',depthshade=False)                                                    #plot raw LUT scattered points
        
        ax.set_xlabel('SoC'); ax.set_ylabel('Temperature [K]'); ax.set_zlabel('OCV [V]')
        if self.status_LUTinterp=='Interp':
            ax.set_title('%s cell OCV Interpolation, kind=%s'%(self.status_Eparam,self.status_scipy_interpkind))
        if self.status_LUTinterp=='Fitting':
            ax.set_title('%s cell OCV Fitting'%(self.status_Eparam))
    #=================================plot R0    
        plt.figure()
        if self.status_LUTinterp=='Interp':
            SoC=np.linspace(-0.1, 1.1, 100);   T=np.linspace(self.LUT_T[1,0]-self.LUT_T[1,0]/100, self.LUT_T[-2,0]+self.LUT_T[-2,0]/100, 100)
            X,Y = np.meshgrid(SoC,T)
            f = interpolate.interp2d(self.LUT_SoC[1:-1], self.LUT_T[1:-1], self.LUT_R0_PerA[1:-1,1:-1,0], kind=self.status_scipy_interpkind)
            R0=f(SoC,T)
            if self.status_scipy_interpkind != 'linear':                              #Saturation is used when cubic interpolation is used. Because runge phenomenon may happen causing minus or unreasonably high value
                R0[R0 < self.LUT_R0_PerA_min]=self.LUT_R0_PerA_min; R0[R0 > self.LUT_R0_PerA_max]=self.LUT_R0_PerA_max;                                   #saturation condition, out-of-range value (especially minus) is not physical
        if self.status_LUTinterp=='Fitting':
            SoC=np.linspace(self.LUT_SoC[-2], self.LUT_SoC[1], 100);   T=np.linspace(self.LUT_T[1], self.LUT_T[-2], 100)
            X,Y = np.meshgrid(SoC,T)
            R0=self.fun_R0_Fitted(X,Y)
        ax = plt.axes(projection='3d')
        ax.plot_surface(X, Y, R0, rstride=1, cstride=1,cmap='winter', edgecolor='none',alpha=0.5)   #plot interpolated or fitted surface
       
        X_LUT,Y_LUT = np.meshgrid(self.LUT_SoC[1:-1],self.LUT_T[1:-1])
        x= X_LUT.reshape(-1); y=Y_LUT.reshape(-1); z=self.LUT_R0_PerA[1:-1,1:-1,0].reshape(-1) 
        ax.scatter3D(x, y, z,color='r',depthshade=False)                                                    #plot raw LUT scattered points
        
        ax.set_xlabel('SoC'); ax.set_ylabel('Temperature [K]'); ax.set_zlabel('R0\n for unit area for element\n[Ω·m2]')
        if self.status_LUTinterp=='Interp':
            ax.set_title('%s cell R0 Interpolation, kind=%s'%(self.status_Eparam,self.status_scipy_interpkind))
        if self.status_LUTinterp=='Fitting':
            ax.set_title('%s cell R0 Fitting'%(self.status_Eparam))
    #=================================plot Ri       
        for i0 in np.arange(self.nRC):
            plt.figure()
            if self.status_LUTinterp=='Interp':
                SoC=np.linspace(-0.1, 1.1, 100);   T=np.linspace(self.LUT_T[1,0]-self.LUT_T[1,0]/100, self.LUT_T[-2,0]+self.LUT_T[-2,0]/100, 100)
                X,Y = np.meshgrid(SoC,T)
                f = interpolate.interp2d(self.LUT_SoC[1:-1], self.LUT_T[1:-1], self.LUT_Ri_PerA[1:-1,1:-1,i0], kind=self.status_scipy_interpkind)
                Ri=f(SoC,T)
                if self.status_scipy_interpkind != 'linear':                              #Saturation is used when cubic interpolation is used. Because runge phenomenon may happen causing minus or unreasonably high value
                    Ri[Ri < self.LUT_Ri_PerA_min[i0]]=self.LUT_Ri_PerA_min[i0]; Ri[Ri > self.LUT_Ri_PerA_max[i0]]=self.LUT_Ri_PerA_max[i0];                                   #saturation condition, out-of-range value (especially minus) is not physical
            if self.status_LUTinterp=='Fitting':
                SoC=np.linspace(self.LUT_SoC[-2], self.LUT_SoC[1], 100);   T=np.linspace(self.LUT_T[1], self.LUT_T[-2], 100)
                X,Y = np.meshgrid(SoC,T)
                X_scaled=X;          Y_scaled=(Y-self.LUT_T_min)/(self.LUT_T_max-self.LUT_T_min)
                if i0 == 0:
                    Ri_scaled=self.fun_R1_fitted_scaled_expression_Cell(X_scaled,Y_scaled)
                    Ri_scaled[Ri_scaled < 0]=0; Ri_scaled[Ri_scaled > 1]=1                #Saturation used
                    Ri= Ri_scaled*(self.LUT_Ri_Cell_max[0]-self.LUT_Ri_Cell_min[0])+self.LUT_Ri_Cell_min[0]
                elif i0 == 1:
                    Ri_scaled=self.fun_R2_fitted_scaled_expression_Cell(X_scaled,Y_scaled)
                    Ri_scaled[Ri_scaled < 0]=0; Ri_scaled[Ri_scaled > 1]=1                #Saturation used
                    Ri= Ri_scaled*(self.LUT_Ri_Cell_max[1]-self.LUT_Ri_Cell_min[1])+self.LUT_Ri_Cell_min[1]
                else:
                    Ri_scaled=self.fun_R3_fitted_scaled_expression_Cell(X_scaled,Y_scaled)
                    Ri_scaled[Ri_scaled < 0]=0; Ri_scaled[Ri_scaled > 1]=1                #Saturation used
                    Ri= Ri_scaled*(self.LUT_Ri_Cell_max[2]-self.LUT_Ri_Cell_min[2])+self.LUT_Ri_Cell_min[2]
                Ri=Ri *self.A_electrodes_real
                Ri=Ri/self.scalefactor_z
            ax = plt.axes(projection='3d')
            ax.plot_surface(X, Y, Ri, rstride=1, cstride=1,cmap='winter', edgecolor='none',alpha=0.5)           #plot interpolated or fitted surface
       
            X_LUT,Y_LUT = np.meshgrid(self.LUT_SoC[1:-1],self.LUT_T[1:-1])
            x= X_LUT.reshape(-1); y=Y_LUT.reshape(-1); z=self.LUT_Ri_PerA[1:-1,1:-1,i0].reshape(-1) 
            ax.scatter3D(x, y, z,color='r',depthshade=False)                                                    #plot raw LUT scattered points
        
            ax.set_xlabel('SoC'); ax.set_ylabel('Temperature [K]'); ax.set_zlabel('R%d\n for unit area for element\n[Ω·m2]'%(i0+1))
            if self.status_LUTinterp=='Interp':
                ax.set_title('%s cell R%d Interpolation, kind=%s'%(self.status_Eparam,i0+1,self.status_scipy_interpkind))
            if self.status_LUTinterp=='Fitting':
                ax.set_title('%s cell R%d Fitting'%(self.status_Eparam,i0+1))
    #=================================plot Ci       
        for i0 in np.arange(self.nRC):
            plt.figure()
            if self.status_LUTinterp=='Interp':
                SoC=np.linspace(-0.1, 1.1, 100);   T=np.linspace(self.LUT_T[1,0]-self.LUT_T[1,0]/100, self.LUT_T[-2,0]+self.LUT_T[-2,0]/100, 100)
                X,Y = np.meshgrid(SoC,T)
                f = interpolate.interp2d(self.LUT_SoC[1:-1], self.LUT_T[1:-1], self.LUT_Ci_PerA[1:-1,1:-1,i0], kind=self.status_scipy_interpkind)
                Ci=f(SoC,T)
                if self.status_scipy_interpkind != 'linear':                              #Saturation is used when cubic interpolation is used. Because runge phenomenon may happen causing minus or unreasonably high value
                    Ci[Ci < self.LUT_Ci_PerA_min[i0]]=self.LUT_Ci_PerA_min[i0]; Ci[Ci > self.LUT_Ci_PerA_max[i0]]=self.LUT_Ci_PerA_max[i0];                                   #saturation condition, out-of-range value (especially minus) is not physical
            if self.status_LUTinterp=='Fitting':
                SoC=np.linspace(self.LUT_SoC[-2], self.LUT_SoC[1], 100);   T=np.linspace(self.LUT_T[1], self.LUT_T[-2], 100)
                X,Y = np.meshgrid(SoC,T)
                X_scaled=X;          Y_scaled=(Y-self.LUT_T_min)/(self.LUT_T_max-self.LUT_T_min)
                if i0 == 0:
                    Ri_scaled_Cell=self.fun_R1_fitted_scaled_expression_Cell(X_scaled,Y_scaled)
                    Ri_Cell= Ri_scaled_Cell*(self.LUT_Ri_Cell_max[0]-self.LUT_Ri_Cell_min[0])+self.LUT_Ri_Cell_min[0]
                    Ci_Cell=self.fun_R1C1_fitted_unscaled_expression_Cell(X_scaled,Y_scaled)/Ri_Cell
                    Ci_Cell[Ci_Cell < self.LUT_Ci_Cell_min[0]]=self.LUT_Ci_Cell_min[0]; Ci_Cell[Ci_Cell > self.LUT_Ci_Cell_max[0]]=self.LUT_Ci_Cell_max[0]                        #Saturation used
                elif i0 == 1:
                    Ri_scaled_Cell=self.fun_R2_fitted_scaled_expression_Cell(X_scaled,Y_scaled)
                    Ri_Cell= Ri_scaled_Cell*(self.LUT_Ri_Cell_max[1]-self.LUT_Ri_Cell_min[1])+self.LUT_Ri_Cell_min[1]
                    Ci_Cell=self.fun_R2C2_fitted_unscaled_expression_Cell(X_scaled,Y_scaled)/Ri_Cell
                    Ci_Cell[Ci_Cell < self.LUT_Ci_Cell_min[1]]=self.LUT_Ci_Cell_min[1]; Ci_Cell[Ci_Cell > self.LUT_Ci_Cell_max[1]]=self.LUT_Ci_Cell_max[1]                        #Saturation used
                else:
                    Ri_scaled_Cell=self.fun_R3_fitted_scaled_expression_Cell(X_scaled,Y_scaled)
                    Ri_Cell= Ri_scaled_Cell*(self.LUT_Ri_Cell_max[2]-self.LUT_Ri_Cell_min[2])+self.LUT_Ri_Cell_min[2]
                    Ci_Cell=self.fun_R3C3_fitted_unscaled_expression_Cell(X_scaled,Y_scaled)/Ri_Cell
                    Ci_Cell[Ci_Cell < self.LUT_Ci_Cell_min[2]]=self.LUT_Ci_Cell_min[2]; Ci_Cell[Ci_Cell > self.LUT_Ci_Cell_max[2]]=self.LUT_Ci_Cell_max[2]                        #Saturation used
                Ci=Ci_Cell /self.A_electrodes_real
                Ci=Ci*self.scalefactor_z
            ax = plt.axes(projection='3d')
            ax.plot_surface(X, Y, Ci, rstride=1, cstride=1,cmap='winter', edgecolor='none',alpha=0.5)           #plot interpolated or fitted surface
       
            X_LUT,Y_LUT = np.meshgrid(self.LUT_SoC[1:-1],self.LUT_T[1:-1])
            x= X_LUT.reshape(-1); y=Y_LUT.reshape(-1); z=self.LUT_Ci_PerA[1:-1,1:-1,i0].reshape(-1) 
            ax.scatter3D(x, y, z,color='r',depthshade=False)                                                    #plot raw LUT scattered points
        
            ax.set_xlabel('SoC'); ax.set_ylabel('Temperature [K]'); ax.set_zlabel('C%d\n for unit area for element\n[F/m2]'%(i0+1))
            if self.status_LUTinterp=='Interp':
                ax.set_title('%s cell C%d Interpolation, kind=%s'%(self.status_Eparam,i0+1,self.status_scipy_interpkind))
            if self.status_LUTinterp=='Fitting':
                ax.set_title('%s cell C%d Fitting'%(self.status_Eparam,i0+1))
    #=================================plot dVdT       
        plt.figure()
        if self.status_LUTinterp=='Interp':
            SoC=np.linspace(-0.1, 1.1, 100)
            f = interpolate.interp1d(self.LUT_SoC_entropy.reshape(-1), self.LUT_dVdT_PerA.reshape(-1), kind=self.status_scipy_interpkind)
            dVdT=f(SoC)
            if self.status_scipy_interpkind != 'linear':                              #Saturation is used when cubic interpolation is used. Because runge phenomenon may happen causing minus or unreasonably high value
                dVdT[dVdT < self.LUT_dVdT_Cell_min]=self.LUT_dVdT_Cell_min; dVdT[dVdT > self.LUT_dVdT_Cell_max]=self.LUT_dVdT_Cell_max                                   #saturation condition, out-of-range value (especially minus) is not physical
        if self.status_LUTinterp=='Fitting':
            SoC=np.linspace(self.LUT_SoC_entropy[-2], self.LUT_SoC_entropy[1], 100)
            dVdT=self.fun_dVdT_Fitted(SoC)
        plt.plot(SoC,dVdT,'b')                                                                               #plot interpolated or fitted curve
        plt.plot(self.LUT_SoC_entropy[1:-1],self.LUT_dVdT_PerA[1:-1],'ro')                                                    #plot raw LUT scattered points
        plt.xlabel('SoC'); plt.ylabel('dV/dT [V/K]') 
        if self.status_LUTinterp=='Interp':
            plt.title('Pouch_Cell1 cell dV/dT %s, kind=%s'%(self.status_LUTinterp,self.status_scipy_interpkind))
        if self.status_LUTinterp=='Fitting':
            plt.title('Pouch_Cell1 cell dV/dT Fitting')