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)))
