def test_NumericCompartmentalMatrixFunc(self):
for n in self.symbol_names:
var(n)
k_1o = Function("k_1o")
sym_B = hr.compartmental_matrix_2(self.out_fluxes_by_symbol,
self.internal_fluxes_by_symbol,
self.state_variables)
par_dict = {
k_01: 1 / 100, # 1/year
k_10: 1 / 100, # 1/year
k_0o: 1 / 2, # 1/year
}
def k_1o_func(t):
omega = 2 * pi # 1/year
phi = pi / 8
V_0 = 20 # kilogram/year
V_range = 5 # kilogram/year
u_res = V_0 + V_range * sin(omega * t + phi)
return u_res
func_dict = {'k_1o': k_1o_func}
para_num = NumericParameterization(par_dict, func_dict)
start_values_num = np.array([1, 2]) # kg
times_num = NumericSimulationTimes(np.linspace(0, 20, 16))
B_func = numericCompartmentalMatrixFunc(sym_B, self.state_variables,
self.time_symbol, para_num)
npsrm = numeric_parameterized_smooth_reservoir_model_1(
srm=self.srm, para_num=para_num)
smr = numeric_model_run_1(npsrm, start_values_num, times_num)
xs = numeric_solution_array_1(smr)
ress = numericCompartmentalMatrixSolutionTuple(xs, times_num, B_func)
def test_solve_num(self):
C_0, C_1, t, k_01, k_10, k_0o = (
Symbol(s) for s in ("C_0", "C_1", "t", "k_01", "k_10", "k_0o")
)
k_1o = Function("k_1o")
par_dict = {
k_01: 1 / 100, # 1/year
k_10: 1 / 100, # 1/year
k_0o: 1 / 2, # 1/year
}
def k_1o_func(t):
omega = 2 * pi # 1/year
phi = pi / 8
V_0 = 20 # kilogram/year
V_range = 5 # kilogram/year
u_res = V_0 + V_range * sin(omega * t + phi)
return u_res
para = NumericParameterization(
par_dict=par_dict,
func_dict={k_1o: k_1o_func}
)
npsrm = NumericParameterizedSmoothReservoirModel(
srm=self.srm, parameterization=para
)
# The parameterdict and the functions, possibly even the matrix/flux
# expressions have implicit unit assumption, which the user is required
# to maintain consistently. To make modelruns comparable it is
# important to remember the units for which this consistency can be
# guaranteed.
# A model run can then adapt the units of times and masses since it
times_num = np.linspace(0, 20, 16)
start_values_num = NumericStartValueArray([1, 2])
# start_values_dict = frozendict({C_0: 1,C_1: 2})
# would be a bit more intuitive but both formulations
# rely on the information stored in the model
nmr = numeric_model_run_1(npsrm, start_values_num, times_num)
print(nmr.solve())
#Model based on Fig. 1 in page 127 (3 in the PDF) of doi= "10.1016/0304-3800(88)90112-3", no ODEs in publication
t = TimeSymbol("t") #"the model has a daily and a yearly component. Allocation occurs yearly"
x = StateVariableTuple((C_f, C_r, C_w,C_frl,C_s))
b = ImmutableMatrix((eta_f, eta_w, eta_r))
Input = InputTuple(tuple(u * b)+(0,0))
A = CompartmentalMatrix(
[[-gamma_f, 0 , 0 , (l_p*eta_f) ,(s_p*eta_f)],
[ 0 ,-gamma_r, 0 , (l_p*eta_r) ,(s_p*eta_r)],
[ 0 , 0 ,-gamma_w, (l_p*eta_w) ,(s_p*eta_w)],
[ gamma_f, gamma_r, gamma_w, -(l_p+l_s+l_dr), 0 ],
[ 0 , 0 , 0 , l_s ,-(s_p+s_dr)]
])
## The following are default values suggested by this entry's creator only to be able to run the model:
np1 = NumericParameterization(
par_dict={u: 1400, eta_f: 0.48, eta_r: 0.44, eta_w: 0.49, gamma_r: 3.03, gamma_f: 23.32, gamma_w: 0.04},
func_dict=frozendict({})
)
nsv1 = NumericStartValueDict({
C_f: 200,
C_w: 5000,
C_r: 300
})
ntimes = NumericSimulationTimes(np.arange(0, 20000, 0.01))
# doi: 10.1016/0304-3800(88)90112-3
np2 = NumericParameterization(
par_dict={
eta_f: Rational(25,100), eta_r: Rational(40,100), eta_w: Rational(35,100), gamma_r: Rational(40,100), gamma_f: Rational(33,100), gamma_w: Rational(0,100)},
func_dict=frozendict({})
np1 = NumericParameterization(
par_dict={
a_f: 0.16
# ,buf:
# ,bvr:
# ,bmf:
# ,bmr:
# ,bam:
# ,ban:
# ,bau:
# ,bav:
,
baw: 0.413,
bas: 0.42,
bsa: 0.35
# ,bsu:
# ,bsv:
,
bsw: 0.175,
bps: 0.032,
bpa: 0.004,
bap: 0.45,
s_f: 0.12 #"year^{-1}"
,
s_r: 1.0 #"year^{-1}"
,
s_w: 0.0069 #"year^{-1}"
},
func_dict=frozendict({})
# state_var_units=kgC*m^{-2}
# time_unit=year
)
[0, 0, 0, 0, f_75, f_76, -c_7, 0],
[0, 0, 0, 0, 0, f_86, f_87, -c_8]])
np1 = NumericParameterization(par_dict={
GPP: 3.370,
b_1: 0.14,
b_2: 0.26,
b_3: 0.14,
f_41: 0.9,
f_51: 0.1,
f_52: 1,
f_43: 0.2,
f_53: 0.8,
f_64: 0.45,
f_65: 0.275,
f_75: 0.275,
f_76: 0.296,
f_86: 0.004,
f_67: 0.42,
f_87: 0.01,
f_68: 0.45,
c_1: 0.00258,
c_2: 0.0000586,
c_3: 0.002390,
c_4: 0.0109,
c_5: 0.00095,
c_6: 0.0105,
c_7: 0.0000995,
c_8: 0.0000115
},
func_dict=frozendict({}))
# "Initial values as in Wang and Luo"
nsv1 = NumericStartValueDict({
LIT_A / C_A, LIT_S / C_S, LIT_L / C_L, LIT_R / C_R, 0, 0,
-DEC_LIT / C_LIT, 0, 0
], [0, 0, 0, 0, LIT_WL / C_WL, LIT_WR / C_WR, 0, -DEC_CWD / C_CWD, 0],
[
0, 0, 0, 0, 0, 0, ((1 - c_lit_atm) * DEC_LIT) / C_LIT,
((1 - c_cwd_atm) * DEC_CWD) / C_CWD, -DEC_SOIL / C_SOIL
]])
t = TimeSymbol("t") # "day"
np1 = NumericParameterization(
par_dict={
c_lit_atm: 0.77,
c_cwd_atm: 0.2,
tau_LIT: 2.05 # "yr"
,
tau_CWD: 60 # "yr"
,
tau_SOIL: 100 # "yr"
,
Q_10h: 1.4
},
func_dict=frozendict({}))
mvs = CMTVS(
{
BibInfo( # Bibliographical Information
name="JeDi-DGVM",
longName="The Jena Diversity-Dynamic Global Vegetation Model",
version="1",
entryAuthor="Verónika Ceballos-Núñez",
entryAuthorOrcid="0000-0002-0046-1160",
Input = InputTuple(u * ImmutableMatrix(b))
A = CompartmentalMatrix(diag(-gamma_f, -gamma_w, -gamma_r))
t = TimeSymbol("t")
# "Original parameters of the publication. Parameter value of GPP corresponds to an annual average"
# T, Q_10, and W are variables that should be looked at in a data set. What I have here are invented values
np1 = NumericParameterization(
par_dict={
Q_10: 1,
W: 4.2,
T: 25,
GPP: 3370, #"gC*day^{-1}"
eta_f: 0.14,
eta_r: 0.26,
eta_w: 0.14,
gamma_f: 0.00258,
gamma_w: 0.0000586,
gamma_r: 0.00239
},
func_dict=frozendict({})
# state_var_units=gram/kilometer**2,
# time_unit=day
)
nsv1 = NumericStartValueDict({C_f: 250, C_w: 4145, C_r: 192})
ntimes = NumericSimulationTimes(np.arange(0, 150, 2.5))
mvs = MVarSet({
BibInfo( # Bibliographical Information
name="",
], [0, 0, 0, 0, f_stlit2slowsom, f_fastsom2slowsom, -cr_slowsom, 0],
[0, 0, 0, 0, 0, f_fastsom2passsom, f_slowsom2passsom, -cr_passsom]])
np1 = NumericParameterization(par_dict={
GPP: 3.370,
b_foliage: 0.14,
b_roots: 0.26,
b_wood: 0.14,
f_foliage2metlit: 0.9,
f_foliage2stlit: 0.1,
f_wood2stlit: 1,
f_roots2metlit: 0.2,
f_roots2stlit: 0.8,
f_metlit2fastsom: 0.45,
f_stlit2fastsom: 0.275,
f_stlit2slowsom: 0.275,
f_fastsom2slowsom: 0.296,
f_fastsom2passsom: 0.004,
f_slowsom2fastsom: 0.42,
f_slowsom2passsom: 0.01,
f_passsom2fastsom: 0.45,
cr_foliage: 0.00258,
cr_wood: 0.0000586,
cr_root: 0.002390,
cr_metlit: 0.0109,
cr_stlit: 0.00095,
cr_fastsom: 0.0105,
cr_slowsom: 0.0000995,
cr_passsom: 0.0000115
},
func_dict=frozendict({}))
# "Initial values as in Wang and Luo"
nsv1 = NumericStartValueDict({
xi = f_T * f_W #environmental effects multiplier (DEFAG)
A = ([-k_1, 0, 0, 0, 0, 0,
0], [0, -K_2, 0, 0, 0, 0,
0], [0, 0, -k_3, 0, 0, 0, 0], [0, 0, 0, -K_4, 0, 0, 0], [
alpha_51 * k_1, 0.45 * K_2, alpha_53 * k_3, 0.45 * K_4, -k_5,
0.42 * K_6, 0.45 * K_7
], [alpha_61 * k_1, 0, alpha_63 * k_3, 0, alpha_65 * k_5, -K_6,
0], [0, 0, 0, 0, 0.004 * k_5, 0.03 * K_6, -K_7])
B = CompartmentalMatrix(xi * ImmutableMatrix(A))
#Original values without effects of temperature and soil moisture:
np1 = NumericParameterization(par_dict={
K_1: 0.076,
K_2: 0.28,
K_3: 0.094,
K_4: 0.35,
K_5: 0.14,
K_6: 0.0038,
K_7: 0.00013,
xi: 1
},
func_dict=frozendict({}))
nsv1 = NumericStartValueDict({
C_1: 100,
C_2: 200,
C_3: 00,
C_4: 0,
C_5: 0,
C_6: 0,
C_7: 0
}) #faked values by Markus to make it run
#ntimes = NumericSimulationTimes(np.arange())
C_i = (B_L / (a_0L * (B_R + B_S + B_L)))
C_delta = A_CC * C - R_g
a_L = ((1 - C_i) / (3 + a_0R + a_0S - Q_i - G_i - C_i))
a_R = ((1 + a_0R - G_i) / (3 + a_0R + a_0S - Q_i - G_i - C_i))
a_S = ((1 + a_0S - Q_i) / (3 + a_0R + a_0S - Q_i - G_i - C_i))
t = TimeSymbol("t") # unit: "month"
x = StateVariableTuple((B_L, B_R, B_S))
u = C_delta
b = (a_L, a_R, a_S)
Input = InputTuple(u * ImmutableMatrix(b))
B = CompartmentalMatrix(diag(-gamma_f, -gamma_r, -gamma_w))
np1 = NumericParameterization(
par_dict={
a_0L: 0.3,
a_0R: 0.5,
a_0S: 0.2,
Q_i: 1
},
#Q_i: 1 when light is highly available (See sup. material 1, pg 17)
func_dict=frozendict({}))
mvs = CMTVS(
{
BibInfo( # Bibliographical Information
name="aDGVM",
longName="",
version="",
# modApproach= "individuals based"
entryAuthor="Verónika Ceballos-Núñez",
entryAuthorOrcid="0000-0002-0046-1160",
entryCreationDate="17/7/2015",
eta_w = 1 - eta_f - eta_r
x = StateVariableTuple((F, R, W))
u = G
b = (eta_f, eta_r, eta_w)
Input = InputTuple(u * ImmutableMatrix(b))
A = CompartmentalMatrix(diag(-gamma_f, -gamma_r, 0))
t = TimeSymbol("t") # units: days, years for allocation
#Parameter set: "Chosen based on the performance of Pinus radiata at Puruki, New Zeland":
## eta_ are not mentioned in the paper... probably the different values they gave to them were part of the hypothesis
np1 = NumericParameterization(
par_dict={
k: 0.5,
Phi_0: 2500, #"MJ*m*^{-2}*year^{-1}"
omega: 5, #"m*^2*kg^{-1}"
gamma_r: 2, #"kg^{-1}"
gamma_f: 0.5
}, #"kg^{-1}"
func_dict=frozendict({}))
mvs = MVarSet({
BibInfo( # Bibliographical Information
name="",
longName="",
version="1",
entryAuthor="Verónika Ceballos-Núñez",
entryAuthorOrcid="0000-0002-0046-1160",
entryCreationDate="29/7/2015",
doi="10.1093/treephys/12.2.119",
sym_dict=sym_dict),
mu_S = mu_max * S / (K_s * theta + S) # "hr^{-1}"
Exu = ExuM * exp(-ExuT * t) # "hr^{-1}"
x = StateVariableTuple((X, S))
u = InputTuple((0, BGF + Exu))
T = ImmutableMatrix([[-1, Y], [K_r, -1]])
N = ImmutableMatrix([[D_max * K_d / (K_d + S / theta), 0],
[0, X / Y * mu_max / (K_s * theta + S)]])
B = CompartmentalMatrix(T * N)
# Original values from linked model (no nitrogen cycle considered in this model here):
np1 = NumericParameterization(par_dict={
D_max: 0.26,
Y: 0.44,
K_s: 3.0,
theta: 0.23,
ExuT: 0.8,
BGF: 0.15,
K_d: 14.5,
K_r: 0.4,
ExuM: 8.0,
mu_max: 0.063
},
func_dict=frozendict({}))
# Standard version of BACWAVE, optimized to simulate bacterial biomass along wheat roots:
nsv1 = NumericStartValueDict({X: 0.5, S: 1.5}) # "Low"
nsv2 = NumericStartValueDict({X: 1.0, S: 2.5}) # "Medium"
nsv3 = NumericStartValueDict({X: 1.5, S: 4.0}) # "High"
ntimes = NumericSimulationTimes(np.arange(0, 2000, 0.1))
mvs = CMTVS(
{
xi = f_T * f_W # environmental effects multiplier
A = ImmutableMatrix([[ -k_1, 0 , 0, 0, 0],
[ 0, -k_2, 0, 0, 0],
[ a*k_1, a*k_2, -k_3+a*k_3, a*k_4, 0],
[ b*k_1, b*k_2, b*k_3,-k_4+b*k_4, 0],
[ 0, 0, 0, 0, 0]])
B = CompartmentalMatrix(xi * A)
# Original values without effects of temperature and soil moisture
# doi = {10.1007/978-3-642-61094-3_17},
np1 = NumericParameterization(
par_dict={
k_1: 10
,k_2: 0.3
,k_3: 0.66
,k_4: 0.02
,pClay: 23.4
,DR: 1.44
,J: 1.7
,xi: 1
},
func_dict=frozendict({})
)
mvs = CMTVS(
{
BibInfo(# Bibliographical Information
name="RothC-26.3",
longName="",
version="",
entryAuthor="Holger Metzler",
entryAuthorOrcid="0000-0002-8239-1601",
var(name)
t = TimeSymbol("t") # unit: "day"
x = StateVariableTuple((x_1, x_2, x_3, x_4, x_5))
u = InputTuple((I_1, 0, I_3, 0, 0))
B = CompartmentalMatrix([[-F_1, 0, 0, 0, 0], [F_21, -F_2, 0, 0, 0],
[0, 0, -F_3, 0, 0], [F_41, F_42, F_43, -F_4, 0],
[0, F_52, F_53, F_54, -F_5]])
np1 = NumericParameterization(par_dict={
I_1: 77,
I_3: 36,
F_1: 2.081,
F_2: 0.0686,
F_3: 0.5217,
F_4: 0.5926,
F_5: 9.813e-3,
F_21: 0.8378,
F_41: 0.5676,
F_42: 0.0322,
F_52: 4.425e-3,
F_43: 0.1739,
F_53: 0.0870,
F_54: 0.0370
},
func_dict=frozendict({}))
nsv1 = NumericStartValueDict({x_1: 37, x_2: 452, x_3: 69, x_4: 81, x_5: 1121})
ntimes = NumericSimulationTimes(np.arange(0, 200, 0.1))
mvs = CMTVS(
{
BibInfo( # Bibliographical Information
np1 = NumericParameterization(
par_dict={
NPP: Rational(409, 365), # *gram*/(meter**2*day)
# Note:
# The (negative ) parameter value for mint (see below) suggests that
# maxt and mint are given in the celsius scale.
# The sympy unit system does not destinguish between absolute
# temperature and celsius scale.
# Conceptually 5 deg Celsius describe a temperature DIFFERENCE of 5 Kelvin
# to the triple point of water.
# Differences are always mesured in Kelvin
# So although mint and maxt are given in Kelvin they are not understood
# as absolute temperatures but as differences to the triple point.
mint: -4, # Kelvin (deg Celsius)
maxt: 5, # Kelvin (de Celsius)
multtf: 0,
multtl: 1,
# p_2 :0.47,
p_3: 0.31,
p_4: 0.43,
p_5: 0.0027, # 1/day
p_6: 0.00000206, # 1/day
p_7: 0.00248, # 1/day
#
# Althouhg p10 is considered to have unit 1/Kelvin
# inspection of the T_rate expression connects it
# to Temperature DIFFERENCE from the triple point
p_10: 0.0693, # /kelvin
p_14: 0.45,
p_15: 0.001, # 1/day
p_16: 0.251,
},
func_dict=frozendict({})
# state_var_units=kilogram/meter**2,
# time_unit=day
)
Input = InputTuple(u * ImmutableMatrix(b))
A = CompartmentalMatrix(diag(-tau_f, -tau_r, -tau_w))
t = TimeSymbol("t")
# model_run_data is incomplete :
# Even parameter_sets cannot fully parameterize the symbolic model: mm made up
# a purely fictional parameters to show how a purely numeric could be build.
# (The yaml file lacks consistent unit information).
np1 = NumericParameterization(
par_dict={
alpha_f: Rational(1, 3),
alpha_r: Rational(1, 3),
alpha_w: Rational(1, 3),
tau_f: 1.5,
tau_r: 3,
tau_w: 50,
SOL: 1, # completely faked by mm
epsilon: 1.1,
FPAR: 1, # completely faked by mm
},
func_dict=frozendict({}))
# Original dataset of the publication":
# values: {alpha_f: 'Rational(1,3)',alpha_r: 'Rational(1,3)',alpha_w: 'Rational(1,3)'}
# # epsilon varies from 1.1 - 1.4 gC*MJ^{-1}PAR in crop ecosystems.
# doi: 10.1029/93GB02725
# - "Tundra":
# values: {alpha_f: 0.25, alpha_r: 0.25, alpha_w: 0.5, tau_f: 1.5, tau_r: 3, tau_w: 50}
# doi: 10.2307/1313568
# - "High-latitude forest":
# values: {alpha_f: 0.30, alpha_r: 0.25, alpha_w: 0.45, tau_f: 1, tau_r: 3, tau_w: 50}
0, -((f_np * lambda_p * W_p) + (f_ns * lambda_s * W_s) +
(f_nr * lambda_r * W_r)) * ((kappa * W_C) / W_g**2), 0, 0, 0
], [0, (kappa * N * lambda_p * W_p) / W_g, 0, 0, 0],
[0, (kappa * N * lambda_s * W_s) / W_g, 0, 0, 0],
[0, (kappa * N * lambda_r * W_r) / W_g, 0, 0, 0]])
t = TimeSymbol("t") # unit: "day"
np1 = NumericParameterization(par_dict={
sigma_r: 0.01,
I_dens: 1000,
f_C: 0.5,
Beta: 0.05,
f_cp: 0.60,
f_cr: 0.45,
f_cs: 0.45,
f_np: 0.16,
f_nr: 0.03,
f_ns: 0.005,
h_max: 0.0003,
h_half: 200,
kappa: 300,
rho: '5*10**5',
C_i: 240
},
func_dict=frozendict({}))
nsv1 = NumericStartValueDict({
N: 0.01,
C: 0.15,
W_p: 100,
W_s: 100,
W_r: 100,
W_C: 45,
np1 = NumericParameterization(
par_dict={
Q_10: 1,
W: 4.2,
T: 25,
U: 3370 #"gC*day^{-1}" # Average estimated value
,
b_1: 0.14,
b_2: 0.14,
b_3: 0.26,
c_1: 0.00258,
c_2: 0.0000586,
c_3: 0.00239,
c_4: 0.0109,
c_5: 0.00095,
c_6: 0.0105,
c_7: 0.0000995,
c_8: 0.0000115,
f_41: 0.9,
f_51: 0.1,
f_52: 1,
f_43: 0.2,
f_53: 0.8,
f_64: 0.45,
f_65: 0.275,
f_75: 0.275,
f_76: 0.296,
f_86: 0.004,
f_67: 0.42,
f_87: 0.01,
f_68: 0.45
},
func_dict=frozendict({})
# state_var_units=gram/kilometer**2,
# time_unit=day
)
}
for name in sym_dict.keys():
var(name)
xi = r #environmental effects multiplier
T = ImmutableMatrix([[-1, 0], [h, -1]]) #transition operator
N = diag(k_1, k_2) #decomposition operator
t = TimeSymbol("t") # unit: "year"
x = StateVariableTuple((Y, O))
u = InputTuple((i, 0))
B = CompartmentalMatrix(xi * T * N)
# - "Bare fallow":
np1 = NumericParameterization(par_dict={
k_1: 0.8,
k_2: 0.00605,
i: 0,
h: 0.13,
r: 1.32
},
func_dict=frozendict({}))
nsv1 = NumericStartValueDict({Y: 0.3, O: 3.96})
# - "+N +straw":
np2 = NumericParameterization(par_dict={
k_1: 0.8,
k_2: 0.00605,
i: 0.285,
h: 0.125,
r: 1.00
},
func_dict=frozendict({}))
nsv2 = NumericStartValueDict({Y: 0.3, O: 4.11})
def test_numeric_input_tuple(self):
# setup the paths to the testdata
cable_out_path = Path(
'/home/data/cable-data/example_runs/parallel_1901_2004_with_spinup/output/new4'
)
# cable_data_set = cH.cable_ds(cable_out_path)
time_slice = slice(0, None)
landpoint_slice = slice(1590, 1637) # cheated
# landpoint_slice = slice(None,None)
# time_slice=slice(None,None,None)
zarr_cache_path = cP.slice_dir_path(
cable_out_path,
sub_dir_trunk="zarr_mm11",
time_slice=time_slice,
landpoint_slice=landpoint_slice,
)
if "cable_data_set" not in dir():
cable_data_set = cH.cable_ds(cable_out_path)
args = {
"cable_data_set": cable_data_set,
"zarr_cache_path": zarr_cache_path,
"landpoint_slice": landpoint_slice,
"time_slice": time_slice,
#'batch_size': 128,
"batch_size": 12,
#'rm': True
}
x_org_iveg = cH.cacheWrapper(cC.x_org_iveg, **args)
time = cH.cacheWrapper(cC.time, **args)
patches, landpoints = cC.all_pools_vary_cond_nz(**args)
pcs = patches.compute()
lpcs = landpoints.compute()
pcs, lpcs
p = Path('plots')
p.mkdir(exist_ok=True)
ind = 0 # first pair that has a nonconstant solution for
lp = lpcs[ind]
patch = lpcs[ind]
# get the symbolic represantation from the database
mvs = self.mvs
# define some stuff to extend it with
def default(t):
return 1
leaf = Symbol('leaf')
fine_root = Symbol('fine_root')
Npp = Function("Npp")
bvec_leaf = Function("bvec_leaf")
bvec_fine_root = Function("bvec_fine_root")
xk_leaf_cold = Function("xk_leaf_cold")
xk_leaf_dry = Function("xk_leaf_dry")
kleaf = Function("kleaf")
kfroot = Function("kfroot")
# bvec_wood = Function("bvec_wood")
np1 = NumericParameterization(
par_dict={},
func_dict=frozendict({
Npp: default,
bvec_fine_root: default,
bvec_leaf: default,
xk_leaf_cold: default,
kleaf: default,
kfroot: default,
xk_leaf_dry: default,
}),
)
nsv1 = NumericStartValueDict({leaf: 0.3, fine_root: 3.96})
ntimes1 = NumericSimulationTimes(np.linspace(0, 1, 11))
# extend the symbolice version with the new stuff
pvs = mvs.provided_mvar_values
#from IPython import embed; embed()
pvs1 = pvs.union(frozenset({np1, nsv1, ntimes1}))
mvs1 = MVarSet(pvs1)
x = mvs1.get_StateVariableTuple()
Input = mvs1.get_InputTuple()
#B = mvs1.get_CompartmentalMatrix()
sym_times = mvs1.get_NumericSimulationTimes()
sol_smooth = mvs1.get_NumericSolutionArray()
comp_slice = slice(0, 100)
n = sol_smooth.shape[1]
fig = plt.figure()
for pool in range(n):
ax = fig.add_subplot(n + 1, 1, 2 + pool)
title = "\$" + latex(x[pool]) + "\$"
#ax.plot(
# sym_times[comp_slice],
# sol_smooth[comp_slice, pool],
# color='r'
#)
ax.plot(time[comp_slice],
x_org_iveg[comp_slice, pool, patch, lp],
color='b')
fontsize = 10
ax.set_title(title, fontsize=fontsize)
fig.savefig('solution.pdf')
-(t_litterC_soilC + t_litterC_atm) / C_litter, 0, t_CWDC / C_cwd
],
[0, 0, 0, 0, 0, 0, t_litterC_soilC / C_litter, -t_soilC_atm / C_soil, 0],
[0, 0, 0, tau_wood, 0, 0, 0, 0, -t_CWDC / C_cwd]])
t = TimeSymbol("t")
np1 = NumericParameterization(
par_dict={
tau_leaf: 0.0027,
tau_wood: 5e-05,
tau_root: 0.002,
tau_excessC: 0.05,
tau_litter: 0.029,
tau_cwd: 0.001,
tau_soil: 1e-04,
Q_h: 1.4,
m_resp_frac: 0.5,
DON_leach_prop: 0.0015,
leach_rate: 0.00001 # day^{-1}
,
nitr_rate: 0.0001 # day^{-1}
},
func_dict=frozendict({})
# state_var_units= gC*m^{-2}
# time_unit=day
)
in_fl_c = carbon_in_fluxes_by_symbol_1(c_in_t, xc)
internal_fl_c = carbon_internal_fluxes_by_symbol_1(A_c, xc)
out_fl_c = carbon_out_fluxes_by_symbol_1(A_c, xc)
in_fl_n = {N_labile: U_Nfix, N_NH4: Ndep_NH4, N_NO3: Ndep_NO3}
out_fl_n = {N_soil: L_DON, N_NH4: U_NH4, N_NO3: U_NO3 + L_NO3}
[0, 0, 0, 0, 0, 0, 0, d_5 * p_pa, d_6 * p_ps, -d_7]])
# Commented out the following lines because original publication only has 3 parameter values
np1 = NumericParameterization(
par_dict={
# G: , #"Mg*ha^{-1}*yr^{-1}"
eta_f: 0.3,
eta_r: 0.3,
gamma_f: 0.5 #"yr^{-1}"
,
gamma_r: 1.5 #"yr^{-1}"
,
gamma_w: 0.01 #"yr^{-1}"
,
lambda_f: 1,
lambda_r: 1,
omega: 0.45,
L_fl: 0.2,
L_rl: 0.16,
T: 0.5,
p_am: 0.45,
p_an: 0.45,
p_pa: 0.004,
p_as: 0.42,
p_ps: 0.03,
p_ap: 0.45
},
func_dict=frozendict({})
# state_var_units=gram/kilometer**2,
# time_unit=day
)
#nsv1 = NumericStartValueDict({
# F: , #"Mg/ha"
