def muf(X, T, I, D, ps, Jmax, Vcmax,\ ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1): alpha_log10, b, c, g1, kxmax_log10, p50 = X kxmax = 10**kxmax_log10 PLC = [] for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf4, bounds=(pxmin, psi),\ method='bounded',\ args=(Ti, Ii, Di, psi, Kc, Vcmax, ca,\ q, Jmax, z1, z2, R, g1, b, c,\ kxmax, p50, a, L)) px1 = pxf4(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ g1, b, c, kxmax, p50, a, L) px2 = pxf4(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2,\ R, g1, b, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf4, pxmin, pxmax.x, args=(Ti, Ii, Di, psi,\ Kc, Vcmax, ca, q,\ Jmax, z1, z2, R,\ g1, b, c, kxmax,\ p50, a, L)) PLC.append(kxf(px, kxmax, p50) / kxmax) else: PLC.append('nan') return PLC
def muf(X, env, Vcmax=60, Jmax=120, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1): c, p50, param, D, ps = X T, I, day = env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf, bounds=(pxmin, ps),\ method='bounded',\ args=(T, I, D, ps, Kc, Vcmax, ca, q,\ Jmax, z1, z2, R, param, c, p50,\ a, L)) px1 = pxf(pxmin, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, param,\ c, p50, a, L) px2 = pxf(pxmax.x, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ param, c, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf, pxmin, pxmax.x,\ args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1,\ z2, R, param, c, p50, a, L)) return (1 - PLCf(px, p50)) * (ps - px) * day else: return 0
def muf(X, env, Vcmax=60, Jmax=120, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1): alpha_log10, c_log10, g1_log10, kxmax_log10, p50, ps = X alpha, c, g1, kxmax = 10**alpha_log10, 10**c_log10, 10**g1_log10, 10**kxmax_log10 T, I, D, dayi = env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) return kxf(px, kxmax, p50) * (ps - px) * dayi / alpha
def muf(X, T, I, D, ps, Jmax, Vcmax,\ ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1): alpha_log10, c, g1, kxmax, p50 = X gs_closure = [] for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf3, bounds=(pxmin, psi),\ method='bounded',\ args=(Ti, Ii, Di, psi, Kc, Vcmax, ca,\ q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L)) px1 = pxf3(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ g1, c, kxmax, p50, a, L) px2 = pxf3(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2,\ R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf3, pxmin, pxmax.x, args=(Ti, Ii, Di, psi,\ Kc, Vcmax, ca, q,\ Jmax, z1, z2, R,\ g1, c, kxmax,\ p50, a, L)) b = (0.3 * p50 - 1) * (np.log(10))**(-1 / c) gs_closure.append(np.exp(-(px / b)**c)) else: gs_closure.append('nan') return gs_closure
def testf(X, env, Vcmax=60, Jmax=120, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1): alpha_log10, c_log10, g1_log10, kxmax_log10, p50, ps = X c, g1, kxmax = 10**c_log10, 10**g1_log10, 10**kxmax_log10 T, I, D, dayi = env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px1 = pxf2(pxmin, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) return px1 * px2
def muf(X, T, I, D, ps, day_length, vn_max, Jmax, Vcmax,\ ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1): alpha_log10, c, g1, kxmax, p50 = X alpha = 10**alpha_log10 sapflow_modeled = [] for i in range(len(T)): Ti, Ii, Di, psi, dli = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i],\ day_length.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf3, bounds=(pxmin, psi),\ method='bounded',\ args=(Ti, Ii, Di, psi, Kc, Vcmax, ca,\ q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L)) px1 = pxf3(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ g1, c, kxmax, p50, a, L) px2 = pxf3(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2,\ R, g1, c, kxmax, p50, a, L) if px1*px2 < 0: px = optimize.brentq(pxf3, pxmin, pxmax.x, args=(Ti, Ii, Di, psi,\ Kc, Vcmax, ca, q,\ Jmax, z1, z2, R,\ g1, c, kxmax,\ p50, a, L)) sapflow_modeled.append(kxf(px, kxmax, p50)*(psi-px)*30*60*dli*\ 18/1000000/vn_max/alpha) else: if abs(px1) < abs(px2): sapflow_modeled.append(1) else: sapflow_modeled.append(0) return sapflow_modeled
def muf(X, T, I, D, ps, Vcmax, Jmax,\ ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, rho=997000,\ L=1): alpha_log10, c, g1, kxmax_log10, p50 = X alpha, kxmax = 10**alpha_log10, 10**kxmax_log10 sapflow_modeled, gs_closure, PLC = [], [], [] f1 = lambda x: np.exp(-x * c) for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, psi),\ method='bounded',\ args=(Ti, Ii, Di, psi, Kc, Vcmax,\ ca, q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2,\ R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, psi,\ Kc, Vcmax, ca,\ q, Jmax, z1, z2,\ R, g1, c, kxmax,\ p50, a, L)) sapflow_modeled.append(kxf(px, kxmax, p50)*(psi-px)*18/1000000/\ 1000*rho/alpha) PLC.append(PLCf(px, p50)) gs_closure.append((f1(PLCf(px, p50)) - f1(1)) / (f1(0) - f1(1))) else: sapflow_modeled.append(np.nan) PLC.append(np.nan) gs_closure.append(np.nan) return sapflow_modeled, PLC, gs_closure
def muf(X, T, I, D, ps, Vcmax, Jmax,\ ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1): alpha_log10, c, g1_log10, kxmax_log10, p50 = X g1, kxmax = 10**g1_log10, 10**kxmax_log10 A = [] for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, psi),\ method='bounded',\ args=(Ti, Ii, Di, psi, Kc, Vcmax,\ ca, q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2,\ R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, psi,\ Kc, Vcmax, ca,\ q, Jmax, z1, z2,\ R, g1, c, kxmax,\ p50, a, L)) gs = kxf(px, kxmax, p50) * (psi - px) / (1000 * a * Di * L) A_gs = Af(gs, Ti, Ii, Kc, Vcmax, ca, q, Jmax, z1, z2, R) A_max = Af(1000, Ti, Ii, Kc, Vcmax, ca, q, Jmax, z1, z2, R) A.append(A_gs / A_max) else: A.append(np.nan) return A
def muf(X, Env, ca=400, Kc=460, q=0.3, R=8.314, Jmax=80, Vcmax=30, z1=0.9, z2=0.9999, a=1.6): #, alpha = 0.02, g1 = 50, kxmax = 7): alpha, c, g1, kxmax, p50, L, ps = X #c, p50, L, ps = X T, I, D = Env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px = optimize.brentq(pxf, pxmin, pxmax.x, args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) res = alpha * kxf(px, kxmax, p50) * (ps - px) return res
def testf(X, env, Jmax=100, Vcmax=50, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, l=1.8 * 10**(-5), u=48240): b, c, g1, kxmax, p50, L = X T, I, D, ps = env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf4, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L)) px1 = pxf4(pxmin, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L) px2 = pxf4(pxmax.x, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L) return px1 * px2
def muf(X, T, I, D, ps, Vcmax, Jmax,\ ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, rho=997000,\ L=1): _, c, g1, kxmax_log10, p50 = X kxmax = 10**kxmax_log10 res = [] for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, psi),\ method='bounded',\ args=(Ti, Ii, Di, psi, Kc, Vcmax,\ ca, q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2,\ R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, psi,\ Kc, Vcmax, ca,\ q, Jmax, z1, z2,\ R, g1, c, kxmax,\ p50, a, L)) PLC = PLCf(px, p50) gs = kxf(px, kxmax, p50) * (psi - px) / (1000 * a * Di * L) res.append([PLC, gs]) else: res.append([np.nan, np.nan]) return res
def muf(alpha_log10=3, c=13, g1_log10=1.3, kxmax_log10=3, p50=-2.5, T=T, I=I, D=D, ps=ps, day_len=day_len,\ ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, L=1, Jmax=122, Vcmax=61): alpha, g1, kxmax = 10**alpha_log10, 10**g1_log10,\ 10**kxmax_log10 sapflow_modeled = [] for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] dayi = day_len.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, psi),\ method='bounded',\ args=(Ti, Ii, Di, psi, Kc, Vcmax, ca,\ q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R,\ g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2,\ R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, psi,\ Kc, Vcmax, ca, q,\ Jmax, z1, z2, R,\ g1, c, kxmax,\ p50, a, L)) sapflow_modeled.append(kxf(px, kxmax, p50)*(psi-px)*30*60*18/\ 1000000/alpha*dayi) else: sapflow_modeled.append(np.nan) return sapflow_modeled
def muf(X, env, Jmax=100, Vcmax=50, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, l=1.8 * 10**(-5), u=48240, vn_max=2): b, c, g1, kxmax, p50, L = X T, I, D, ps = env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf4, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L)) px = optimize.brentq(pxf4, pxmin, pxmax.x, args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L)) return l * u * kxf(px, kxmax, p50) * (ps - px) / 1000 / vn_max
def testf(X, Env, ca = 400, Kc = 460, q = 0.3, R = 8.314, Jmax = 80, Vcmax = 30, z1 = 0.9, z2 = 0.9999, a = 1.6, g1 = 50): c, kxmax, p50, L, ps = X T, I, D = Env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) res = pxf(pxmin, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)*pxf(pxmax.x, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) return res
def muf(alpha_log10=1, c_log10=0, g1_log10=1, kxmax_log10=3, p50=-1, ps=-0.5, ca=400, Kc=460, q=0.3, R=8.314, Jmax=80, Vcmax=30, z1=0.9, z2=0.9999, a=1.6, L=1): alpha, c, g1, kxmax = 10**alpha_log10, 10**c_log10, 10**g1_log10, 10**kxmax_log10 sapflow_modeled = [] for i in range(len(vn)): # Environmental conditions Ti, Ii, Di = T.iloc[i], I.iloc[i], D.iloc[i] # px pxmin = pxminf(ps, p50) if pxmin < ps: pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, ps), method='bounded', args=(Ti, Ii, Di, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) sapflow_modeled.append( kxf(px, kxmax, p50) * (ps - px) * 30 * 60 * 18 / 1000000 / vn_max / alpha) else: if abs(px1) < abs(px2): sapflow_modeled.append(1) else: sapflow_modeled.append(0) else: print('pxmin > ps') sapflow_modeled.append(0) return sapflow_modeled
def muf(alpha, b, c, p50, kxmax, g1, L=1, ca=400, Kc=460, q=0.3, R=8.314, Jmax=Jmax, Vcmax=Vcmax, z1=0.9, z2=0.9999, a=1.6): sapflow_modeled = [] for i in range(len(vn)): # Environmental conditions Ti, Ii, Di, psi, dli = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i], 30 # px pxmin = pxminf(psi, p50) if pxmin < psi: pxmax = optimize.minimize_scalar(pxf4, bounds=(pxmin, psi), method='bounded', args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L)) px1 = pxf4(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L) px2 = pxf4(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf4, pxmin, pxmax.x, args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L)) sapflow_modeled.append( kxf(px, kxmax, p50) * (psi - px) * 30 * 60 * dli * 18 / 1000000 / vn_max / alpha) else: if abs(px1) < abs(px2): sapflow_modeled.append(1) else: sapflow_modeled.append(0) else: print('pxmin > ps') sapflow_modeled.append(0) return sapflow_modeled
def muf(alpha_log10=-2, c=6, g1=0.5, kxmax_log10=2, p50=-1, ca=400, Kc=460, q=0.3, R=8.314, Vcmax=Vcmax, Jmax=Jmax, z1=0.9, z2=0.9999, a=1.6, rho=997000, L=1): alpha, kxmax = 10**alpha_log10, 10**kxmax_log10 sapflow_modeled = [] for i in range(len(vn)): # Environmental conditions Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) if pxmin < psi: pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, psi), method='bounded', args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) sapflow_modeled.append( kxf(px, kxmax, p50) * (psi - px) * 18 / 1000000 / 1000 * rho / alpha) else: sapflow_modeled.append(np.nan) else: sapflow_modeled.append(np.nan) print(kxf(px, kxmax, p50) * (psi - px) / (1000 * a * Di)) return sapflow_modeled
def muf(b, c, p50, kxmax, g1, L=1, ca=400, Kc=460, q=0.3, R=8.314, Jmax=Jmax, Vcmax=Vcmax, z1=0.9, z2=0.9999, a=1.6): res = [] for i in range(len(T)): # Environmental conditions Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) if pxmin < psi: pxmax = optimize.minimize_scalar(pxf4, bounds=(pxmin, psi), method='bounded', args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L)) px1 = pxf4(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L) px2 = pxf4(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf4, pxmin, pxmax.x, args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, b, c, kxmax, p50, a, L)) res.append(np.exp(-(px / b)**c)) else: if abs(px1) < abs(px2): res.append(1) else: res.append(0) else: print('pxmin > ps') res.append(0) return res
def muf(X, T, I, D, ps, Jmax, Vcmax, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6): alpha, c, p50, kxmax, g1, L = X gs = [] for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, psi), method='bounded', args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) PLC = PLCf(px, p50) f1 = lambda x: np.exp(-x * c) f2 = lambda x: (f1(x) - f1(1)) / (f1(0) - f1(1)) gs.append(f2(PLC)) else: if abs(px1) < abs(px2): gs.append(1) else: gs.append(0) return gs
def muf(X, T, I, D, ps, Jmax, Vcmax, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, l=1.8 * 10**(-5), u=48240): alpha, c, p50, kxmax, g1, L = X sapflow_modeled = [] for i in range(len(T)): Ti, Ii, Di, psi = T.iloc[i], I.iloc[i], D.iloc[i], ps.iloc[i] # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, psi), method='bounded', args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px1 = pxf2(pxmin, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) sapflow_modeled.append(l * u * kxf(px, kxmax, p50) * (psi - px) / 1000 / alpha) else: if abs(px1) < abs(px2): sapflow_modeled.append(1) else: sapflow_modeled.append(0) return sapflow_modeled
def muf(X, env, Jmax=100, Vcmax=50, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999, a=1.6, l=1.8*10**(-5), u=48240, alpha=0.013): c, g1, kxmax, p50, L, ps = X T, I, D = env pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px1 = pxf2(pxmin, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) px2 = pxf2(pxmax.x, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L) if px1*px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax.x, args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) return l*u*kxf(px, kxmax, p50)*(ps-px)/1000/alpha else: if abs(px1) < abs(px2): return 1 else: return 0
def muf( X, T, I, D, ps, ca=400, Kc=460, q=0.3, R=8.314, Jmax=80, Vcmax=30, z1=0.9, z2=0.9999, a=1.6, l=1.8 * 10**(-5), u=48240, ): alpha, c, p50, kxmax, g1, L = X sapflow_modeled = np.zeros(len(T)) for i in range(len(T)): # Environmental conditions Ti, Ii, Di, psi, Li = T[i], I[i], D[i], ps[i], L # px pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf, bounds=(pxmin, psi), method='bounded', args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, Li)) px = optimize.brentq(pxf, pxmin, pxmax.x, args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, Li)) # vn sapflow_modeled[i] = l * u * kxf(px, kxmax, p50) * (psi - px) / 1000 / alpha return sapflow_modeled
def muf(c, p50, T, I, D, ps, day_len, g1_log10=1, kxmax_log10=3, Vcmax=60, Jmax=120, ca=400, Kc=460, q=0.3, R=8.314, z1=0.9, z2=0.9999,\ a=1.6, L=1): g1, kxmax = 10**g1_log10, 10**kxmax_log10 pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf2, bounds=(pxmin, ps),\ method='bounded',\ args=(T, I, D, ps, Kc, Vcmax, ca, q,\ Jmax, z1, z2, R, g1, c, kxmax, p50,\ a, L)).x px1 = pxf2(pxmin, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L) px2 = pxf2(pxmax, T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c,\ kxmax, p50, a, L) if px1 * px2 < 0: px = optimize.brentq(pxf2, pxmin, pxmax,\ args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1,\ z2, R, g1, c, kxmax, p50, a, L)) return kxf(px, kxmax, p50) * (ps - px) * day_len return np.nan
def muf(c, p50, T=12, I=140, D=0.0027, ps=-0.5, ca=400, Kc=460, q=0.3, R=8.314, Jmax=80, Vcmax=30, z1=0.9, z2=0.9999, a=1.6, l=1.8 * 10**(-5), u=48240, n=0.43, Z=3, alpha=0.02, kxmax=7, g1=50, L=2): pxmin = pxminf(ps, p50) pxmax = optimize.minimize_scalar(pxf, bounds=(pxmin, ps), method='bounded', args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) px = optimize.brentq(pxf, pxmin, pxmax.x, args=(T, I, D, ps, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) gs = 10**(-3) * kxf(px, kxmax, p50) * (ps - px) / (a * D * L) E = a * L * l * u / (n * Z) * D * gs sapflow_modeled = E / alpha return sapflow_modeled
kxmax = 7 p50 = -5 ps = -1 g1 = 10 f = lambda px: pxf(px, T, I, D, ps=ps, Kc=460, Vcmax=30, ca=400, q=0.3, Jmax=80, z1=0.9, z2=0.9999, R=8.314, g1=g1, c=30, kxmax=kxmax, p50=p50, a=1.6, L=1) x_min = pxminf(ps, p50) x_max = optimize.minimize_scalar(f, bounds=(x_min, ps), method='bounded').x x = np.linspace(x_min, x_max, 10) y = f(x) plt.plot(y) plt.axhline(y=0, color='red')
# read csv df = pd.read_csv('../Data/UMB_daily_average.csv') T = df['T'] I = df['I'] D = df['D'] ps = df['ps3'] # parameters Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, kxmax, a, L = 460, 31, 400, 0.3, 48, 0.9, 0.9999, 8.314, 50, 7, 1.6, 2 c, p50 = 10, -3 j = 0 for i in range(len(T)): Ti, Ii, Di, psi = T[i], I[i], D[i], ps[i] pxmin = pxminf(psi, p50) pxmax = optimize.minimize_scalar(pxf, bounds=(pxmin, psi), method='bounded', args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) try: px = optimize.brentq(pxf, pxmin, pxmax.x, args=(Ti, Ii, Di, psi, Kc, Vcmax, ca, q, Jmax, z1, z2, R, g1, c, kxmax, p50, a, L)) except ValueError: j += 1 print('{} out of {} days'.format(j, len(T)))