Skip to content

Commit daf6a79

Browse files
valentinsulzervalentinsulzer
committedOct 17, 2019
#668 add evaluate function
·
v25.1.1v0.2.0
1 parent 1028e78 commit daf6a79

File tree

11 files changed

+107
-152
lines changed

11 files changed

+107
-152
lines changed
 

‎examples/scripts/compare_comsol/compare_comsol_DFN.py

+1-1
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@
5757
# Make Comsol 'model' for comparison
5858
whole_cell = ["negative electrode", "separator", "positive electrode"]
5959
comsol_t = comsol_variables["time"]
60-
L_x = param.process_symbol(pybamm.standard_parameters_lithium_ion.L_x).evaluate()
60+
L_x = param.evaluate(pybamm.standard_parameters_lithium_ion.L_x)
6161

6262

6363
def get_interp_fun(variable, domain):

‎pybamm/models/submodels/current_collector/effective_resistance_current_collector.py

+9-9
Original file line numberDiff line numberDiff line change
@@ -123,15 +123,15 @@ def get_processed_potentials(self, solution, mesh, param_values, V_av, I_av):
123123
"""
124124
# Get required processed parameters
125125
param = self.param
126-
l_cn = param_values.process_symbol(param.l_cn).evaluate()
127-
l_cp = param_values.process_symbol(param.l_cp).evaluate()
128-
l_y = param_values.process_symbol(param.l_y).evaluate()
129-
l_z = param_values.process_symbol(param.l_z).evaluate()
130-
sigma_cn_prime = param_values.process_symbol(param.sigma_cn_prime).evaluate()
131-
sigma_cp_prime = param_values.process_symbol(param.sigma_cp_prime).evaluate()
132-
alpha = param_values.process_symbol(param.alpha).evaluate()
133-
pot_scale = param_values.process_symbol(param.potential_scale).evaluate()
134-
U_ref = param_values.process_symbol(param.U_p_ref - param.U_n_ref).evaluate()
126+
l_cn = param_values.evaluate(param.l_cn)
127+
l_cp = param_values.evaluate(param.l_cp)
128+
l_y = param_values.evaluate(param.l_y)
129+
l_z = param_values.evaluate(param.l_z)
130+
sigma_cn_prime = param_values.evaluate(param.sigma_cn_prime)
131+
sigma_cp_prime = param_values.evaluate(param.sigma_cp_prime)
132+
alpha = param_values.evaluate(param.alpha)
133+
pot_scale = param_values.evaluate(param.potential_scale)
134+
U_ref = param_values.evaluate(param.U_p_ref - param.U_n_ref)
135135

136136
# Process psi and W, and their (average) values at the negative tab
137137
psi = pybamm.ProcessedVariable(

‎pybamm/parameters/parameter_values.py

+20
Original file line numberDiff line numberDiff line change
@@ -502,3 +502,23 @@ def update_scalars(self, symbol):
502502
x.function.interpolate()
503503

504504
return symbol
505+
506+
def evaluate(self, symbol):
507+
"""
508+
Process and evaluate a symbol.
509+
510+
Parameters
511+
----------
512+
symbol : :class:`pybamm.Symbol`
513+
Symbol or Expression tree to evaluate
514+
515+
Returns
516+
-------
517+
number of array
518+
The evaluated symbol
519+
"""
520+
processed_symbol = self.process_symbol(symbol)
521+
if processed_symbol.is_constant() and processed_symbol.evaluates_to_number():
522+
return processed_symbol.evaluate()
523+
else:
524+
raise ValueError("symbol must evaluate to a constant scalar")

‎results/2plus1D/compare_lithium_ion_2plus1D.py

+2-2
Original file line numberDiff line numberDiff line change
@@ -79,8 +79,8 @@
7979
plt.ylabel("Terminal voltage [V]")
8080
plt.legend()
8181
# add C-rate, delta, and alpha to title
82-
delta = param.process_symbol(pybamm.standard_parameters_lithium_ion.delta).evaluate()
83-
alpha = param.process_symbol(pybamm.standard_parameters_lithium_ion.alpha).evaluate()
82+
delta = param.evaluate(pybamm.standard_parameters_lithium_ion.delta)
83+
alpha = param.evaluate(pybamm.standard_parameters_lithium_ion.alpha)
8484
plt.title(
8585
r"C-rate = {:3d}, $\alpha$ = {:.6f} , $\delta$ = {:.6f}".format(
8686
C_rate, alpha, delta

‎results/2plus1D/compare_spmecc.py

+1-3
Original file line numberDiff line numberDiff line change
@@ -63,9 +63,7 @@
6363
# add current collector Ohmic losses to average SPMEe to get SPMeCC voltage
6464
if model.name == "Average SPMe":
6565
current = pybamm.ProcessedVariable(model.variables["Current [A]"], t, y)(t)
66-
delta = param.process_symbol(
67-
pybamm.standard_parameters_lithium_ion.delta
68-
).evaluate()
66+
delta = param.evaluate(pybamm.standard_parameters_lithium_ion.delta)
6967
R_cc = param.process_symbol(
7068
cc_model.variables["Effective current collector resistance [Ohm]"]
7169
).evaluate(

‎results/2plus1D/spm_2plus1D_tab_grid.py

+2-4
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
# adjust current to correspond to a typical current density of 24 [A.m-2]
2323
C_rate = 1
2424
param["Typical current [A]"] = (
25-
C_rate * 24 * param.process_symbol(pybamm.geometric_parameters.A_cc).evaluate()
25+
C_rate * 24 * param.evaluate(pybamm.geometric_parameters.A_cc)
2626
)
2727
param.process_model(model)
2828
param.process_geometry(geometry)
@@ -39,9 +39,7 @@
3939
var.z: 5,
4040
}
4141
submesh_types = model.default_submesh_types
42-
submesh_types[
43-
"current collector"
44-
] = pybamm.ScikitExponential2DSubMesh
42+
submesh_types["current collector"] = pybamm.ScikitExponential2DSubMesh
4543
# depnding on number of points in y-z plane may need to increase recursion depth...
4644
sys.setrecursionlimit(10000)
4745
mesh = pybamm.Mesh(geometry, submesh_types, var_pts)

‎results/2plus1D/spmecc.py

+1-1
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@
4141
time = pybamm.ProcessedVariable(cell_model.variables["Time [h]"], t, y)(t)
4242
voltage = pybamm.ProcessedVariable(cell_model.variables["Terminal voltage [V]"], t, y)
4343
current = pybamm.ProcessedVariable(cell_model.variables["Current [A]"], t, y)(t)
44-
delta = param.process_symbol(pybamm.standard_parameters_lithium_ion.delta).evaluate()
44+
delta = param.evaluate(pybamm.standard_parameters_lithium_ion.delta)
4545
R_cc = param.process_symbol(
4646
cc_model.variables["Effective current collector resistance [Ohm]"]
4747
).evaluate(t=cc_solution.t, y=cc_solution.y)[0][0]

‎results/2plus1D/user_mesh_spm_1plus1D.py

+1-1
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@
1919
# load parameter values and process model and geometry
2020
param = model.default_parameter_values
2121
C_rate = 1
22-
current_1C = 24 * param.process_symbol(pybamm.geometric_parameters.A_cc).evaluate()
22+
current_1C = 24 * param.evaluate(pybamm.geometric_parameters.A_cc)
2323
param.update(
2424
{
2525
"Typical current [A]": C_rate * current_1C,

‎tests/integration/test_models/standard_output_tests.py

+4-4
Original file line numberDiff line numberDiff line change
@@ -90,8 +90,8 @@ def __init__(self, model, param, disc, solution, operating_condition):
9090
self.r_p_edge = disc.mesh["positive particle"][0].edges
9191

9292
# Useful parameters
93-
self.l_n = param.process_symbol(pybamm.geometric_parameters.l_n).evaluate()
94-
self.l_p = param.process_symbol(pybamm.geometric_parameters.l_p).evaluate()
93+
self.l_n = param.evaluate(pybamm.geometric_parameters.l_n)
94+
self.l_p = param.evaluate(pybamm.geometric_parameters.l_p)
9595

9696
if isinstance(self.model, pybamm.lithium_ion.BaseModel):
9797
current_param = pybamm.standard_parameters_lithium_ion.current_with_time
@@ -635,9 +635,9 @@ def test_velocity_vs_current(self):
635635
t, x_n, x_p = self.t, self.x_n, self.x_p
636636

637637
beta_n = pybamm.standard_parameters_lead_acid.beta_n
638-
beta_n = self.param.process_symbol(beta_n).evaluate()
638+
beta_n = self.param.evaluate(beta_n)
639639
beta_p = pybamm.standard_parameters_lead_acid.beta_p
640-
beta_p = self.param.process_symbol(beta_p).evaluate()
640+
beta_p = self.param.evaluate(beta_p)
641641

642642
np.testing.assert_array_almost_equal(
643643
self.v_box(t, x_n), beta_n * self.i_e(t, x_n)

‎tests/unit/test_parameters/test_dimensionless_parameter_values_lithium_ion.py

+51-127
Original file line numberDiff line numberDiff line change
@@ -21,144 +21,98 @@ def test_lithium_ion(self):
2121
"particle geometry"
2222
# a_n dimensional
2323
np.testing.assert_almost_equal(
24-
values.process_symbol(param.a_n_dim).evaluate(None, None),
25-
0.18 * 10 ** (6),
26-
2,
24+
values.evaluate(param.a_n_dim), 0.18 * 10 ** (6), 2
2725
)
2826
# R_n dimensional
29-
np.testing.assert_almost_equal(
30-
values.process_symbol(param.R_n).evaluate(None, None), 1 * 10 ** (-5), 2
31-
)
27+
np.testing.assert_almost_equal(values.evaluate(param.R_n), 1 * 10 ** (-5), 2)
3228

3329
# a_n
34-
np.testing.assert_almost_equal(
35-
values.process_symbol(param.a_n).evaluate(None, None), 1.8, 2
36-
)
30+
np.testing.assert_almost_equal(values.evaluate(param.a_n), 1.8, 2)
3731

3832
# a_p dimensional
3933
np.testing.assert_almost_equal(
40-
values.process_symbol(param.a_p_dim).evaluate(None, None),
41-
0.15 * 10 ** (6),
42-
2,
34+
values.evaluate(param.a_p_dim), 0.15 * 10 ** (6), 2
4335
)
4436

4537
# R_p dimensional
46-
np.testing.assert_almost_equal(
47-
values.process_symbol(param.R_n).evaluate(None, None), 1 * 10 ** (-5), 2
48-
)
38+
np.testing.assert_almost_equal(values.evaluate(param.R_n), 1 * 10 ** (-5), 2)
4939

5040
# a_p
51-
np.testing.assert_almost_equal(
52-
values.process_symbol(param.a_p).evaluate(None, None), 1.5, 2
53-
)
41+
np.testing.assert_almost_equal(values.evaluate(param.a_p), 1.5, 2)
5442

5543
"reaction rates"
5644
# m_n*
5745
np.testing.assert_almost_equal(
58-
values.process_symbol(param.m_n_dimensional(param.T_ref)).evaluate(
59-
None, None
60-
),
61-
2 * 10 ** (-5),
62-
8,
46+
values.evaluate(param.m_n_dimensional(param.T_ref)), 2 * 10 ** (-5), 8
6347
)
6448

6549
np.testing.assert_almost_equal(
66-
values.process_symbol(1 / param.C_r_n * c_rate).evaluate(None, None),
67-
26.6639,
68-
3,
50+
values.evaluate(1 / param.C_r_n * c_rate), 26.6639, 3
6951
)
7052

7153
# m_p*
7254
np.testing.assert_almost_equal(
73-
values.process_symbol(param.m_p_dimensional(param.T_ref)).evaluate(
74-
None, None
75-
),
76-
6 * 10 ** (-7),
77-
8,
55+
values.evaluate(param.m_p_dimensional(param.T_ref)), 6 * 10 ** (-7), 8
7856
)
7957

8058
# gamma_p / C_r_p
8159
np.testing.assert_almost_equal(
82-
values.process_symbol(param.gamma_p / param.C_r_p * c_rate).evaluate(
83-
None, None
84-
),
85-
1.366,
86-
3,
60+
values.evaluate(param.gamma_p / param.C_r_p * c_rate), 1.366, 3
8761
)
8862

8963
"particle dynamics"
9064
# neg diffusion coefficient
9165
np.testing.assert_almost_equal(
92-
values.process_symbol(
93-
param.D_n_dimensional(param.c_n_init, param.T_ref)
94-
).evaluate(None, None),
66+
values.evaluate(param.D_n_dimensional(param.c_n_init, param.T_ref)),
9567
3.9 * 10 ** (-14),
9668
2,
9769
)
9870

9971
# neg diffusion timescale
10072
np.testing.assert_almost_equal(
101-
values.process_symbol(param.tau_diffusion_n).evaluate(None, None),
102-
2.5641 * 10 ** (3),
103-
2,
73+
values.evaluate(param.tau_diffusion_n), 2.5641 * 10 ** (3), 2
10474
)
10575

10676
# tau_n / tau_d (1/gamma_n in Scott's transfer)
107-
np.testing.assert_almost_equal(
108-
values.process_symbol(param.C_n / c_rate).evaluate(None, None), 0.11346, 3
109-
)
77+
np.testing.assert_almost_equal(values.evaluate(param.C_n / c_rate), 0.11346, 3)
11078

11179
# pos diffusion coefficient
11280
np.testing.assert_almost_equal(
113-
values.process_symbol(
114-
param.D_p_dimensional(param.c_p_init, param.T_ref)
115-
).evaluate(None, None),
81+
values.evaluate(param.D_p_dimensional(param.c_p_init, param.T_ref)),
11682
1 * 10 ** (-13),
11783
2,
11884
)
11985

12086
# pos diffusion timescale
12187
np.testing.assert_almost_equal(
122-
values.process_symbol(param.tau_diffusion_p).evaluate(None, None),
123-
1 * 10 ** (3),
124-
2,
88+
values.evaluate(param.tau_diffusion_p), 1 * 10 ** (3), 2
12589
)
12690

12791
# tau_p / tau_d (1/gamma_p in Scott's transfer)
128-
np.testing.assert_almost_equal(
129-
values.process_symbol(param.C_p / c_rate).evaluate(None, None), 0.044249, 3
130-
)
92+
np.testing.assert_almost_equal(values.evaluate(param.C_p / c_rate), 0.044249, 3)
13193

13294
"electrolyte dynamics"
13395
# typical diffusion coefficient (we should change the typ value in paper to
13496
# match this one. We take this parameter excluding the exp(-0.65) in the
13597
# paper at the moment
13698
np.testing.assert_almost_equal(
137-
values.process_symbol(
138-
param.D_e_dimensional(param.c_e_typ, param.T_ref)
139-
).evaluate(None, None),
99+
values.evaluate(param.D_e_dimensional(param.c_e_typ, param.T_ref)),
140100
5.34 * 10 ** (-10) * np.exp(-0.65),
141101
10,
142102
)
143103

144104
# electrolyte diffusion timescale (accounting for np.exp(-0.65) in
145105
# diffusion_typ). Change value in paper to this.
146106
np.testing.assert_almost_equal(
147-
values.process_symbol(param.tau_diffusion_e).evaluate(None, None),
148-
181.599,
149-
3,
107+
values.evaluate(param.tau_diffusion_e), 181.599, 3
150108
)
151109

152110
# C_e
153-
np.testing.assert_almost_equal(
154-
values.process_symbol(param.C_e / c_rate).evaluate(None, None), 0.008, 3
155-
)
111+
np.testing.assert_almost_equal(values.evaluate(param.C_e / c_rate), 0.008, 3)
156112

157113
# electrolyte conductivity
158114
np.testing.assert_almost_equal(
159-
values.process_symbol(
160-
param.kappa_e_dimensional(param.c_e_typ, param.T_ref)
161-
).evaluate(None, None),
115+
values.evaluate(param.kappa_e_dimensional(param.c_e_typ, param.T_ref)),
162116
1.1045,
163117
3,
164118
)
@@ -167,32 +121,26 @@ def test_lithium_ion(self):
167121
# F R / T (should be equal to old 1 / Lambda)
168122
old_Lambda = 38
169123
np.testing.assert_almost_equal(
170-
values.process_symbol(param.potential_scale).evaluate(None, None),
171-
1 / old_Lambda,
172-
3,
124+
values.evaluate(param.potential_scale), 1 / old_Lambda, 3
173125
)
174126

175127
"electrode conductivities"
176128
# neg dimensional
177-
np.testing.assert_almost_equal(
178-
values.process_symbol(param.sigma_n_dim).evaluate(None, None), 100, 3
179-
)
129+
np.testing.assert_almost_equal(values.evaluate(param.sigma_n_dim), 100, 3)
180130

181131
# neg dimensionless (old sigma_n / old_Lambda ) (this is different to values
182132
# in paper so check again, it is close enough though for now)
183133
np.testing.assert_almost_equal(
184-
values.process_symbol(param.sigma_n * c_rate).evaluate(None, None), 475.7, 1
134+
values.evaluate(param.sigma_n * c_rate), 475.7, 1
185135
)
186136

187137
# neg dimensional
188-
np.testing.assert_almost_equal(
189-
values.process_symbol(param.sigma_p_dim).evaluate(None, None), 10, 3
190-
)
138+
np.testing.assert_almost_equal(values.evaluate(param.sigma_p_dim), 10, 3)
191139

192140
# neg dimensionless (old sigma_n / old_Lambda ) (this is different to values in
193141
# paper so check again, it is close enough for now though)
194142
np.testing.assert_almost_equal(
195-
values.process_symbol(param.sigma_p * c_rate).evaluate(None, None), 47.57, 1
143+
values.evaluate(param.sigma_p * c_rate), 47.57, 1
196144
)
197145

198146
def test_thermal_parameters(self):
@@ -201,72 +149,48 @@ def test_thermal_parameters(self):
201149
c_rate = param.i_typ / 24
202150

203151
# Density
204-
np.testing.assert_almost_equal(
205-
values.process_symbol(param.rho_cn).evaluate(), 1.9019, 2
206-
)
207-
np.testing.assert_almost_equal(
208-
values.process_symbol(param.rho_n).evaluate(), 0.6403, 2
209-
)
210-
np.testing.assert_almost_equal(
211-
values.process_symbol(param.rho_s).evaluate(), 0.1535, 2
212-
)
213-
np.testing.assert_almost_equal(
214-
values.process_symbol(param.rho_p).evaluate(), 1.2605, 2
215-
)
216-
np.testing.assert_almost_equal(
217-
values.process_symbol(param.rho_cp).evaluate(), 1.3403, 2
218-
)
152+
np.testing.assert_almost_equal(values.evaluate(param.rho_cn), 1.9019, 2)
153+
np.testing.assert_almost_equal(values.evaluate(param.rho_n), 0.6403, 2)
154+
np.testing.assert_almost_equal(values.evaluate(param.rho_s), 0.1535, 2)
155+
np.testing.assert_almost_equal(values.evaluate(param.rho_p), 1.2605, 2)
156+
np.testing.assert_almost_equal(values.evaluate(param.rho_cp), 1.3403, 2)
219157

220158
# Thermal conductivity
221-
np.testing.assert_almost_equal(
222-
values.process_symbol(param.lambda_cn).evaluate(), 6.7513, 2
223-
)
224-
np.testing.assert_almost_equal(
225-
values.process_symbol(param.lambda_n).evaluate(), 0.0296, 2
226-
)
227-
np.testing.assert_almost_equal(
228-
values.process_symbol(param.lambda_s).evaluate(), 0.0027, 2
229-
)
230-
np.testing.assert_almost_equal(
231-
values.process_symbol(param.lambda_p).evaluate(), 0.0354, 2
232-
)
233-
np.testing.assert_almost_equal(
234-
values.process_symbol(param.lambda_cp).evaluate(), 3.9901, 2
235-
)
159+
np.testing.assert_almost_equal(values.evaluate(param.lambda_cn), 6.7513, 2)
160+
np.testing.assert_almost_equal(values.evaluate(param.lambda_n), 0.0296, 2)
161+
np.testing.assert_almost_equal(values.evaluate(param.lambda_s), 0.0027, 2)
162+
np.testing.assert_almost_equal(values.evaluate(param.lambda_p), 0.0354, 2)
163+
np.testing.assert_almost_equal(values.evaluate(param.lambda_cp), 3.9901, 2)
236164

237165
# other thermal parameters
238166

239167
# note: in paper this is 0.0534 * c_rate which conflicts with this
240168
# if we do C_th * c_rate we get 0.0534 so probably error in paper
241169
# np.testing.assert_almost_equal(
242-
# values.process_symbol(param.C_th / c_rate).evaluate(), 0.0253, 2
170+
# values.evaluate(param.C_th / c_rate), 0.0253, 2
243171
# )
244172

245-
np.testing.assert_almost_equal(
246-
values.process_symbol(param.Theta / c_rate).evaluate(), 0.008, 2
247-
)
173+
np.testing.assert_almost_equal(values.evaluate(param.Theta / c_rate), 0.008, 2)
248174

249-
np.testing.assert_almost_equal(
250-
values.process_symbol(param.h).evaluate(), 3.7881 * 10 ** (-5), 7
251-
)
175+
np.testing.assert_almost_equal(values.evaluate(param.h), 3.7881 * 10 ** (-5), 7)
252176

253177
# np.testing.assert_almost_equal(
254-
# values.process_symbol(param.B / c_rate).evaluate(), 36.216, 2
178+
# values.evaluate(param.B / c_rate), 36.216, 2
255179
# )
256180

257-
np.testing.assert_equal(values.process_symbol(param.T_init).evaluate(), 0)
181+
np.testing.assert_equal(values.evaluate(param.T_init), 0)
258182

259183
# test timescale
260184
# np.testing.assert_almost_equal(
261-
# values.process_symbol(param.tau_th_yz).evaluate(), 1.4762 * 10 ** (3), 2
185+
# values.evaluate(param.tau_th_yz), 1.4762 * 10 ** (3), 2
262186
# )
263187

264188
# thermal = pybamm.thermal_parameters
265189
# np.testing.assert_almost_equal(
266-
# values.process_symbol(thermal.rho_eff_dim).evaluate(), 1.8116 * 10 ** (6), 2
190+
# values.evaluate(thermal.rho_eff_dim), 1.8116 * 10 ** (6), 2
267191
# )
268192
# np.testing.assert_almost_equal(
269-
# values.process_symbol(thermal.lambda_eff_dim).evaluate(), 59.3964, 2
193+
# values.evaluate(thermal.lambda_eff_dim), 59.3964, 2
270194
# )
271195

272196
def test_parameter_functions(self):
@@ -276,17 +200,17 @@ def test_parameter_functions(self):
276200
c_test = pybamm.Scalar(0.5)
277201
T_test = pybamm.Scalar(0)
278202

279-
values.process_symbol(param.U_n(c_test, T_test)).evaluate()
280-
values.process_symbol(param.U_p(c_test, T_test)).evaluate()
281-
values.process_symbol(param.dUdT_n(c_test)).evaluate()
282-
values.process_symbol(param.dUdT_p(c_test)).evaluate()
203+
values.evaluate(param.U_n(c_test, T_test))
204+
values.evaluate(param.U_p(c_test, T_test))
205+
values.evaluate(param.dUdT_n(c_test))
206+
values.evaluate(param.dUdT_p(c_test))
283207

284-
values.process_symbol(param.D_p(c_test, T_test)).evaluate()
285-
values.process_symbol(param.D_n(c_test, T_test)).evaluate()
208+
values.evaluate(param.D_p(c_test, T_test))
209+
values.evaluate(param.D_n(c_test, T_test))
286210

287211
c_e_test = pybamm.Scalar(1)
288-
values.process_symbol(param.D_e(c_e_test, T_test)).evaluate()
289-
values.process_symbol(param.kappa_e(c_e_test, T_test)).evaluate()
212+
values.evaluate(param.D_e(c_e_test, T_test))
213+
values.evaluate(param.kappa_e(c_e_test, T_test))
290214

291215

292216
if __name__ == "__main__":

‎tests/unit/test_parameters/test_parameter_values.py

+15
Original file line numberDiff line numberDiff line change
@@ -451,6 +451,21 @@ def test_process_empty_model(self):
451451
):
452452
parameter_values.process_model(model)
453453

454+
def test_evaluate(self):
455+
parameter_values = pybamm.ParameterValues({"a": 1, "b": 2, "c": 3})
456+
a = pybamm.Parameter("a")
457+
b = pybamm.Parameter("b")
458+
c = pybamm.Parameter("c")
459+
self.assertEqual(parameter_values.evaluate(a), 1)
460+
self.assertEqual(parameter_values.evaluate(a + (b * c)), 7)
461+
462+
y = pybamm.StateVector(slice(0, 1))
463+
with self.assertRaises(ValueError):
464+
parameter_values.evaluate(y)
465+
array = pybamm.Array(np.array([1, 2, 3]))
466+
with self.assertRaises(ValueError):
467+
parameter_values.evaluate(array)
468+
454469

455470
if __name__ == "__main__":
456471
print("Add -v for more debug output")

0 commit comments

Comments
 (0)
Please sign in to comment.