def set_algebraic(self, variables):
param = self.param
applied_current = variables["Total current density"]
cc_area = self._get_effective_current_collector_area()
z = pybamm.standard_spatial_vars.z
phi_s_cn = variables["Negative current collector potential"]
phi_s_cp = variables["Positive current collector potential"]
i_boundary_cc = variables["Current collector current density"]
i_boundary_cc_0 = variables[
"Leading-order current collector current density"]
c = variables["Lagrange multiplier"]
# Note that the second argument of 'source' must be the same as the argument
# in the laplacian (the variable to which the boundary conditions are applied)
self.algebraic = {
phi_s_cn: (param.sigma_cn * param.delta**2 * param.l_cn) *
pybamm.laplacian(phi_s_cn) -
pybamm.source(i_boundary_cc_0, phi_s_cn),
i_boundary_cc: (param.sigma_cp * param.delta**2 * param.l_cp) *
pybamm.laplacian(phi_s_cp) +
pybamm.source(i_boundary_cc_0, phi_s_cp) +
c * pybamm.PrimaryBroadcast(cc_area, "current collector"),
c:
pybamm.Integral(i_boundary_cc, z) - applied_current / cc_area +
pybamm.Multiplication(0, c),
}
def test_convert_scalar_symbols(self):
a = pybamm.Scalar(0)
b = pybamm.Scalar(1)
c = pybamm.Scalar(-1)
d = pybamm.Scalar(2)
e = pybamm.Scalar(3)
g = pybamm.Scalar(3.3)
self.assertEqual(a.to_casadi(), casadi.MX(0))
self.assertEqual(d.to_casadi(), casadi.MX(2))
# negate
self.assertEqual((-b).to_casadi(), casadi.MX(-1))
# absolute value
self.assertEqual(abs(c).to_casadi(), casadi.MX(1))
# floor
self.assertEqual(pybamm.Floor(g).to_casadi(), casadi.MX(3))
# ceiling
self.assertEqual(pybamm.Ceiling(g).to_casadi(), casadi.MX(4))
# function
def square_plus_one(x):
return x**2 + 1
f = pybamm.Function(square_plus_one, b)
self.assertEqual(f.to_casadi(), 2)
def myfunction(x, y):
return x + y
f = pybamm.Function(myfunction, b, d)
self.assertEqual(f.to_casadi(), casadi.MX(3))
# use classes to avoid simplification
# addition
self.assertEqual((pybamm.Addition(a, b)).to_casadi(), casadi.MX(1))
# subtraction
self.assertEqual(pybamm.Subtraction(c, d).to_casadi(), casadi.MX(-3))
# multiplication
self.assertEqual(
pybamm.Multiplication(c, d).to_casadi(), casadi.MX(-2))
# power
self.assertEqual(pybamm.Power(c, d).to_casadi(), casadi.MX(1))
# division
self.assertEqual(pybamm.Division(b, d).to_casadi(), casadi.MX(1 / 2))
# modulo
self.assertEqual(pybamm.Modulo(e, d).to_casadi(), casadi.MX(1))
# minimum and maximum
self.assertEqual(pybamm.Minimum(a, b).to_casadi(), casadi.MX(0))
self.assertEqual(pybamm.Maximum(a, b).to_casadi(), casadi.MX(1))
def test_convert_scalar_symbols(self):
a = pybamm.Scalar(0)
b = pybamm.Scalar(1)
c = pybamm.Scalar(-1)
d = pybamm.Scalar(2)
self.assertEqual(a.to_casadi(), casadi.MX(0))
self.assertEqual(d.to_casadi(), casadi.MX(2))
# negate
self.assertEqual((-b).to_casadi(), casadi.MX(-1))
# absolute value
self.assertEqual(abs(c).to_casadi(), casadi.MX(1))
# function
def sin(x):
return np.sin(x)
f = pybamm.Function(sin, b)
self.assertEqual(f.to_casadi(), casadi.MX(np.sin(1)))
def myfunction(x, y):
return x + y
f = pybamm.Function(myfunction, b, d)
self.assertEqual(f.to_casadi(), casadi.MX(3))
# use classes to avoid simplification
# addition
self.assertEqual((pybamm.Addition(a, b)).to_casadi(), casadi.MX(1))
# subtraction
self.assertEqual(pybamm.Subtraction(c, d).to_casadi(), casadi.MX(-3))
# multiplication
self.assertEqual(
pybamm.Multiplication(c, d).to_casadi(), casadi.MX(-2))
# power
self.assertEqual(pybamm.Power(c, d).to_casadi(), casadi.MX(1))
# division
self.assertEqual(pybamm.Division(b, d).to_casadi(), casadi.MX(1 / 2))
# minimum and maximum
self.assertEqual(pybamm.Minimum(a, b).to_casadi(), casadi.MX(0))
self.assertEqual(pybamm.Maximum(a, b).to_casadi(), casadi.MX(1))
def __rmul__(self, other):
"""return a :class:`Multiplication` object"""
return pybamm.simplify_if_constant(pybamm.Multiplication(other, self),
keep_domains=True)
def __rmul__(self, other):
"""return a :class:`Multiplication` object"""
if isinstance(other, (Symbol, numbers.Number)):
return pybamm.Multiplication(other, self)
else:
raise NotImplementedError
def simplified_multiplication(left, right):
left, right = simplify_elementwise_binary_broadcasts(left, right)
# Check for Concatenations and Broadcasts
out = simplified_binary_broadcast_concatenation(left, right,
simplified_multiplication)
if out is not None:
return out
# simplify multiply by scalar zero, being careful about shape
if pybamm.is_scalar_zero(left):
return pybamm.zeros_like(right)
if pybamm.is_scalar_zero(right):
return pybamm.zeros_like(left)
# if one of the children is a zero matrix, we have to be careful about shapes
if pybamm.is_matrix_zero(left) or pybamm.is_matrix_zero(right):
return pybamm.zeros_like(pybamm.Multiplication(left, right))
# anything multiplied by a scalar one returns itself
if pybamm.is_scalar_one(left):
return right
if pybamm.is_scalar_one(right):
return left
# anything multiplied by a scalar negative one returns negative itself
if pybamm.is_scalar_minus_one(left):
return -right
if pybamm.is_scalar_minus_one(right):
return -left
# anything multiplied by a matrix one returns itself if
# - the shapes are the same
# - both left and right evaluate on edges, or both evaluate on nodes, in all
# dimensions
# (and possibly more generally, but not implemented here)
try:
if left.shape_for_testing == right.shape_for_testing and all(
left.evaluates_on_edges(dim) == right.evaluates_on_edges(dim)
for dim in ["primary", "secondary", "tertiary"]):
if pybamm.is_matrix_one(left):
return right
elif pybamm.is_matrix_one(right):
return left
# also check for negative one
if pybamm.is_matrix_minus_one(left):
return -right
elif pybamm.is_matrix_minus_one(right):
return -left
except NotImplementedError:
pass
# Return constant if both sides are constant
if left.is_constant() and right.is_constant():
return pybamm.simplify_if_constant(pybamm.Multiplication(left, right))
# Simplify (B @ c) * a to (a * B) @ c if (a * B) is constant
# This is a common construction that appears from discretisation of spatial
# operators
if (isinstance(left, MatrixMultiplication) and left.left.is_constant()
and right.is_constant()
and not (right.ndim_for_testing == 2
and right.shape_for_testing[1] > 1)):
l_left, l_right = left.orphans
new_left = right * l_left
# Special hack for the case where l_left is a matrix one
# because of weird domain errors otherwise
if new_left == right and isinstance(right, pybamm.Array):
new_left = right.new_copy()
# be careful about domains to avoid weird errors
new_left.clear_domains()
new_mul = new_left @ l_right
# Keep the domain of the old left
new_mul.copy_domains(left)
return new_mul
elif isinstance(left, Multiplication) and right.is_constant():
# Simplify (a * b) * c to (a * c) * b if (a * c) is constant
if left.left.is_constant():
l_left, l_right = left.orphans
new_left = l_left * right
return new_left * l_right
# Simplify (a * b) * c to a * (b * c) if (b * c) is constant
elif left.right.is_constant():
l_left, l_right = left.orphans
new_right = l_right * right
return l_left * new_right
elif isinstance(left, Division) and right.is_constant():
# Simplify (a / b) * c to a * (c / b) if (c / b) is constant
if left.right.is_constant():
l_left, l_right = left.orphans
new_right = right / l_right
return l_left * new_right
# Simplify a * (B @ c) to (a * B) @ c if (a * B) is constant
if (isinstance(right, MatrixMultiplication) and right.left.is_constant()
and left.is_constant()
and not (left.ndim_for_testing == 2
and left.shape_for_testing[1] > 1)):
r_left, r_right = right.orphans
new_left = left * r_left
# Special hack for the case where r_left is a matrix one
# because of weird domain errors otherwise
if new_left == left and isinstance(left, pybamm.Array):
new_left = left.new_copy()
# be careful about domains to avoid weird errors
new_left.clear_domains()
new_mul = new_left @ r_right
# Keep the domain of the old right
new_mul.copy_domains(right)
return new_mul
elif isinstance(right, Multiplication) and left.is_constant():
# Simplify a * (b * c) to (a * b) * c if (a * b) is constant
if right.left.is_constant():
r_left, r_right = right.orphans
new_left = left * r_left
return new_left * r_right
# Simplify a * (b * c) to (a * c) * b if (a * c) is constant
elif right.right.is_constant():
r_left, r_right = right.orphans
new_left = left * r_right
return new_left * r_left
elif isinstance(right, Division) and left.is_constant():
# Simplify a * (b / c) to (a / c) * b if (a / c) is constant
if right.right.is_constant():
r_left, r_right = right.orphans
new_left = left / r_right
return new_left * r_left
# Simplify a * (b + c) to (a * b) + (a * c) if (a * b) or (a * c) is constant
# This is a common construction that appears from discretisation of spatial
# operators
# Also do this for cases like a * (b @ c + d) where (a * b) is constant
elif isinstance(right, Addition):
mul_classes = (
pybamm.Multiplication,
pybamm.MatrixMultiplication,
pybamm.Division,
)
if (right.left.is_constant() or right.right.is_constant()
or (isinstance(right.left, mul_classes)
and right.left.left.is_constant())
or (isinstance(right.right, mul_classes)
and right.right.left.is_constant())):
r_left, r_right = right.orphans
if (r_left.domain == right.domain
or r_left.domain == []) and (r_right.domain == right.domain
or r_right.domain == []):
return (left * r_left) + (left * r_right)
# Negation simplifications
if isinstance(left, pybamm.Negate) and right.is_constant():
# Simplify (-a) * b to a * (-b) if (-b) is constant
return left.orphans[0] * (-right)
elif isinstance(right, pybamm.Negate) and left.is_constant():
# Simplify a * (-b) to (-a) * b if (-a) is constant
return (-left) * right.orphans[0]
return pybamm.Multiplication(left, right)
