'''Chemical Engineering Design Library (ChEDL). Utilities for process modeling. Copyright (C) 2018 Caleb Bell Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ''' import os from math import log10 import numpy as np import pytest from numpy.testing import assert_allclose from scipy.interpolate import RectBivariateSpline, UnivariateSpline, bisplev, bisplrep, splev, splrep from scipy.optimize import fsolve, newton from fluids import fluids_data_dir from fluids.core import Engauge_2d_parser from fluids.optional.pychebfun import chebfun, chebfun_to_poly ### Contractions def test_contraction_conical_Miller_coefficients(): from fluids.fittings import contraction_conical_Miller_tck path = os.path.join(fluids_data_dir, 'Miller 2E 1990 conical contractions K part 1.csv') Kds, l_ratios, A_ratios = Engauge_2d_parser(open(path).readlines()) path = os.path.join(fluids_data_dir, 'Miller 2E 1990 conical contractions K part 2.csv') Kd2, l_ratio2, A_ratio2 = Engauge_2d_parser(open(path).readlines()) Kds.extend(Kd2) l_ratios.extend(l_ratio2) A_ratios.extend(A_ratio2) A_ratios = [[i+1.0 for i in j] for j in A_ratios] # # The second set of data obviously looks terirble when plotted # # Normally the data should be smoothed, but, well, the smoothing # # function also requires smooth functions. # for K, ls, As in zip(Kds, l_ratios, A_ratios): # plt.loglog(ls, np.array(As)-1, label=str(K)) # plt.legend() # plt.show() all_zs = [] all_xs = [] all_ys = [] for z, xs, ys in zip(Kds, l_ratios, A_ratios): for x, y in zip(xs, ys): all_zs.append(z) all_xs.append(x) all_ys.append(y) tck = bisplrep(np.log(all_xs), np.log(all_ys), all_zs, kx=3, ky=1, s=.0001) [assert_allclose(i, j) for i, j in zip(contraction_conical_Miller_tck, tck)] # err = 0.0 # n = 0 # for z, xs, ys in zip(Kds, l_ratios, A_ratios): # for x, y in zip(xs, ys): # predict = bisplev(log(x), log(y), tck) # err += abs(predict - z)/z # n += 1 # 5% relative error seems like the sweetspot # print(err/n, n, err) # import matplotlib.pyplot as plt # ax = plt.gca() # ax.set_xscale("log") # ax.set_yscale("log") # x = np.logspace(np.log10(.1), np.log10(10), 200) # y = np.logspace(np.log10(1.1), np.log10(4), 200) # X, Y = np.meshgrid(x, y, indexing='ij') # func = np.vectorize(lambda x, y: max(min(bisplev(log(x), log(y), tck), .5), 0)) # # Z = func(X.ravel(), Y.ravel()) # Z = [[func(xi, yi) for yi in y.tolist()] for xi in x] # # levels = [.001, .01, .03, .04, .05, .1, .2, .3, .4] # plt.contourf(X, Y-1, Z, levels=levels, cmap='RdGy') # plt.colorbar() # plt.show() @pytest.mark.slow def test_contraction_abrupt_Miller_coefficients(): from fluids.fittings import tck_contraction_abrupt_Miller curve_path = os.path.join(fluids_data_dir, 'Miller 2E 1990 abrupt contraction K.csv') text = open(curve_path).readlines() zs, x_lists, y_lists = Engauge_2d_parser(text) for xs, values in zip(x_lists, y_lists): values[-1] = 0 low = 1e-8 for i in range(2): low = low/10 values.insert(-1, low) xs.insert(-1, 1-low) xs[-1] = 1 inter_objs = [] for rd, As, Ks in zip(zs, x_lists, y_lists): univar = UnivariateSpline(As, Ks, s=1e-5) inter_objs.append(univar) # make a rectangular grid As = np.linspace(0, 1, 1000) Ks_stored = [] for obj in inter_objs: Ks_smoothed = obj(As) Ks_smoothed[Ks_smoothed < 0] = 0 # Avoid zeros Ks_stored.append(Ks_smoothed) # Flatten the data to the form used in creating the spline all_zs = [] all_xs = [] all_ys = [] for z, x, ys in zip(zs, As, Ks_stored): for x, y in zip(As, ys): all_zs.append(z) all_xs.append(x) all_ys.append(y) tck_recalc = bisplrep(all_xs, all_zs, all_ys, s=5e-4) [assert_allclose(i, j, rtol=1e-2) for i, j in zip(tck_contraction_abrupt_Miller, tck_recalc)] # Plotting code # print([i.tolist() for i in tck[:3]]) # for i, (rd, As, Ks) in enumerate(zip(zs, x_lists, y_lists)): # plt.plot(As, Ks, '.') # univar = inter_objs[i] # As2 = np.linspace(0, 1, 1000) # Ks_smoothed = univar(As2) # plt.plot(As2, Ks_smoothed) # # Compute with the spline # Ks_new = bisplev(As2, rd, tck) # plt.plot(As2, Ks_new) # for rd in np.linspace(.1, 0, 100): # As2 = np.linspace(0, 1, 1000) # Ks_new = bisplev(As2, rd, tck) # plt.plot(As2, Ks_new) # plt.show() ### Diffusers @pytest.mark.slow def test_diffuser_conical_Miller_coefficients(): from fluids.fittings import tck_diffuser_conical_Miller path = os.path.join(fluids_data_dir, 'Miller 2E 1990 conical diffuser Kd.csv') Kds, l_ratios, A_ratios = Engauge_2d_parser(open(path).readlines()) # Fixup stupidity A_ratios = [[i+1.0 for i in j] for j in A_ratios] # for K, ls, As in zip(Kds, l_ratios, A_ratios): # plt.loglog(ls, np.array(As)-1) # plt.show() interp_objs = [] for K, ls, As in zip(Kds, l_ratios, A_ratios): univar = UnivariateSpline(np.log10(ls), np.log10(As), s=4e-5) interp_objs.append(univar) # Extrapolation to the left and right looks bad # Extrapolation upwards looks bad too ls_full = np.logspace(log10(0.1), log10(20.0)) ls_stored = [] As_stored = [] for i, (K, ls, As) in enumerate(zip(Kds, l_ratios, A_ratios)): # plt.loglog(ls, As) univar = interp_objs[i] As_full = 10**univar(np.log10(ls_full)) # plt.loglog(ls_full, As_full) # print(len(univar.get_coeffs()), len(univar.get_knots())) ls_smoothed = np.logspace(log10(ls[0]), log10(ls[-1]), 100) As_smoothed = 10**univar(np.log10(ls_smoothed)) # plt.loglog(ls_smoothed, As_smoothed) ls_stored.append(ls_smoothed) As_stored.append(As_smoothed) # plt.show() all_zs = [] all_xs = [] all_ys = [] for z, xs, ys in zip(Kds, ls_stored, As_stored): for x, y in zip(xs, ys): all_zs.append(z) all_xs.append(x) all_ys.append(y) tck_recalc = bisplrep(np.log(all_xs), np.log(all_ys), all_zs, s=.002) [assert_allclose(i, j, rtol=1e-2) for i, j in zip(tck_diffuser_conical_Miller, tck_recalc)] # Plotting code to re-create the graph through solving for points # print([len(i) for i in tck[0:3]]) # # for K, ls in zip(Kds, ls_stored): # def get_right_y(l, K_goal): # try: # def err(y_guess): # if y_guess <= 1.1: # y_guess = 1.1 # if y_guess > 4: # y_guess = 4 # return bisplev(log(l), log(y_guess), tck) - K_goal # # ans = newton(err, 1.3) # ans = bisect(err, 1.1, 4) # # # if abs(err(ans)) > .1: # # ans = None # return ans # except: # return None # As_needed = [get_right_y(l, K) for l in ls] # plt.loglog(ls, As_needed, 'x') # plt.show() ### Entrances def test_entrance_distance_Miller_coefficients(): from fluids.fittings import entrance_distance_Miller_coeffs t_ds = [0.006304, 0.007586, 0.009296, 0.011292, 0.013288, 0.015284, 0.019565, 0.022135, 0.024991, 0.02842, 0.032136, 0.036426, 0.040145, 0.043149, 0.048446, 0.054745, 0.061332, 0.067919, 0.075081, 0.081957, 0.089121, 0.096284, 0.099722, 0.106886, 0.110897, 0.118061, 0.125224, 0.132101, 0.139264, 0.147, 0.153877, 0.16104, 0.167917, 0.175081, 0.181957, 0.189121, 0.196284, 0.199723, 0.206886, 0.214049, 0.221213, 0.228376, 0.235539, 0.242416, 0.249579, 0.250726, 0.257889, 0.264766, 0.271929, 0.279093, 0.286256, 0.293419, 0.300009] Ks = [1.00003, 0.97655, 0.94239, 0.90824, 0.87408, 0.83993, 0.78301, 0.75028, 0.71756, 0.68626, 0.65638, 0.62793, 0.6066, 0.59166, 0.57532, 0.56111, 0.54833, 0.5384, 0.53416, 0.53135, 0.53138, 0.53142, 0.53143, 0.53147, 0.53149, 0.53152, 0.53156, 0.53159, 0.53162, 0.53023, 0.53027, 0.5303, 0.53033, 0.53179, 0.5304, 0.53186, 0.53189, 0.53191, 0.53194, 0.53198, 0.53201, 0.53347, 0.53208, 0.53353, 0.53215, 0.53215, 0.53218, 0.53364, 0.53367, 0.53371, 0.53374, 0.53378, 0.5331] # plt.plot(t_ds, Ks) t_ds2 = np.linspace(t_ds[0], t_ds[-1], 1000) # Ks_Rennels = [entrance_distance(Di=1, t=t) for t in t_ds2] # plt.plot(t_ds2, Ks_Rennels) # plt.show() obj = UnivariateSpline(t_ds, Ks, s=3e-5) # print(len(obj.get_coeffs()), len(obj.get_knots())) # plt.plot(t_ds2, obj(t_ds2)) fun = chebfun(f=obj, domain=[0,.3], N=15) coeffs = chebfun_to_poly(fun, text=False) assert_allclose(coeffs, entrance_distance_Miller_coeffs) def test_entrance_distance_45_Miller_coefficients(): from fluids.fittings import entrance_distance_45_Miller_coeffs t_ds_re_entrant_45 = [0.006375, 0.007586, 0.009296, 0.011292, 0.013288, 0.015284, 0.019565, 0.022135, 0.024991, 0.02842, 0.032136, 0.036426, 0.040109, 0.043328, 0.046868, 0.048443, 0.053379, 0.053594, 0.059318, 0.059855, 0.065044, 0.068836, 0.070768, 0.07678, 0.082793, 0.088805, 0.089663, 0.095963, 0.104267, 0.110566, 0.116866, 0.123451, 0.129751, 0.136337, 0.142637, 0.146933, 0.153807, 0.160394, 0.167268, 0.174143, 0.181018, 0.187893, 0.194769, 0.199927, 0.20709, 0.213966, 0.221129, 0.228292, 0.235455, 0.242332, 0.249495, 0.250641, 0.257804, 0.264967, 0.27213, 0.279006, 0.286169, 0.293333, 0.299815] Ks_re_entrant_45 = [1.0, 0.97655, 0.94239, 0.90824, 0.87408, 0.83993, 0.78301, 0.75028, 0.71756, 0.68626, 0.65638, 0.62793, 0.60642, 0.59113, 0.57033, 0.56535, 0.54225, 0.54403, 0.52128, 0.52003, 0.5028, 0.48752, 0.48147, 0.463, 0.44737, 0.42889, 0.4232, 0.41184, 0.39053, 0.3749, 0.3607, 0.34507, 0.33086, 0.31666, 0.30388, 0.29678, 0.28685, 0.27549, 0.26699, 0.25848, 0.25282, 0.24715, 0.24434, 0.24437, 0.24298, 0.24158, 0.2402, 0.24023, 0.23884, 0.23745, 0.23606, 0.23606, 0.2361, 0.23329, 0.23332, 0.23193, 0.23054, 0.23057, 0.22989] # plt.plot(t_ds_re_entrant_45, Ks_re_entrant_45) obj = UnivariateSpline(t_ds_re_entrant_45, Ks_re_entrant_45, s=1e-4) t_ds_re_entrant_45_long = np.linspace(0, 0.3, 1000) # plt.plot(t_ds_re_entrant_45_long, obj(t_ds_re_entrant_45_long)) fun = chebfun(f=obj, domain=[0,.3], N=15) # plt.plot(t_ds_re_entrant_45_long, fun(t_ds_re_entrant_45_long), '--') # plt.show() coeffs = chebfun_to_poly(fun) assert_allclose(coeffs, entrance_distance_45_Miller_coeffs) def test_entrance_rounded_Miller_coefficients(): from fluids.fittings import entrance_rounded_Miller_coeffs path = os.path.join(fluids_data_dir, 'Miller 2E 1990 entrances rounded beveled K.csv') lines = open(path).readlines() _, ratios, Ks = Engauge_2d_parser(lines) ratios_45, ratios_30, ratios_round = ratios Ks_45, Ks_30, Ks_round = Ks # plt.plot(ratios_round, Ks_round) t_ds2 = np.linspace(ratios_round[0], ratios_round[1], 1000) # Ks_Rennels = [entrance_rounded(Di=1, rc=t) for t in t_ds2] # plt.plot(t_ds2, Ks_Rennels) obj = UnivariateSpline(ratios_round, Ks_round, s=6e-5) # plt.plot(t_ds2, obj(t_ds2)) fun = chebfun(f=obj, domain=[0,.3], N=8) # plt.plot(t_ds2, fun(t_ds2), '--') # plt.show() coeffs = chebfun_to_poly(fun) assert_allclose(coeffs, entrance_rounded_Miller_coeffs) ### Bends def test_bend_rounded_Crane_coefficients(): from fluids.fittings import bend_rounded_Crane_coeffs, bend_rounded_Crane_fds, bend_rounded_Crane_ratios bend_rounded_Crane_obj = UnivariateSpline(bend_rounded_Crane_ratios, bend_rounded_Crane_fds, s=0) fun = chebfun(f=bend_rounded_Crane_obj, domain=[1,20], N=10) coeffs = chebfun_to_poly(fun) assert_allclose(coeffs, bend_rounded_Crane_coeffs) xs = np.linspace(1, 20, 2000) diffs = (abs(fun(xs)-bend_rounded_Crane_obj(xs))/bend_rounded_Crane_obj(xs)) assert np.max(diffs) < .02 assert np.mean(diffs) < .002 @pytest.mark.slow def test_bend_rounded_Miller_K_coefficients(): from fluids import fluids_data_dir from fluids.core import Engauge_2d_parser Kb_curve_path = os.path.join(fluids_data_dir, 'Miller 2E 1990 smooth bends Kb.csv') lines = open(Kb_curve_path).readlines() all_zs, all_xs, all_ys = Engauge_2d_parser(lines, flat=True) tck_recalc = bisplrep(all_xs, all_ys, all_zs, kx=3, ky=3, s=.001) # Different platforms don't generate the same coefficients at all # and that is OK # [assert_allclose(i, j) for i, j in zip(tck_bend_rounded_Miller, tck_recalc)] @pytest.mark.slow def test_bend_rounded_Miller_Re_correction(): from fluids import fluids_data_dir from fluids.core import Engauge_2d_parser from fluids.fittings import tck_bend_rounded_Miller_C_Re Re_curve_path = os.path.join(fluids_data_dir, 'Miller 2E 1990 smooth bends Re correction.csv') text = open(Re_curve_path).readlines() rds, Re_lists, C_lists = Engauge_2d_parser(text) inter_objs = [] for rd, Res, Cs in zip(rds, Re_lists, C_lists): univar = UnivariateSpline(np.log10(Res), Cs) # Default smoothing is great! inter_objs.append(univar) for i, (rd, Res, Cs) in enumerate(zip(rds, Re_lists, C_lists)): # plt.semilogx(Res, Cs) univar = inter_objs[i] Cs_smoothed = univar(np.log10(Res)) # plt.semilogx(Res, Cs_smoothed) # print(univar.get_coeffs(), univar.get_knots()) # plt.show() # make a rectangular grid Res = np.logspace(np.log10(1E4), np.log10(1E8), 100) Cs_stored = [] for obj in inter_objs: Cs_smoothed = obj(np.log10(Res)) # plt.semilogx(Res, Cs_smoothed) Cs_stored.append(Cs_smoothed) # plt.show() # Flatten the data to the form used in creating the spline all_zs = [] all_xs = [] all_ys = [] for z, x, ys in zip(rds, Res, Cs_stored): for x, y in zip(Res, ys): all_zs.append(z) all_xs.append(x) all_ys.append(y) tck_recalc = bisplrep(np.log10(all_xs), all_zs, all_ys) [assert_allclose(i, j) for i, j in zip(tck_bend_rounded_Miller_C_Re, tck_recalc)] spline_obj = lambda Re, r_D : bisplev(np.log10(Re), r_D, tck_recalc) Res = np.logspace(np.log10(1E4), np.log10(1E8), 100) for obj, r_d in zip(inter_objs, rds): Cs_smoothed = obj(np.log10(Res)) # plt.semilogx(Res, Cs_smoothed) # Cs_spline = spline_obj(Res, r_d) # plt.semilogx(Res, Cs_spline, '--') for r in np.linspace(1, 2, 10): Cs_spline = spline_obj(Res, r) # plt.semilogx(Res, Cs_spline, '-') # plt.show() from fluids.fittings import bend_rounded_Miller_C_Re, bend_rounded_Miller_C_Re_limit_1 ps = np.linspace(1, 2) qs = [newton(lambda x: bend_rounded_Miller_C_Re(x, i)-1, 2e5) for i in ps] rs = np.polyfit(ps, qs, 4).tolist() assert_allclose(rs, bend_rounded_Miller_C_Re_limit_1) @pytest.mark.slow def test_bend_rounded_Miller_outlet_tangent_correction(): Re_curve_path = os.path.join(fluids_data_dir, 'Miller 2E 1990 smooth bends outlet tangent length correction.csv') text = open(Re_curve_path).readlines() Kbs, length_ratio_lists, Co_lists = Engauge_2d_parser(text) def BioScience_GeneralizedSubstrateDepletion_model(x_in): '''Fit created using zunzun.com, comparing the non-linear, non-logarithmic plot values with pixel positions on the graph. 0 0.00 1 311 2 493 4 721 6 872 10 1074 20 1365 30 1641 40 1661 ''' temp = 0.0 a = 1.0796070184265327E+03 b = 2.7557612059844967E+00 c = -2.1529870432577212E+01 d = 4.1229208061974096E-03 temp = (a * x_in) / (b + x_in) - (c * x_in) - d return temp def fix(y): # Reverse the plot # Convert input "y" to between 0 and 1661 y = y/30 # 0-1 linear y *= 1641 # to max err = lambda x: BioScience_GeneralizedSubstrateDepletion_model(x) - y return float(fsolve(err, 1)[0]) for values in length_ratio_lists: for i in range(len(values)): x = min(values[i], 30) # Do not allow values over 30 values[i] = fix(x) # Plotting code # inter_objs = [] # for Kb, lrs, Cos in zip(Kbs, length_ratio_lists, Co_lists): # univar = UnivariateSpline(lrs, Cos, s=4e-4) # Default smoothing is great! # inter_objs.append(univar) # for i, (Kb, lrs, Cos) in enumerate(zip(Kbs, length_ratio_lists, Co_lists)): # plt.semilogx(lrs, Cos, 'x') # univar = inter_objs[i] # Cs_smoothed = univar(lrs) # plt.semilogx(lrs, Cs_smoothed) # plt.ylim([0.3, 3]) # plt.xlim([0.1, 30]) # plt.show() # Code to literally write the code min_vals = [] tcks = [] for Kb, lrs, Cos in zip(Kbs, length_ratio_lists, Co_lists): univar = splrep(lrs, Cos, s=4e-4) # Default smoothing is great! s = ('tck_bend_rounded_Miller_C_o_%s = ' %str(Kb).replace('.', '_')) template = 'np.array(%s),\n' t1 = template%str(univar[0].tolist()) t2 = template%str(univar[1].tolist()) s = s + f'[{t1}{t2}3]' # print(s) min_vals.append(float(splev(0.01, univar))) tcks.append(univar) # Check the fixed constants above the function from fluids.fittings import tck_bend_rounded_Miller_C_os for tck, tck_recalc in zip(tck_bend_rounded_Miller_C_os, tcks): [assert_allclose(i, j) for i, j in zip(tck, tck_recalc)] from fluids.fittings import bend_rounded_Miller_C_o_limit_0_01 assert_allclose(min_vals, bend_rounded_Miller_C_o_limit_0_01) from fluids.fittings import bend_rounded_Miller_C_o_limits max_ratios = [i[-1] for i in length_ratio_lists] assert_allclose(max_ratios, bend_rounded_Miller_C_o_limits) def test_bend_miter_Miller_coefficients(): from fluids.optional.pychebfun import chebfun, chebfun_to_poly curve_path = os.path.join(fluids_data_dir, 'Miller 2E 1990 Kb mitre bend.csv') text = open(curve_path).readlines() zs, x_lists, y_lists = Engauge_2d_parser(text) x_raw, y_raw = x_lists[0], y_lists[0] univar = UnivariateSpline(x_raw, y_raw, s=1e-4) fun = chebfun(f=univar, domain=[0,120], N=15) # 15 max for many coeffs recalc_coeffs = chebfun_to_poly(fun) from fluids.fittings import bend_miter_Miller_coeffs assert_allclose(bend_miter_Miller_coeffs, recalc_coeffs) def test_diffuser_conical_Idelchik_coefficients(): from fluids.fittings import ( diffuser_conical_Idelchik_A_ratios, diffuser_conical_Idelchik_angles, diffuser_conical_Idelchik_data, diffuser_conical_Idelchik_tck, ) diffuser_conical_Idelchik_obj = RectBivariateSpline(np.array(diffuser_conical_Idelchik_A_ratios), np.array(diffuser_conical_Idelchik_angles), np.array(diffuser_conical_Idelchik_data), kx=3, ky=1) [assert_allclose(i, j) for i, j in zip(diffuser_conical_Idelchik_obj.tck, diffuser_conical_Idelchik_tck)] def test_entrance_rounded_Idelchik_coeffs(): from fluids.fittings import entrance_rounded_Idelchik_tck, entrance_rounded_Ks_Idelchik, entrance_rounded_ratios_Idelchik tck_refit = splrep(entrance_rounded_ratios_Idelchik, entrance_rounded_Ks_Idelchik, s=0, k=2) [assert_allclose(i, j, rtol=1e-3) for i, j in zip(tck_refit, entrance_rounded_Idelchik_tck)] #entrance_rounded_Idelchik = UnivariateSpline(entrance_rounded_ratios_Idelchik, # entrance_rounded_Ks_Idelchik, # s=0, k=2, ext=3) # def test_entrance_rounded_Harris_coeffs(): from fluids.fittings import entrance_rounded_Harris_tck, entrance_rounded_Ks_Harris, entrance_rounded_ratios_Harris tck_refit = splrep(entrance_rounded_ratios_Harris, entrance_rounded_Ks_Harris, s=0, k=2) [assert_allclose(i, j, rtol=1e-3) for i, j in zip(tck_refit, entrance_rounded_Harris_tck)] #entrance_rounded_Harris = UnivariateSpline(entrance_rounded_ratios_Harris, # entrance_rounded_Ks_Harris, # s=0, k=2, ext=3) def test_entrance_distance_Harris_coeffs(): from fluids.fittings import entrance_distance_Harris_Ks, entrance_distance_Harris_t_Di, entrance_distance_Harris_tck tck_refit = splrep(entrance_distance_Harris_t_Di, entrance_distance_Harris_Ks, s=0, k=3) [assert_allclose(i, j, rtol=1e-3) for i, j in zip(tck_refit, entrance_distance_Harris_tck)] #entrance_distance_Harris_obj = UnivariateSpline(entrance_distance_Harris_t_Di, # entrance_distance_Harris_Ks, # s=0, k=3)