def test_processed_variable_2D_x_r(self):
var = pybamm.Variable(
"var",
domain=["negative particle"],
auxiliary_domains={"secondary": ["negative electrode"]},
)
x = pybamm.SpatialVariable("x", domain=["negative electrode"])
r = pybamm.SpatialVariable("r", domain=["negative particle"])
disc = tests.get_p2d_discretisation_for_testing()
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
r_sol = disc.process_symbol(r).entries[:, 0]
# Keep only the first iteration of entries
r_sol = r_sol[:len(r_sol) // len(x_sol)]
var_sol = disc.process_symbol(var)
t_sol = np.linspace(0, 1)
y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(
0, 5)
processed_var = pybamm.ProcessedVariable(var_sol,
pybamm.Solution(t_sol, y_sol))
np.testing.assert_array_equal(
processed_var.entries,
np.reshape(
y_sol,
[len(r_sol), len(x_sol), len(t_sol)]),
)
def test_processed_var_2D_fixed_t_interpolation(self):
var = pybamm.Variable(
"var",
domain=["negative particle"],
auxiliary_domains={"secondary": ["negative electrode"]},
)
x = pybamm.SpatialVariable("x", domain=["negative electrode"])
r = pybamm.SpatialVariable(
"r",
domain=["negative particle"],
auxiliary_domains={"secondary": ["negative electrode"]},
)
disc = tests.get_p2d_discretisation_for_testing()
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
r_sol = disc.process_symbol(r).entries[:, 0]
# Keep only the first iteration of entries
r_sol = r_sol[: len(r_sol) // len(x_sol)]
var_sol = disc.process_symbol(var)
t_sol = np.array([0])
y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis]
processed_var = pybamm.ProcessedVariable(
var_sol, pybamm.Solution(t_sol, y_sol), warn=False
)
# 2 vectors
np.testing.assert_array_equal(processed_var(x=x_sol, r=r_sol).shape, (10, 40))
# 1 vector, 1 scalar
np.testing.assert_array_equal(processed_var(x=0.2, r=r_sol).shape, (10,))
np.testing.assert_array_equal(processed_var(x=x_sol, r=0.5).shape, (40,))
# 2 scalars
np.testing.assert_array_equal(processed_var(x=0.2, r=0.2).shape, ())
def test_failure(self):
t = np.ones(25)
y = np.ones((120, 25))
mat = pybamm.Vector(np.ones(120), domain=["negative particle"])
disc = tests.get_p2d_discretisation_for_testing()
with self.assertRaisesRegex(
ValueError, "3D variable shape does not match domain shape"):
pybamm.ProcessedVariable(mat, t, y, disc.mesh)
def test_processed_variable_3D(self):
var = pybamm.Variable("var", domain=["negative particle"])
x = pybamm.SpatialVariable("x", domain=["negative electrode"])
r = pybamm.SpatialVariable("r", domain=["negative particle"])
disc = tests.get_p2d_discretisation_for_testing()
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
r_sol = disc.process_symbol(r).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = np.linspace(0, 1)
y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(
0, 5)
processed_var = pybamm.ProcessedVariable(var_sol,
t_sol,
y_sol,
mesh=disc.mesh)
np.testing.assert_array_equal(
processed_var.entries,
np.reshape(
y_sol,
[len(x_sol), len(r_sol), len(t_sol)]),
)
def test_processed_var_2D_interpolation(self):
var = pybamm.Variable(
"var",
domain=["negative particle"],
auxiliary_domains={"secondary": ["negative electrode"]},
)
x = pybamm.SpatialVariable("x", domain=["negative electrode"])
r = pybamm.SpatialVariable("r", domain=["negative particle"])
disc = tests.get_p2d_discretisation_for_testing()
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
r_sol = disc.process_symbol(r).entries[:, 0]
# Keep only the first iteration of entries
r_sol = r_sol[:len(r_sol) // len(x_sol)]
var_sol = disc.process_symbol(var)
t_sol = np.linspace(0, 1)
y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(
0, 5)
processed_var = pybamm.ProcessedVariable(var_sol,
pybamm.Solution(t_sol, y_sol))
# 3 vectors
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, r_sol).shape, (10, 40, 50))
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, r_sol),
np.reshape(
y_sol,
[len(r_sol), len(x_sol), len(t_sol)]),
)
# 2 vectors, 1 scalar
np.testing.assert_array_equal(
processed_var(0.5, x_sol, r_sol).shape, (10, 40))
np.testing.assert_array_equal(
processed_var(t_sol, 0.2, r_sol).shape, (10, 50))
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, 0.5).shape, (40, 50))
# 1 vectors, 2 scalar
np.testing.assert_array_equal(
processed_var(0.5, 0.2, r_sol).shape, (10, ))
np.testing.assert_array_equal(
processed_var(0.5, x_sol, 0.5).shape, (40, ))
np.testing.assert_array_equal(
processed_var(t_sol, 0.2, 0.5).shape, (50, ))
# 3 scalars
np.testing.assert_array_equal(processed_var(0.2, 0.2, 0.2).shape, ())
# positive particle
var = pybamm.Variable(
"var",
domain=["positive particle"],
auxiliary_domains={"secondary": ["positive electrode"]},
)
x = pybamm.SpatialVariable("x", domain=["positive electrode"])
r = pybamm.SpatialVariable("r", domain=["positive particle"])
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
r_sol = disc.process_symbol(r).entries[:, 0]
# Keep only the first iteration of entries
r_sol = r_sol[:len(r_sol) // len(x_sol)]
var_sol = disc.process_symbol(var)
t_sol = np.linspace(0, 1)
y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(
0, 5)
processed_var = pybamm.ProcessedVariable(var_sol,
pybamm.Solution(t_sol, y_sol))
# 3 vectors
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, r_sol).shape, (10, 35, 50))
def test_1D_different_domains(self):
# Negative electrode domain
var = pybamm.Variable("var", domain=["negative electrode"])
x = pybamm.SpatialVariable("x", domain=["negative electrode"])
disc = tests.get_discretisation_for_testing()
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = [0]
y_sol = np.ones_like(x_sol)[:, np.newaxis] * 5
sol = pybamm.Solution(t_sol, y_sol)
pybamm.ProcessedSymbolicVariable(var_sol, sol)
# Particle domain
var = pybamm.Variable("var", domain=["negative particle"])
r = pybamm.SpatialVariable("r", domain=["negative particle"])
disc = tests.get_discretisation_for_testing()
disc.set_variable_slices([var])
r_sol = disc.process_symbol(r).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = [0]
y_sol = np.ones_like(r_sol)[:, np.newaxis] * 5
sol = pybamm.Solution(t_sol, y_sol)
pybamm.ProcessedSymbolicVariable(var_sol, sol)
# Current collector domain
var = pybamm.Variable("var", domain=["current collector"])
z = pybamm.SpatialVariable("z", domain=["current collector"])
disc = tests.get_1p1d_discretisation_for_testing()
disc.set_variable_slices([var])
z_sol = disc.process_symbol(z).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = [0]
y_sol = np.ones_like(z_sol)[:, np.newaxis] * 5
sol = pybamm.Solution(t_sol, y_sol)
pybamm.ProcessedSymbolicVariable(var_sol, sol)
# Other domain
var = pybamm.Variable("var", domain=["line"])
x = pybamm.SpatialVariable("x", domain=["line"])
geometry = pybamm.Geometry(
{"line": {x: {"min": pybamm.Scalar(0), "max": pybamm.Scalar(1)}}}
)
submesh_types = {"line": pybamm.MeshGenerator(pybamm.Uniform1DSubMesh)}
var_pts = {x: 10}
mesh = pybamm.Mesh(geometry, submesh_types, var_pts)
disc = pybamm.Discretisation(mesh, {"line": pybamm.FiniteVolume()})
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = [0]
y_sol = np.ones_like(x_sol)[:, np.newaxis] * 5
sol = pybamm.Solution(t_sol, y_sol)
pybamm.ProcessedSymbolicVariable(var_sol, sol)
# 2D fails
var = pybamm.Variable(
"var",
domain=["negative particle"],
auxiliary_domains={"secondary": "negative electrode"},
)
r = pybamm.SpatialVariable(
"r",
domain=["negative particle"],
auxiliary_domains={"secondary": "negative electrode"},
)
disc = tests.get_p2d_discretisation_for_testing()
disc.set_variable_slices([var])
r_sol = disc.process_symbol(r).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = [0]
y_sol = np.ones_like(r_sol)[:, np.newaxis] * 5
sol = pybamm.Solution(t_sol, y_sol)
with self.assertRaisesRegex(NotImplementedError, "Shape not recognized"):
pybamm.ProcessedSymbolicVariable(var_sol, sol)
def test_processed_var_3D_interpolation(self):
var = pybamm.Variable("var", domain=["negative particle"])
x = pybamm.SpatialVariable("x", domain=["negative electrode"])
r = pybamm.SpatialVariable("r", domain=["negative particle"])
disc = tests.get_p2d_discretisation_for_testing()
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
r_sol = disc.process_symbol(r).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = np.linspace(0, 1)
y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(
0, 5)
processed_var = pybamm.ProcessedVariable(var_sol,
t_sol,
y_sol,
mesh=disc.mesh)
# 3 vectors
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, r_sol).shape, (40, 10, 50))
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, r_sol),
np.reshape(
y_sol,
[len(x_sol), len(r_sol), len(t_sol)]),
)
# 2 vectors, 1 scalar
np.testing.assert_array_equal(
processed_var(0.5, x_sol, r_sol).shape, (40, 10))
np.testing.assert_array_equal(
processed_var(t_sol, 0.2, r_sol).shape, (10, 50))
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, 0.5).shape, (40, 50))
# 1 vectors, 2 scalar
np.testing.assert_array_equal(
processed_var(0.5, 0.2, r_sol).shape, (10, ))
np.testing.assert_array_equal(
processed_var(0.5, x_sol, 0.5).shape, (40, ))
np.testing.assert_array_equal(
processed_var(t_sol, 0.2, 0.5).shape, (50, ))
# 3 scalars
np.testing.assert_array_equal(processed_var(0.2, 0.2, 0.2).shape, ())
# positive particle
var = pybamm.Variable("var", domain=["positive particle"])
x = pybamm.SpatialVariable("x", domain=["positive electrode"])
r = pybamm.SpatialVariable("r", domain=["positive particle"])
disc.set_variable_slices([var])
x_sol = disc.process_symbol(x).entries[:, 0]
r_sol = disc.process_symbol(r).entries[:, 0]
var_sol = disc.process_symbol(var)
t_sol = np.linspace(0, 1)
y_sol = np.ones(len(x_sol) * len(r_sol))[:, np.newaxis] * np.linspace(
0, 5)
processed_var = pybamm.ProcessedVariable(var_sol,
t_sol,
y_sol,
mesh=disc.mesh)
# 3 vectors
np.testing.assert_array_equal(
processed_var(t_sol, x_sol, r_sol).shape, (35, 10, 50))
