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)