def test_memory_leak():
import resource
arr = np.arange(1).reshape((1, 1))
starting = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
for i in range(1000):
for axis in [None, 0, 1]:
bn.nansum(arr, axis=axis)
bn.nanargmax(arr, axis=axis)
bn.nanargmin(arr, axis=axis)
bn.nanmedian(arr, axis=axis)
bn.nansum(arr, axis=axis)
bn.nanmean(arr, axis=axis)
bn.nanmin(arr, axis=axis)
bn.nanmax(arr, axis=axis)
bn.nanvar(arr, axis=axis)
ending = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
diff = ending - starting
diff_bytes = diff * resource.getpagesize()
print(diff_bytes)
# For 1.3.0 release, this had value of ~100kB
assert diff_bytes == 0
def test_memory_leak() -> None:
import resource
arr = np.arange(1).reshape((1, 1))
n_attempts = 3
results = []
for _ in range(n_attempts):
starting = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
for _ in range(1000):
for axis in [None, 0, 1]:
bn.nansum(arr, axis=axis)
bn.nanargmax(arr, axis=axis)
bn.nanargmin(arr, axis=axis)
bn.nanmedian(arr, axis=axis)
bn.nansum(arr, axis=axis)
bn.nanmean(arr, axis=axis)
bn.nanmin(arr, axis=axis)
bn.nanmax(arr, axis=axis)
bn.nanvar(arr, axis=axis)
ending = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
diff = ending - starting
diff_bytes = diff * resource.getpagesize()
# For 1.3.0 release, this had value of ~100kB
if diff_bytes:
results.append(diff_bytes)
else:
break
assert len(results) < n_attempts
def func11(y, e, nlhc, indTC, residual, o, a, _s, p):
m, n = y.shape
if p.probType == "IP":
w = arange(m)
# TODO: omit recalculation from func1
ind = nanargmin(a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:], 1)
sup_inf_diff = 0.5*(a[w, ind] - o[w, ind] + a[w, n+ind] - o[w, n+ind])
diffao = a - o
minres_ind = nanargmin(diffao, 1)
minres = diffao[w, minres_ind]
complementary_minres = diffao[w, where(minres_ind<n, minres_ind+n, minres_ind-n)]
volume = prod(e-y, 1)
volumeResidual = volume * sup_inf_diff
F = 0.25 * (a[w, ind] + o[w, ind] + a[w, n+ind] + o[w, n+ind])
return [si(IP_fields, sup_inf_diff[i], minres[i], minres_ind[i], complementary_minres[i], y[i], e[i], o[i], a[i], _s[i], F[i], volume[i], volumeResidual[i]) for i in range(m)]
else:
residual = None
tmp = asarray(a)-asarray(o)
tmp[tmp<1e-300] = 1e-300
nlhf = log2(tmp)#-log2(p.fTol)
# nlhf[a==inf] = 1e300# to make it not inf and nan
# nlhf[o==-inf] = 1e300# to make it not inf and nan
if nlhf.ndim == 3: # in MOP
nlhf = nlhf.sum(axis=1)
if p.probType == "MOP":
# make correct o,a wrt each target
return [si(MOP_Fields, y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None,
[o[i][k] for k in range(p.nf)], [a[i][k] for k in range(p.nf)],
_s[i]) for i in range(m)]
else:
s, q = o[:, 0:n], o[:, n:2*n]
Tmp = nanmax(where(q<s, q, s), 1)
nlhf[logical_and(isinf(a), isinf(nlhf))] = 1e300
assert p.probType in ('GLP', 'NLP', 'NSP', 'SNLE', 'NLSP', 'MINLP')
# residual = None
return [si(Fields, Tmp[i], y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None,
o[i], a[i], _s[i]) for i in range(m)]
def compute_draw_info(self, x, ys):
bs = self.compute_baseline(x, ys)
im = np.array([bottleneck.nanargmin(abs(x - self.limits[0]))])
dx = [self.limits[0], self.limits[0]]
dys = np.hstack((bs[:, im], ys[:, im]))
return [("curve", (dx, dys, INTEGRATE_DRAW_EDGE_PENARGS)), # line to value
("dot", (x[im], ys[:, im]))]
def reducepoints(x, y, n=2000, further=True):
"""
Reduce the total number of x, y coordinates for plotting. The
algorithm looks windows roughly one pixel wide and plots the
minimum and maximum point within that window. NOTE: both the min
and max for each n will be determined. This will yield a length
of approximately 2n. If further, remove nonessential points.
"""
# Can only work on blocks
if len(x) < n*3: return (x, y)
# Calculate the block size to average over
block = int(math.floor(float(len(x))/n))
newn = int(math.ceil(float(len(x))/block))
ox, oy = np.zeros(2*newn), np.zeros(2*newn)
# Search over each block for the min and max y value, order
# correctly, and add to the output
for i in range(newn):
# Avoid just adding NaN's for all NaN blocks
try:
pmn = nanargmin(y[i*block:(i + 1)*block])
except ValueError:
pmn = 0
try:
pmx = nanargmax(y[i*block:(i + 1)*block])
except ValueError:
pmx = 0
if pmn < pmx:
ox[2*i], oy[2*i] = x[i*block + pmn], y[i*block + pmn]
ox[2*i + 1], oy[2*i + 1] = x[i*block + pmx], y[i*block + pmx]
else:
ox[2*i + 1], oy[2*i + 1] = x[i*block + pmn], y[i*block + pmn]
ox[2*i], oy[2*i] = x[i*block + pmx], y[i*block + pmx]
if further:
last = -1
match = 0
# Search through all values and set >= triplets to 0
for i in range(len(ox)):
if oy[i] != last:
last = oy[i]
match = 0
else:
match += 1
if match > 1:
ox[i - 1] = np.nan
# Eliminate those positions where ox is nan
if np.sum(np.isnan(ox)) > 0:
oy = oy[np.isfinite(ox)]
ox = ox[np.isfinite(ox)]
return ox, oy
def r2(PointVals, PointCoords, dataType):
r23 = nanargmin(PointVals)
if isnan(r23):
r23 = 0
# TODO: check it , maybe it can be improved
#bestCenter = cs[r23]
#r7 = array([(val[0][r23]+val[1][r23]) / 2 for val in domain.values()], dtype=dataType)
#r8 = atleast_1d(r3)[r23] if not isnan(r23) else inf
r7 = array(PointCoords[r23], dtype=dataType)
r8 = atleast_1d(PointVals)[r23]
return r7, r8
def r2(PointVals, PointCoords, dataType):
r23 = nanargmin(PointVals)
if isnan(r23):
r23 = 0
# TODO: check it , maybe it can be improved
#bestCenter = cs[r23]
#r7 = array([(val[0][r23]+val[1][r23]) / 2 for val in domain.values()], dtype=dataType)
#r8 = atleast_1d(r3)[r23] if not isnan(r23) else inf
r7 = array(PointCoords[r23], dtype=dataType)
r8 = atleast_1d(PointVals)[r23]
return r7, r8
def find_nearest(array, value):
"""
Search array for value and return the index where the value is closest.
Parameters:
array (ndarray): Array to search.
value: Value to search array for.
Returns:
int: Index of ``array`` closest to ``value``.
Raises:
ValueError: If ``value`` is NaN.
.. codeauthor:: Rasmus Handberg <*****@*****.**>
"""
if np.isnan(value):
raise ValueError("Invalid search value")
if np.isposinf(value):
return nanargmax(array)
if np.isneginf(value):
return nanargmin(array)
return nanargmin(np.abs(array - value))
def time_nanargmin(self, dtype, shape, order, axis):
bn.nanargmin(self.arr, axis=axis)
def time_nanargmin(self, dtype, shape):
bn.nanargmin(self.arr)
def gas_exchange(p, fw, photo='Farquhar', res='low', dynamic=True, inf_gb=False,
iter_max=40, threshold_conv=0.1):
# initial state
Cs = p.CO2 # Pa
Tleaf = p.Tair # deg C
# hydraulics
P, E = hydraulics(p, res=res, kmax=p.kmaxT)
# initialise gs over A
g0 = 1.e-9 # g0 ~ 0, removing it entirely introduces errors
Cs_umol_mol = Cs * conv.MILI / p.Patm # umol mol-1
gsoA = g0 + p.g1T * fw / Cs_umol_mol
# iter on the solution until it is stable enough
iter = 0
while True:
An, Aj, Ac, Ci = calc_photosynthesis(p, 0., Cs, photo, Tleaf=Tleaf,
gs_over_A=gsoA)
# stomatal conductance, with fwsoil effect
gs = np.maximum(cst.zero, conv.GwvGc * gsoA * An)
# calculate new trans, gw, gb, etc.
trans, real_zero, gw, gb, __ = calc_trans(p, Tleaf, gs, inf_gb=inf_gb)
new_Tleaf, __ = leaf_temperature(p, trans, Tleaf=Tleaf, inf_gb=inf_gb)
Pleaf = P[bn.nanargmin(np.abs(E - trans))]
# update Cs (Pa)
boundary_CO2 = p.Patm * conv.FROM_MILI * An / (gb * conv.GbcvGb)
Cs = np.maximum(cst.zero, np.minimum(p.CO2, p.CO2 - boundary_CO2))
Cs_umol_mol = Cs * conv.MILI / p.Patm
# update gs over A
gsoA = g0 + p.g1T * fw / Cs_umol_mol
# force stop when atm. conditions yield E < 0. (non-physical)
if (iter < 1) and (not real_zero):
real_zero = None
# check for convergence
if ((real_zero is None) or (iter >= iter_max) or ((iter >= 2) and
real_zero and (abs(Tleaf - new_Tleaf) <= threshold_conv) and not
np.isclose(gs, cst.zero, rtol=cst.zero, atol=cst.zero))):
break
# no convergence, iterate on leaf temperature
Tleaf = new_Tleaf
iter += 1
if ((np.isclose(trans, cst.zero, rtol=cst.zero, atol=cst.zero) and
(An > 0.)) or np.isclose(Ci, 0., rtol=cst.zero, atol=cst.zero) or
(Ci < 0.) or np.isclose(Ci, p.CO2, rtol=cst.zero, atol=cst.zero) or
(Ci > p.CO2) or (real_zero is None) or (not real_zero) or
any(np.isnan([An, Ci, trans, gs, Tleaf, Pleaf]))):
An, Ci, trans, gs, gb, Tleaf, Pleaf = (9999.,) * 7
return An, Aj, Ac, Ci, trans, gs, gb, new_Tleaf, Pleaf
def func11(y, e, nlhc, indTC, residual, o, a, _s, p):
m, n = y.shape
if p.probType == "IP":
w = arange(m)
# TODO: omit recalculation from func1
ind = nanargmin(a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:], 1)
sup_inf_diff = 0.5 * (a[w, ind] - o[w, ind] + a[w, n + ind] -
o[w, n + ind])
diffao = a - o
minres_ind = nanargmin(diffao, 1)
minres = diffao[w, minres_ind]
complementary_minres = diffao[w,
where(minres_ind < n, minres_ind +
n, minres_ind - n)]
volume = prod(e - y, 1)
volumeResidual = volume * sup_inf_diff
F = 0.25 * (a[w, ind] + o[w, ind] + a[w, n + ind] + o[w, n + ind])
return [
si(IP_fields, sup_inf_diff[i], minres[i], minres_ind[i],
complementary_minres[i], y[i], e[i], o[i], a[i], _s[i], F[i],
volume[i], volumeResidual[i]) for i in range(m)
]
else:
residual = None
isSNLE = p.probType in ('SNLE', 'NLSP')
if 1 or not isSNLE:
o, a = asarray(o), asarray(a)
a[a == inf] = 1e300
o[o == -inf] = -1e300
tmp = a - o
tmp[tmp < 1e-300] = 1e-300
# ind_uf_inf = where(a==inf)[0]
# if ind_uf_inf.size:
# Tmp = o[ind_uf_inf]
# Tmp[Tmp==-inf] = -1e100
# M = nanmax(abs(Tmp))
# if M is nan or M == 0.0:
# M = 1.0
# tmp[ind_uf_inf] = 1e200 * (1.0 + Tmp/M)
nlhf = log2(tmp) #-log2(p.fTol)
# nlhf[a==inf] = 1e300# to make it not inf and nan
# nlhf[o==-inf] = 1e300# to make it not inf and nan
if p.probType == "MOP":
if nlhf.ndim == 3: # in MOP
nlhf = nlhf.sum(axis=1)
else:
assert 0, 'bug in interalg'
# make correct o,a wrt each target
return [
si(MOP_Fields, y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None,
[o[i][k]
for k in range(p.nf)], [a[i][k]
for k in range(p.nf)], _s[i])
for i in range(m)
]
else:
assert p.probType in ('GLP', 'NLP', 'NSP', 'SNLE', 'NLSP', 'MINLP',
'QP', 'LP', 'MILP')
if 0 and isSNLE:
nlhf = Tmp = o = a = [None] * m
else:
s, q = o[:, 0:n], o[:, n:2 * n]
Tmp = nanmax(where(q < s, q, s), 1)
nlhf[logical_and(isinf(a), isinf(nlhf))] = 1e300
# residual = None
return [
si(Fields, Tmp[i], y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None, o[i], a[i],
_s[i]) for i in range(m)
]
def func1(tnlhf, tnlhf_curr, residual, y, e, o, a, _s_prev, p, indT):
m, n = y.shape
w = arange(m)
if p.probType == 'IP':
oc_modL, oc_modU = o[:, :n], o[:, n:]
ac_modL, ac_modU = a[:, :n], a[:, n:]
# # TODO: handle nans
mino = where(oc_modL < oc_modU, oc_modL, oc_modU)
maxa = where(ac_modL < ac_modU, ac_modU, ac_modL)
# Prev
tmp = a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:]
t = nanargmin(tmp, 1)
d = 0.5 * tmp[w, t]
#New
# tmp = a - o
# t_ = nanargmin(tmp,1)
# t = t_% n
# d = tmp[w, t_]
# ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64')
ind = 2**(1.0 / n) * d >= _s_prev
#new
# ind = 2**(1.0/n) * d >= nanmax(maxa-mino, 1)
#ind = 2**(-n) >= (_s_prev - _s)/asarray(_s, 'float64')
#s2 = nanmin(maxa - mino, 1)
#print (abs(s2/_s))
# Prev
_s = nanmin(maxa - mino, 1)
# New
#_s = nanmax(maxa - mino, 1)
# _s = nanmax(a - o, 1)
#ind = _s_prev <= _s + ((2**-n / log(2)) if n > 15 else log2(1+2**-n))
indD = logical_not(ind)
indD = ind
indD = None
#print len(where(indD)[0]), len(where(logical_not(indD))[0])
# elif p.probType == 'MOP':
#
# raise 'unimplemented'
else:
if p.solver.dataHandling == 'sorted':
_s = func13(o, a)
t = nanargmin(a, 1) % n
d = nanmax([a[w, t] - o[w, t], a[w, n + t] - o[w, n + t]], 0)
## !!!! Don't replace it by (_s_prev /d- 1) to omit rounding errors ###
#ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64')
#NEW
ind = d >= _s_prev / 2**(1.0e-12 / n)
#ind = d >= _s_prev / 2 ** (1.0/n)
indD = empty(m, bool)
indD.fill(True)
#ind.fill(False)
###################################################
elif p.solver.dataHandling == 'raw':
if p.probType == 'MOP':
t = p._t[:m]
p._t = p._t[m:]
d = _s = p.__s[:m]
p.__s = p.__s[m:]
else:
# tnlh_1, tnlh_2 = tnlhf[:, 0:n], tnlhf[:, n:]
# TNHLF_min = where(logical_or(tnlh_1 > tnlh_2, isnan(tnlh_1)), tnlh_2, tnlh_1)
# # Set _s
# _s = nanmin(TNHLF_min, 1)
T = tnlhf_curr
tnlh_curr_1, tnlh_curr_2 = T[:, 0:n], T[:, n:]
TNHL_curr_min = where(
logical_or(tnlh_curr_1 < tnlh_curr_2, isnan(tnlh_curr_2)),
tnlh_curr_1, tnlh_curr_2)
t = nanargmin(TNHL_curr_min, 1)
T = tnlhf
d = nanmin(vstack(([T[w, t], T[w, n + t]])), 0)
_s = d
#OLD
#!#!#!#! Don't replace it by _s_prev - d <= ... to omit inf-inf = nan !#!#!#
#ind = _s_prev <= d + ((2**-n / log(2)) if n > 15 else log2(1+2**-n))
#ind = _s_prev - d <= ((2**-n / log(2)) if n > 15 else log2(1+2**-n))
#NEW
if any(_s_prev < d):
pass
ind = _s_prev <= d + 1.0 / n
# T = TNHL_curr_min
#ind2 = nanmin(TNHL_curr_min, 0)
indQ = d >= _s_prev - 1.0 / n
#indQ = logical_and(indQ, False)
indD = logical_or(indQ, logical_not(indT))
# print '------'
# print indQ[:10]
# print indD[:10]
# print _s_prev[:2], d[:2]
#print len(where(indD)[0]), len(where(indQ)[0]), len(where(indT)[0])
#print _s_prev - d
###################################################
#d = ((tnlh[w, t]* tnlh[w, n+t])**0.5)
else:
assert 0
if any(ind):
r10 = where(ind)[0]
#print('r10:', r10)
# print _s_prev
# print ((_s_prev -d)*n)[r10]
# print('ind length: %d' % len(where(ind)[0]))
# print where(ind)[0].size
#bs = e[ind] - y[ind]
#t[ind] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well
bs = e[r10] - y[r10]
t[r10] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well
return t, _s, indD
def mtx_minimise(p,
trans,
all_Cis,
photo,
Vmax25=None,
all_Ccs=None,
inf_gb=False):
"""
Uses matrices to find each value of Ci for which An(supply) ~
An(demand) on the transpiration stream.
Arguments:
----------
p: recarray object or pandas series or class containing the data
time step's met data & params
trans: array
transpiration [mol m-2 s-1], values depending on the possible
leaf water potentials (P) and the Weibull parameters b, c
all_Cis: array
all potential Ci values over the transpiration stream (for each
water potential, Ci values can be anywhere between a lower bound
and Cs)
photo: string
either the Farquhar model for photosynthesis, or the Collatz
model
inf_gb: bool
if True, gb is prescrived and very large
Returns:
--------
The value of Ci for which An(supply) is the closest to An(demand)
(e.g. An(supply) - An(demand) closest to zero).
"""
if Vmax25 is not None:
demand, __, __ = calc_photosynthesis(p,
np.expand_dims(trans, axis=1),
all_Cis,
photo,
Vmax25=np.expand_dims(Vmax25,
axis=1),
inf_gb=inf_gb)
elif all_Ccs is not None:
demand, __, __ = calc_photosynthesis(p,
np.expand_dims(trans, axis=1),
all_Ccs,
photo,
inf_gb=inf_gb)
else:
demand, __, __ = calc_photosynthesis(p,
np.expand_dims(trans, axis=1),
all_Cis,
photo,
inf_gb=inf_gb)
supply = A_trans(p, np.expand_dims(trans, axis=1), all_Cis, inf_gb=inf_gb)
# find the meeting point between demand and supply
idx = bn.nanargmin(np.abs(supply - demand), axis=1) # closest ~0
if all_Ccs is not None:
all_Cis = all_Ccs
# each Ci on the transpiration stream
Ci = np.asarray([all_Cis[e, idx[e]] for e in range(len(trans))])
Ci = np.ma.masked_where(idx == 0, Ci)
Ci = np.ma.masked_where(idx == all_Cis.shape[1] - 1, Ci)
return Ci
def argf(self, *args, **kwargs):
return bn.nanargmin(*args, **kwargs)
def func1(tnlhf, tnlhf_curr, residual, y, e, o, a, _s_prev, p, indT):
m, n = y.shape
w = arange(m)
if p.probType == 'IP':
oc_modL, oc_modU = o[:, :n], o[:, n:]
ac_modL, ac_modU = a[:, :n], a[:, n:]
# # TODO: handle nans
mino = where(oc_modL < oc_modU, oc_modL, oc_modU)
maxa = where(ac_modL < ac_modU, ac_modU, ac_modL)
# Prev
tmp = a[:, 0:n]-o[:, 0:n]+a[:, n:]-o[:, n:]
t = nanargmin(tmp,1)
d = 0.5*tmp[w, t]
#New
# tmp = a - o
# t_ = nanargmin(tmp,1)
# t = t_% n
# d = tmp[w, t_]
# ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64')
ind = 2**(1.0/n) * d >= _s_prev
#new
# ind = 2**(1.0/n) * d >= nanmax(maxa-mino, 1)
#ind = 2**(-n) >= (_s_prev - _s)/asarray(_s, 'float64')
#s2 = nanmin(maxa - mino, 1)
#print (abs(s2/_s))
# Prev
_s = nanmin(maxa - mino, 1)
# New
#_s = nanmax(maxa - mino, 1)
# _s = nanmax(a - o, 1)
#ind = _s_prev <= _s + ((2**-n / log(2)) if n > 15 else log2(1+2**-n))
indD = logical_not(ind)
indD = ind
indD = None
#print len(where(indD)[0]), len(where(logical_not(indD))[0])
# elif p.probType == 'MOP':
#
# raise 'unimplemented'
else:
if p.solver.dataHandling == 'sorted':
_s = func13(o, a)
t = nanargmin(a, 1) % n
d = nanmax([a[w, t] - o[w, t],
a[w, n+t] - o[w, n+t]], 0)
## !!!! Don't replace it by (_s_prev /d- 1) to omit rounding errors ###
#ind = 2**(-n) >= (_s_prev - d)/asarray(d, 'float64')
#NEW
ind = d >= _s_prev / 2 ** (1.0e-12/n)
#ind = d >= _s_prev / 2 ** (1.0/n)
indD = empty(m, bool)
indD.fill(True)
#ind.fill(False)
###################################################
elif p.solver.dataHandling == 'raw':
if p.probType == 'MOP':
t = p._t[:m]
p._t = p._t[m:]
d = _s = p.__s[:m]
p.__s = p.__s[m:]
else:
# tnlh_1, tnlh_2 = tnlhf[:, 0:n], tnlhf[:, n:]
# TNHLF_min = where(logical_or(tnlh_1 > tnlh_2, isnan(tnlh_1)), tnlh_2, tnlh_1)
# # Set _s
# _s = nanmin(TNHLF_min, 1)
T = tnlhf_curr
tnlh_curr_1, tnlh_curr_2 = T[:, 0:n], T[:, n:]
TNHL_curr_min = where(logical_or(tnlh_curr_1 < tnlh_curr_2, isnan(tnlh_curr_2)), tnlh_curr_1, tnlh_curr_2)
t = nanargmin(TNHL_curr_min, 1)
T = tnlhf
d = nanmin(vstack(([T[w, t], T[w, n+t]])), 0)
_s = d
#OLD
#!#!#!#! Don't replace it by _s_prev - d <= ... to omit inf-inf = nan !#!#!#
#ind = _s_prev <= d + ((2**-n / log(2)) if n > 15 else log2(1+2**-n))
#ind = _s_prev - d <= ((2**-n / log(2)) if n > 15 else log2(1+2**-n))
#NEW
if any(_s_prev < d):
pass
ind = _s_prev <= d + 1.0/n
# T = TNHL_curr_min
#ind2 = nanmin(TNHL_curr_min, 0)
indQ = d >= _s_prev - 1.0/n
#indQ = logical_and(indQ, False)
indD = logical_or(indQ, logical_not(indT))
# print _s_prev[:2], d[:2]
#print len(where(indD)[0]), len(where(indQ)[0]), len(where(indT)[0])
#print _s_prev - d
###################################################
#d = ((tnlh[w, t]* tnlh[w, n+t])**0.5)
else:
assert 0
if any(ind):
r10 = where(ind)[0]
#print('r10:', r10)
# print _s_prev
# print ((_s_prev -d)*n)[r10]
# print('ind length: %d' % len(where(ind)[0]))
# print where(ind)[0].size
#bs = e[ind] - y[ind]
#t[ind] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well
bs = e[r10] - y[r10]
t[r10] = nanargmax(bs, 1) # ordinary numpy.argmax can be used as well
return t, _s, indD
def r14MOP(p, nlhc, residual, definiteRange, y, e, vv, asdf1, C, r40, g, nNodes, \
r41, fTol, Solutions, varTols, _in, dataType, \
maxNodes, _s, indTC, xRecord):
assert p.probType == 'MOP'
if len(p._discreteVarsNumList):
y, e = adjustDiscreteVarBounds(y, e, p)
if p.nProc != 1 and getattr(p, 'pool', None) is None:
p.pool = Pool(processes = p.nProc)
elif p.nProc == 1:
p.pool = None
ol, al = [], []
targets = p.targets # TODO: check it
m, n = y.shape
ol, al = [[] for k in range(m)], [[] for k in range(m)]
for i, t in enumerate(targets):
o, a, definiteRange = func82(y, e, vv, t.func, dataType, p)
o, a = o.reshape(2*n, m).T, a.reshape(2*n, m).T
for j in range(m):
ol[j].append(o[j])
al[j].append(a[j])
#ol.append(o.reshape(2*n, m).T.tolist())
#al.append(a.reshape(2*n, m).T.tolist())
nlhf = r43(targets, Solutions.F, ol, al, p.pool, p.nProc)
fo_prev = 0
# TODO: remove NaN nodes here
if y.size == 0:
return _in, g, fo_prev, _s, Solutions, xRecord, r41, r40
nodes = func11(y, e, nlhc, indTC, residual, ol, al, _s, p)
#y, e = func4(y, e, o, a, fo)
assert p.solver.dataHandling == 'raw', '"sorted" mode is unimplemented for MOP yet'
if nlhf is None:
new_nodes_tnlh_all = nlhc
elif nlhc is None:
new_nodes_tnlh_all = nlhf
else:
new_nodes_tnlh_all = nlhf + nlhc
asdf1 = [t.func for t in p.targets]
r5F, r5Coords = getr4Values(vv, y, e, new_nodes_tnlh_all, asdf1, C, p.contol, dataType, p)
nIncome, nOutcome = r44(Solutions, r5Coords, r5F, targets, p.solver.sigma)
fo = 0 # unused for MOP
# TODO: better of nlhc for unconstrained probs
if len(_in) != 0:
an = hstack((nodes, _in))
else:
an = atleast_1d(nodes)
hasNewParetoNodes = False if nIncome == 0 else True
if hasNewParetoNodes:
ol2 = [node.o for node in an]
al2 = [node.a for node in an]
nlhc2 = [node.nlhc for node in an]
nlhf2 = r43(targets, Solutions.F, ol2, al2, p.pool, p.nProc)
tnlh_all = asarray(nlhc2) if nlhf2 is None else nlhf2 if nlhc2[0] is None else asarray(nlhc2) + nlhf2
else:
tnlh_all = vstack([new_nodes_tnlh_all] + [node.tnlh_all for node in _in]) if len(_in) != 0 else new_nodes_tnlh_all
for i, node in enumerate(nodes):
node.tnlh_all = tnlh_all[i]
r10 = logical_not(any(isfinite(tnlh_all), 1))
if any(r10):
ind = where(logical_not(r10))[0]
#an = take(an, ind, axis=0, out=an[:ind.size])
an = asarray(an[ind])
tnlh_all = take(tnlh_all, ind, axis=0, out=tnlh_all[:ind.size])
# else:
# tnlh_all = hstack([node.tnlh_all for node in an])
T1, T2 = tnlh_all[:, :tnlh_all.shape[1]/2], tnlh_all[:, tnlh_all.shape[1]/2:]
T = where(logical_or(T1 < T2, isnan(T2)), T1, T2)
t = nanargmin(T, 1)
w = arange(t.size)
NN = T[w, t].flatten()
for i, node in enumerate(an):
node.tnlh_all = tnlh_all[i]
node.tnlh_curr_best = NN[i]
astnlh = argsort(NN)
an = an[astnlh]
p._t = t
# TODO: form _s in other level (for active nodes only), to reduce calculations
if len(an) != 0:
nlhf_fixed = asarray([node.nlhf for node in an])
nlhc_fixed = asarray([node.nlhc for node in an])
T = nlhf_fixed + nlhc_fixed if nlhc_fixed[0] is not None else nlhf_fixed
p.__s = \
nanmin(vstack(([T[w, t], T[w, n+t]])), 0)
else:
p.__s = array([])
# p._nObtainedSolutions = len(solutions)
# if p._nObtainedSolutions > maxSolutions:
# solutions = solutions[:maxSolutions]
# p.istop = 0
# p.msg = 'user-defined maximal number of solutions (p.maxSolutions = %d) has been exeeded' % p.maxSolutions
# return an, g, fo, None, solutions, coords, xRecord, r41, r40
# TODO: fix it
p._frontLength = len(Solutions.F)
p._nIncome = nIncome
p._nOutcome = nOutcome
p.iterfcn(p.x0)
#print('iter: %d (%d) frontLenght: %d' %(p.iter, itn, len(Solutions.coords)))
if p.istop != 0:
return an, g, fo, None, Solutions, xRecord, r41, r40
#an, g = func9(an, fo, g, p)
nn = maxNodes#1 if asdf1.isUncycled and all(isfinite(o)) and p._isOnlyBoxBounded and not p.probType.startswith('MI') else maxNodes
an, g = func5(an, nn, g, p)
nNodes.append(len(an))
return an, g, fo, _s, Solutions, xRecord, r41, r40
def solve_std(p, sw, photo='Farquhar', res='low', iter_max=40,
threshold_conv=0.1, inf_gb=False):
"""
Checks the energy balance by looking for convergence of the new leaf
temperature with the leaf temperature predicted by the previous
iteration. Then returns the corresponding An, E, Ci, etc.
Arguments:
----------
p: recarray object or pandas series or class containing the data
time step's met data & params
sw: float
mean volumetric soil moisture content [m3 m-3]
photo: string
either the Farquhar model for photosynthesis, or the Collatz
model
threshold_conv: float
convergence threshold for the new leaf temperature to be in
energy balance
iter_max: int
maximum number of iterations allowed on the leaf temperature
before reaching the conclusion that the system is not energy
balanced
inf_gb: bool
if True, gb is prescrived and very large
Returns:
--------
trans_can: float
transpiration rate of canopy [mmol m-2 s-1] across leaves
gs_can: float
stomatal conductance of canopy [mol m-2 s-1] across leaves
An_can: float
C assimilation rate of canopy [umol m-2 s-1] across leaves
Ci_can: float
average intercellular CO2 concentration of canopy [Pa] across
leaves
rublim_can: string
'True' if the C assimilation is rubisco limited, 'False'
otherwise.
"""
# initial state
Cs = p.CO2 # Pa
Tleaf = p.Tair # deg C
Dleaf = np.maximum(0.05, p.VPD) # gs model not valid < 0.05
# hydraulics
P, E = hydraulics(p, res=res)
if sw >= p.fc:
g1 = p.g1
else:
g1 = p.g1 * fwWP(p, p.Ps)
# initialise gs over A
g0 = 1.e-9 # g0 ~ 0, removing it entirely introduces errors
Cs_umol_mol = Cs * conv.MILI / p.Patm # umol mol-1
gsoA = g0 + (1. + g1 / (Dleaf ** 0.5)) / Cs_umol_mol
# iter on the solution until it is stable enough
iter = 0
while True:
An, Aj, Ac, Ci = calc_photosynthesis(p, 0., Cs, photo, Tleaf=Tleaf,
gs_over_A=gsoA)
# stomatal conductance, with moisture stress effect
gs = np.maximum(cst.zero, conv.GwvGc * gsoA * An)
# calculate new trans, gw, gb, mol.m-2.s-1
trans, real_zero, gw, gb, Dleaf = calc_trans(p, Tleaf, gs,
inf_gb=inf_gb)
new_Tleaf, __ = leaf_temperature(p, trans, Tleaf=Tleaf, inf_gb=inf_gb)
# update Cs (Pa)
boundary_CO2 = p.Patm * conv.FROM_MILI * An / (gb * conv.GbcvGb)
Cs = np.maximum(cst.zero, np.minimum(p.CO2, p.CO2 - boundary_CO2))
Cs_umol_mol = Cs * conv.MILI / p.Patm
# new leaf-air vpd, kPa
if (np.isclose(trans, cst.zero, rtol=cst.zero, atol=cst.zero) or
np.isclose(gw, cst.zero, rtol=cst.zero, atol=cst.zero) or
np.isclose(gs, cst.zero, rtol=cst.zero, atol=cst.zero)):
Dleaf = np.maximum(0.05, p.VPD) # kPa
# update gs over A
gsoA = g0 + (1. + g1 / (Dleaf ** 0.5)) / Cs_umol_mol
# force stop when atm. conditions yield E < 0. (non-physical)
if (iter < 1) and (not real_zero):
real_zero = None
# check for convergence
if ((real_zero is None) or (iter >= iter_max) or ((iter >= 1) and
real_zero and (abs(Tleaf - new_Tleaf) <= threshold_conv) and not
np.isclose(gs, cst.zero, rtol=cst.zero, atol=cst.zero))):
break
# no convergence, iterate on leaf temperature
Tleaf = new_Tleaf
iter += 1
Pleaf = P[bn.nanargmin(np.abs(trans - E))]
rublim = rubisco_limit(Aj, Ac) # lim?
if ((np.isclose(trans, cst.zero, rtol=cst.zero, atol=cst.zero) and
(An > 0.)) or np.isclose(Ci, 0., rtol=cst.zero, atol=cst.zero) or
(Ci < 0.) or np.isclose(Ci, p.CO2, rtol=cst.zero, atol=cst.zero) or
(Ci > p.CO2) or (real_zero is None) or (not real_zero) or
any(np.isnan([An, Ci, trans, gs, new_Tleaf, Pleaf]))):
An, Ci, trans, gs, gb, new_Tleaf, Pleaf = (9999.,) * 7
elif not np.isclose(trans, cst.zero, rtol=cst.zero, atol=cst.zero):
trans *= conv.MILI # mmol.m-2.s-1
return An, Ci, rublim, trans, gs, gb, new_Tleaf, Pleaf
def compute_integral(self, x_s, y_s):
if len(x_s) == 0:
return np.zeros((y_s.shape[0],)) * np.nan
closer = bottleneck.nanargmin(abs(x_s - self.limits[0]))
return y_s[:, closer]
def func11(y, e, nlhc, indTC, residual, o, a, _s, p):
m, n = y.shape
if p.probType == "IP":
w = arange(m)
# TODO: omit recalculation from func1
ind = nanargmin(a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:], 1)
sup_inf_diff = 0.5 * (a[w, ind] - o[w, ind] + a[w, n + ind] -
o[w, n + ind])
diffao = a - o
minres_ind = nanargmin(diffao, 1)
minres = diffao[w, minres_ind]
complementary_minres = diffao[w,
where(minres_ind < n, minres_ind +
n, minres_ind - n)]
volume = prod(e - y, 1)
volumeResidual = volume * sup_inf_diff
F = 0.25 * (a[w, ind] + o[w, ind] + a[w, n + ind] + o[w, n + ind])
return [
si(IP_fields, sup_inf_diff[i], minres[i], minres_ind[i],
complementary_minres[i], y[i], e[i], o[i], a[i], _s[i], F[i],
volume[i], volumeResidual[i]) for i in range(m)
]
else:
residual = None
tmp = asarray(a) - asarray(o)
tmp[tmp < 1e-300] = 1e-300
nlhf = log2(tmp) #-log2(p.fTol)
# nlhf[a==inf] = 1e300# to make it not inf and nan
# nlhf[o==-inf] = 1e300# to make it not inf and nan
if nlhf.ndim == 3: # in MOP
nlhf = nlhf.sum(axis=1)
if p.probType == "MOP":
# make correct o,a wrt each target
return [
si(MOP_Fields, y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None,
[o[i][k]
for k in range(p.nf)], [a[i][k]
for k in range(p.nf)], _s[i])
for i in range(m)
]
else:
s, q = o[:, 0:n], o[:, n:2 * n]
Tmp = nanmax(where(q < s, q, s), 1)
nlhf[logical_and(isinf(a), isinf(nlhf))] = 1e300
assert p.probType in ('GLP', 'NLP', 'NSP', 'SNLE', 'NLSP', 'MINLP')
# residual = None
return [
si(Fields, Tmp[i], y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None, o[i], a[i],
_s[i]) for i in range(m)
]
if (iter < 1) and (not real_zero):
real_zero = None
# check for convergence
if ((real_zero is None) or (iter >= iter_max) or
((iter >= 1) and real_zero and
(abs(Tleaf - new_Tleaf) <= threshold_conv)
and not np.isclose(gs, cst.zero, rtol=cst.zero, atol=cst.zero))):
break
# no convergence, iterate on leaf temperature
Tleaf = new_Tleaf
iter += 1
if case == 1: # infer leaf water potential, MPa
Pleaf = P[bn.nanargmin(np.abs(E - trans))]
else:
Pleaf = P[iopt]
ksc = p.kmaxS2 * cost[iopt]
rublim = rubisco_limit(Aj, Ac) # lim?
if ((np.isclose(trans, cst.zero, rtol=cst.zero, atol=cst.zero) and
(An > 0.)) or np.isclose(Ci, 0., rtol=cst.zero, atol=cst.zero)
or (Ci < 0.) or np.isclose(Ci, p.CO2, rtol=cst.zero, atol=cst.zero)
or (Ci > p.CO2) or (real_zero is None) or (not real_zero)
or any(np.isnan([An, Ci, trans, gs, new_Tleaf, Pleaf]))):
An, Ci, trans, gs, gb, new_Tleaf, Pleaf = (9999., ) * 7
elif not np.isclose(trans, cst.zero, rtol=cst.zero, atol=cst.zero):
def func11(y, e, nlhc, indTC, residual, o, a, _s, p):
m, n = y.shape
if p.probType == "IP":
w = arange(m)
# TODO: omit recalculation from func1
ind = nanargmin(a[:, 0:n] - o[:, 0:n] + a[:, n:] - o[:, n:], 1)
sup_inf_diff = 0.5*(a[w, ind] - o[w, ind] + a[w, n+ind] - o[w, n+ind])
diffao = a - o
minres_ind = nanargmin(diffao, 1)
minres = diffao[w, minres_ind]
complementary_minres = diffao[w, where(minres_ind<n, minres_ind+n, minres_ind-n)]
volume = prod(e-y, 1)
volumeResidual = volume * sup_inf_diff
F = 0.25 * (a[w, ind] + o[w, ind] + a[w, n+ind] + o[w, n+ind])
return [si(IP_fields, sup_inf_diff[i], minres[i], minres_ind[i], complementary_minres[i], y[i], e[i], o[i], a[i], _s[i], F[i], volume[i], volumeResidual[i]) for i in range(m)]
else:
residual = None
isSNLE = p.probType in ('SNLE', 'NLSP')
if 1 or not isSNLE:
o, a = asarray(o), asarray(a)
a[a==inf] = 1e300
o[o==-inf] = -1e300
tmp = a - o
tmp[tmp<1e-300] = 1e-300
# ind_uf_inf = where(a==inf)[0]
# if ind_uf_inf.size:
# Tmp = o[ind_uf_inf]
# Tmp[Tmp==-inf] = -1e100
# M = nanmax(abs(Tmp))
# if M is nan or M == 0.0:
# M = 1.0
# tmp[ind_uf_inf] = 1e200 * (1.0 + Tmp/M)
nlhf = log2(tmp)#-log2(p.fTol)
# nlhf[a==inf] = 1e300# to make it not inf and nan
# nlhf[o==-inf] = 1e300# to make it not inf and nan
if p.probType == "MOP":
if nlhf.ndim == 3: # in MOP
nlhf = nlhf.sum(axis=1)
else:
assert 0, 'bug in interalg'
# make correct o,a wrt each target
return [si(MOP_Fields, y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None,
[o[i][k] for k in range(p.nf)], [a[i][k] for k in range(p.nf)],
_s[i]) for i in range(m)]
else:
assert p.probType in ('GLP', 'NLP', 'NSP', 'SNLE', 'NLSP', 'MINLP', 'QP', 'LP', 'MILP')
if 0 and isSNLE:
nlhf = Tmp = o = a = [None]*m
else:
s, q = o[:, 0:n], o[:, n:2*n]
Tmp = nanmax(where(q<s, q, s), 1)
nlhf[logical_and(isinf(a), isinf(nlhf))] = 1e300
# residual = None
return [si(Fields, Tmp[i], y[i], e[i], nlhf[i],
nlhc[i] if nlhc is not None else None,
indTC[i] if indTC is not None else None,
residual[i] if residual is not None else None,
o[i], a[i], _s[i]) for i in range(m)]
def argf(self, *args, **kwargs): return bn.nanargmin(*args, **kwargs) class nanmax(A_extremum):
