def test_figure(self):
C_0, C_1 = symbols('C_0 C_1')
state_vector = [C_0, C_1]
time_symbol = Symbol('t')
input_fluxes = {}
output_fluxes = {}
internal_fluxes = {(0, 1): 5 * C_0 * C_1, (1, 0): 4 * C_0}
rm = SmoothReservoirModel(state_vector, time_symbol, input_fluxes,
output_fluxes, internal_fluxes)
fig = rm.figure()
fig.savefig("reservoir_model_plot.pdf")
def test_linearize_piecewise(self):
# Atmosphere, Terrestrial Carbon and Surface layer
C_A, C_T, C_S = symbols('C_A C_T C_S')
# equilibrium contents
A_e, T_e, S_e = symbols('A_e T_e S_e')
# equilibrium fluxes
F_0, F_1, F_2 = symbols('F_0 F_1 F_2')
# nonlinear coefficients
alpha, beta = symbols('alpha beta')
# external flux from surface layer to deep ocean
F_ex = F_0 * C_S / S_e
# fossil fuel inputs
u_A = symbols('u_A')
#########################################
state_vector = Matrix([C_A, C_T, C_S])
time_symbol = symbols('tau')
input_fluxes = {0: u_A, 1: 0, 2: F_0}
output_fluxes = {
0: Piecewise((1, time_symbol < 0), (0, True)),
1: 0,
2: F_0 * C_S / S_e
}
internal_fluxes = {
(0, 1): F_2 * (C_A / A_e)**alpha, # A --> T
(0, 2): F_1 * C_A / A_e, # A --> S
(1, 0): F_2 * C_T / T_e, # T --> A
(2, 0): F_1 * (C_S / S_e)**beta
} # S --> A
nonlinear_srm = SmoothReservoirModel(state_vector, time_symbol,
input_fluxes, output_fluxes,
internal_fluxes)
A_eq, T_eq, S_eq = (700.0, 3000.0, 1000.0)
par_dict = {
A_e: A_eq,
T_e: T_eq,
S_e: S_eq, # equilibrium contents in Pg
F_0: 45.0,
F_1: 100.0,
F_2: 60.0, # equilibrium fluxes in PgC/yr
alpha: 0.2,
beta: 10.0
} # nonlinear coefficients
# fossil fuel inputs
par_dict[u_A] = 0
# initialize model run
times = np.linspace(0, 10, 101)
start_values = np.array([A_eq, T_eq, S_eq])
nonlinear_smr = SmoothModelRun(nonlinear_srm, par_dict, start_values,
times)
def minimal(symbs):
x,t,k=symbs
inputs={0:1}
outputs={0:-x*k}
internal_fluxes={}
mod=SmoothReservoirModel([x],t,inputs,outputs,internal_fluxes)
return(mod)
def test_age_moment_system(self):
x, y, t = symbols("x y t")
state_vector = Matrix([x, y])
A = Matrix([[-1, 0], [0, -2]])
u = Matrix(2, 1, [9, 1])
srm = SmoothReservoirModel.from_A_u(state_vector, t, A, u)
max_order = 1
extended_state, extended_rhs = srm.age_moment_system(max_order)
x_moment_1, y_moment_1 = symbols('x_moment_1 y_moment_1')
self.assertEqual(extended_state,
Matrix([[x], [y], [x_moment_1], [y_moment_1]]))
self.assertEqual(
extended_rhs,
Matrix([[-x + 9], [-2 * y + 1], [1 - 9 * x_moment_1 / x],
[1 - y_moment_1 / y]]))
max_order = 2
extended_state, extended_rhs = srm.age_moment_system(max_order)
x_moment_1, y_moment_1, x_moment_2, y_moment_2 = symbols(
'x_moment_1 y_moment_1 x_moment_2 y_moment_2')
self.assertEqual(
extended_state,
Matrix([[x], [y], [x_moment_1], [y_moment_1], [x_moment_2],
[y_moment_2]]))
self.assertEqual(
extended_rhs,
Matrix([[-x + 9], [-2 * y + 1], [1 - 9 * x_moment_1 / x],
[1 - y_moment_1 / y],
[2 * x_moment_1 - 9 * x_moment_2 / x],
[2 * y_moment_1 - y_moment_2 / y]]))
def test_Au_matrices_to_fluxes_and_back(self):
# f = u + xi*A*C
t,C_1, C_2, C_3, k_1, k_2, k_3, a_12, a_13, a_21, a_23, a_31, a_32, u_1, u_2, u_3, gamma, xi \
= symbols('t,C_1 C_2 C_3 k_1 k_2 k_3 a_12 a_13 a_21 a_23 a_31 a_32 u_1 u_2 u_3 gamma xi')
C = Matrix(3, 1, [C_1, C_2, C_3])
u = Matrix(3, 1, [u_1, u_2, u_3])
A = gamma * Matrix([[-k_1, a_12, a_13], [a_21, -k_2, a_23],
[a_31, a_32, -k_3]])
rm = SmoothReservoirModel.from_A_u(C, t, A, u)
self.assertEqual(rm.input_fluxes, {0: u_1, 1: u_2, 2: u_3})
self.assertEqual(
rm.output_fluxes, {
0: gamma * (k_1 - a_21 - a_31) * C_1,
1: gamma * (k_2 - a_12 - a_32) * C_2,
2: gamma * (k_3 - a_13 - a_23) * C_3
})
self.assertEqual(
rm.internal_fluxes, {
(0, 1): gamma * a_21 * C_1,
(0, 2): gamma * a_31 * C_1,
(1, 0): gamma * a_12 * C_2,
(1, 2): gamma * a_32 * C_2,
(2, 0): gamma * a_13 * C_3,
(2, 1): gamma * a_23 * C_3
})
## test backward conversion to compartmental matrix
A2 = rm.compartmental_matrix
u2 = rm.external_inputs
self.assertEqual(u, u2)
self.assertEqual(A, A2)
def emanuel(symbs):
u_1, u_3, x_1, x_2, x_3, x_4, x_5, t, F_1, F_2, F_3, F_4, F_5, F_21, F_41, F_42, F_52, F_43, F_53, F_54 = symbs
x = Matrix(5,1,[x_1, x_2, x_3, x_4, x_5])
u = (1+sin(t*pi*2)/2)*Matrix(5, 1, [u_1, 0, u_3, 0, 0])
A = (1+cos(t*pi*2))*Matrix([[-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]])
srm = SmoothReservoirModel.from_A_u(x,t,A,u)
return srm
def test_mean_age_system(self):
x, y, t = symbols("x y t")
state_vector = Matrix([x, y])
A = Matrix([[-1, 0], [0, -2]])
u = Matrix(2, 1, [9, 1])
srm = SmoothReservoirModel.from_A_u(state_vector, t, A, u)
extended_state, extended_rhs = srm.mean_age_system
x_meanage, y_meanage = symbols('x_meanage y_meanage')
self.assertEqual(extended_state,
Matrix([[x], [y], [x_meanage], [y_meanage]]))
self.assertEqual(
extended_rhs,
Matrix([[-x + 9], [-2 * y + 1], [1 - 9 * x_meanage / x],
[1 - y_meanage / y]]))
def test_xi_T_N_u_representation(self):
u_0, u_1, C_0, C_1, gamma = symbols('u_0 u_1 C_0 C_1 gamma')
state_vector = [C_0, C_1]
time_symbol = Symbol('t')
input_fluxes = {0: u_0, 1: u_1}
output_fluxes = {1: 3 * gamma * C_0 * C_1}
internal_fluxes = {
(0, 1): gamma * 3 * 5 * C_0 * C_1,
(1, 0): gamma * 3 * 4 * C_0
}
rm = SmoothReservoirModel(state_vector, time_symbol, input_fluxes,
output_fluxes, internal_fluxes)
xi, T, N, C, u = rm.xi_T_N_u_representation
self.assertEqual(u, Matrix([u_0, u_1]))
self.assertEqual(xi, 3 * gamma)
self.assertEqual(T, Matrix([[-1, 4 / (C_1 + 4)], [1, -1]]))
self.assertEqual(N, Matrix([[5 * C_1, 0], [0, C_0 * (C_1 + 4) / C_1]]))
def nonlinear_two_pool(symbs):
t, k_01, k_10, k_0o, k_1o = symbs
C_0, C_1 = symbols("C_0 C_1")
state_variables = [C_0, C_1] # order is important
inputs = {
0: sin(t)+2, # input to pool 0
1: cos(t)+2 # input to pool 1
}
outputs={
0: k_0o*C_0**3, # output from pool 0
1: k_1o*C_1**3 # output from pool 0
}
internal_fluxes={
(0,1): k_01*C_0*C_1**2, # flux from pool0 to pool 1
(1,0): k_10*C_0*C_1 # flux from pool1 to pool 0
}
time_symbol = t
srm = SmoothReservoirModel(state_variables, time_symbol,
inputs,outputs,internal_fluxes,
content_unit="kg C", time_unit="yr")
return srm
def critics(symbs):
t, k_01,k_10,k_0o,k_1o = symbs
x_0,x_1 = symbols("x_0 x_1")
state_variables = [x_0, x_1] # order is important
s1 = 10
s2 = 20
t1 = 20
k = 1
inputs = {
0: s1+1/2*(1-tanh(-k*(t-t1))*(s2-s1))
}
outputs = {
0: k_0o*x_0, # output from pool 0
1: k_1o*x_1*(1+sin(t/2)) #output from pool 0
}
internal_fluxes = {
(0,1):k_01*x_0 # flux from pool0 to pool 1
}
time_symbol = t
srm = SmoothReservoirModel(state_variables, time_symbol,
inputs,outputs, internal_fluxes,
content_unit="kg C", time_unit="yr")
return srm
def test_NTu_matrices_to_fluxes_and_back(self):
# f = xi*T*N*C + u
t, C_1, C_2, C_3, gamma, k_1, k_2, k_3, t_12, t_13, t_21, t_23, t_31, t_32, u_1, u_2, u_3, xi \
= symbols('t C_1 C_2 C_3 gamma k_1 k_2 k_3 t_12 t_13 t_21 t_23 t_31 t_32 u_1 u_2 u_3 xi')
C = Matrix(3, 1, [C_1, C_2, C_3])
u = Matrix(3, 1, [u_1, u_2, u_3])
xi = gamma
T = Matrix([[-1, t_12, t_13], [t_21, -1, t_23], [t_31, t_32, -1]])
N = diag(k_1, k_2, k_3)
A = gamma * T * N
rm = SmoothReservoirModel.from_A_u(C, t, A, u)
self.assertEqual(rm.input_fluxes, {0: u_1, 1: u_2, 2: u_3})
self.assertEqual(
rm.output_fluxes, {
0: gamma * k_1 * (1 - t_21 - t_31) * C_1,
1: gamma * k_2 * (1 - t_12 - t_32) * C_2,
2: gamma * k_3 * (1 - t_13 - t_23) * C_3
})
self.assertEqual(
rm.internal_fluxes, {
(0, 1): gamma * t_21 * k_1 * C_1,
(0, 2): gamma * t_31 * k_1 * C_1,
(1, 0): gamma * t_12 * k_2 * C_2,
(1, 2): gamma * t_32 * k_2 * C_2,
(2, 0): gamma * t_13 * k_3 * C_3,
(2, 1): gamma * t_23 * k_3 * C_3
})
# test backward conversion to matrices
xi2, T2, N2, C2, u2 = rm.xi_T_N_u_representation
self.assertEqual(xi, xi2)
self.assertEqual(u, u2)
self.assertEqual(T, T2)
self.assertEqual(N, N2)
def test_internal_flux_type(self):
# test simple cases
C_0, C_1 = symbols('C_0 C_1')
state_vector = [C_0, C_1]
time_symbol = Symbol('t')
input_fluxes = {}
output_fluxes = {}
internal_fluxes = {(0, 1): 5 * C_0, (1, 0): 4 * C_1**2}
rm = SmoothReservoirModel(state_vector, time_symbol, input_fluxes,
output_fluxes, internal_fluxes)
self.assertEqual(rm.internal_flux_type(0, 1), 'linear')
self.assertEqual(rm.internal_flux_type(1, 0), 'nonlinear')
# (1,0): 4 is considered to be nonlinear : in A the corresponding entry is 4/C_1
internal_fluxes = {(0, 1): C_0 + 5, (1, 0): C_1 / C_0}
rm = SmoothReservoirModel(state_vector, time_symbol, input_fluxes,
output_fluxes, internal_fluxes)
self.assertEqual(rm.internal_flux_type(0, 1),
'no substrate dependence')
self.assertEqual(rm.internal_flux_type(1, 0), 'nonlinear')
from sympy import symbols, sin, Symbol, cos
from bgc_md.SmoothReservoirModel import SmoothReservoirModel
from bgc_md.SmoothModelRun import SmoothModelRun
if __name__ == '__main__':
# two-dimensional model
C_0, C_1 = symbols('C_0 C_1')
state_vector = [C_0, C_1]
t = Symbol('t')
input_fluxes = {0: 2 + 1 * sin(1 / 4 * t), 1: 3}
output_fluxes = {0: 1 / 6 * C_0}
internal_fluxes = {(0, 1): 1 / 4 * C_0, (1, 0): 1 / 4 * C_1}
srm = SmoothReservoirModel(state_vector, t, input_fluxes, output_fluxes,
internal_fluxes)
# start values, time frame
start_values = (1, 3)
times = np.linspace(0, 1000, 1001)
smr = SmoothModelRun(srm, {}, start_values, times)
# start ages and age frame
ages = np.linspace(0, 200, 201)
start_age_densities = lambda a: np.exp(-a) * np.array(start_values)
start_mean_ages = (1, 1)
# plot a figure for comparison
#fig = plt.figure(figsize=(100,5))
#stretch = {'x': 1.3, 'y': 1.3, 'z': 1}
#smr.plot_age_densities(fig, [0, 1, 'system'], start_age_densities, ages, start_mean_ages, stretch)