#546 make FullBroadcast explicit

pybamm/models/submodels/electrode/base_electrode.py

@@ -120,7 +120,7 @@ def _get_standard_whole_cell_current_variables(self, variables):
             current variables added.
         """
         i_s_n = variables["Negative electrode current density"]
-        i_s_s = pybamm.FullBroadcast(0, ["separator"])
+        i_s_s = pybamm.FullBroadcast(0, ["separator"], "current collector")
         i_s_p = variables["Positive electrode current density"]
 
         i_s = pybamm.Concatenation(i_s_n, i_s_s, i_s_p)

pybamm/models/submodels/electrode/ohm/leading_ohm.py

@@ -37,7 +37,7 @@ def get_coupled_variables(self, variables):
         x_p = pybamm.standard_spatial_vars.x_p
 
         if self.domain == "Negative":
-            phi_s = pybamm.FullBroadcast(0, ["negative electrode"])
+            phi_s = pybamm.FullBroadcast(0, ["negative electrode"], "current collector")
             i_s = pybamm.outer(i_boundary_cc, 1 - x_n / l_n)
 
         elif self.domain == "Positive":

pybamm/models/submodels/electrolyte/stefan_maxwell/conductivity/surface_potential_form/full_surface_form_stefan_maxwell_conductivity.py

@@ -202,7 +202,7 @@ def _get_sep_coupled_variables(self, variables):
             x_s,
         )
 
-        i_e_s = pybamm.FullBroadcast(i_boundary_cc, ["separator"])
+        i_e_s = pybamm.FullBroadcast(i_boundary_cc, ["separator"], "current collector")
 
         variables.update(self._get_domain_potential_variables(phi_e_s))
         variables.update(self._get_domain_current_variables(i_e_s))

pybamm/models/submodels/electrolyte/stefan_maxwell/diffusion/leading_stefan_maxwell_diffusion.py

@@ -36,7 +36,9 @@ def get_fundamental_variables(self):
     def get_coupled_variables(self, variables):
 
         N_e = pybamm.FullBroadcast(
-            0, ["negative electrode", "separator", "positive electrode"]
+            0,
+            ["negative electrode", "separator", "positive electrode"],
+            "current collector",
         )
 
         variables.update(self._get_standard_flux_variables(N_e))

pybamm/models/submodels/interface/base_interface.py

@@ -56,7 +56,7 @@ def _get_standard_interfacial_current_variables(self, j):
         # Average, and broadcast if necessary
         j_av = pybamm.average(j)
         if j.domain == []:
-            j = pybamm.FullBroadcast(j, self.domain_for_broadcast)
+            j = pybamm.FullBroadcast(j, self.domain_for_broadcast, "current collector")
         elif j.domain == ["current collector"]:
             j = pybamm.PrimaryBroadcast(j, self.domain_for_broadcast)
 
@@ -141,7 +141,9 @@ def _get_standard_exchange_current_variables(self, j0):
         # Average, and broadcast if necessary
         j0_av = pybamm.average(j0)
         if j0.domain == []:
-            j0 = pybamm.FullBroadcast(j0, self.domain_for_broadcast)
+            j0 = pybamm.FullBroadcast(
+                j0, self.domain_for_broadcast, "current collector"
+            )
         elif j0.domain == ["current collector"]:
             j0 = pybamm.PrimaryBroadcast(j0, self.domain_for_broadcast)
 
@@ -203,7 +205,9 @@ def _get_standard_overpotential_variables(self, eta_r):
         # Average, and broadcast if necessary
         eta_r_av = pybamm.average(eta_r)
         if eta_r.domain == []:
-            eta_r = pybamm.FullBroadcast(eta_r, self.domain_for_broadcast)
+            eta_r = pybamm.FullBroadcast(
+                eta_r, self.domain_for_broadcast, "current collector"
+            )
         elif eta_r.domain == ["current collector"]:
             eta_r = pybamm.PrimaryBroadcast(eta_r, self.domain_for_broadcast)
 
@@ -241,7 +245,9 @@ def _get_standard_surface_potential_difference_variables(self, delta_phi):
         # Average, and broadcast if necessary
         delta_phi_av = pybamm.average(delta_phi)
         if delta_phi.domain == []:
-            delta_phi = pybamm.FullBroadcast(delta_phi, self.domain_for_broadcast)
+            delta_phi = pybamm.FullBroadcast(
+                delta_phi, self.domain_for_broadcast, "current collector"
+            )
         elif delta_phi.domain == ["current collector"]:
             delta_phi = pybamm.PrimaryBroadcast(delta_phi, self.domain_for_broadcast)
 
@@ -283,7 +289,9 @@ def _get_standard_ocp_variables(self, ocp, dUdT):
         # Average, and broadcast if necessary
         ocp_av = pybamm.average(ocp)
         if ocp.domain == []:
-            ocp = pybamm.FullBroadcast(ocp, self.domain_for_broadcast)
+            ocp = pybamm.FullBroadcast(
+                ocp, self.domain_for_broadcast, "current collector"
+            )
         elif ocp.domain == ["current collector"]:
             ocp = pybamm.PrimaryBroadcast(ocp, self.domain_for_broadcast)
         dUdT_av = pybamm.average(dUdT)

pybamm/models/submodels/oxygen_diffusion/composite_oxygen_diffusion.py

@@ -43,7 +43,9 @@ def get_coupled_variables(self, variables):
 
         N_ox = N_ox_diffusion  # + c_ox * v_box
         # Flux in the negative electrode is zero
-        N_ox = pybamm.Concatenation(pybamm.FullBroadcast(0, "negative electrode"), N_ox)
+        N_ox = pybamm.Concatenation(
+            pybamm.FullBroadcast(0, "negative electrode", "current collector"), N_ox
+        )
 
         variables.update(self._get_standard_flux_variables(N_ox))
 

pybamm/models/submodels/oxygen_diffusion/full_oxygen_diffusion.py

@@ -46,7 +46,7 @@ def __init__(self, param, reactions):
 
     def get_fundamental_variables(self):
         # Oxygen concentration (oxygen concentration is zero in the negative electrode)
-        c_ox_n = pybamm.FullBroadcast(0, "negative electrode")
+        c_ox_n = pybamm.FullBroadcast(0, "negative electrode", "current collector")
         c_ox_s = pybamm.Variable(
             "Separator oxygen concentration",
             domain="separator",

pybamm/models/submodels/oxygen_diffusion/leading_oxygen_diffusion.py

@@ -25,17 +25,23 @@ def __init__(self, param, reactions):
 
     def get_fundamental_variables(self):
         c_ox_av = pybamm.Variable("Average oxygen concentration")
-        c_ox_n = pybamm.FullBroadcast(c_ox_av, ["negative electrode"])
-        c_ox_s = pybamm.FullBroadcast(c_ox_av, ["separator"])
-        c_ox_p = pybamm.FullBroadcast(c_ox_av, ["positive electrode"])
+        c_ox_n = pybamm.FullBroadcast(
+            c_ox_av, ["negative electrode"], "current collector"
+        )
+        c_ox_s = pybamm.FullBroadcast(c_ox_av, ["separator"], "current collector")
+        c_ox_p = pybamm.FullBroadcast(
+            c_ox_av, ["positive electrode"], "current collector"
+        )
         c_ox = pybamm.Concatenation(c_ox_n, c_ox_s, c_ox_p)
 
         return self._get_standard_concentration_variables(c_ox)
 
     def get_coupled_variables(self, variables):
 
         N_ox = pybamm.FullBroadcast(
-            0, ["negative electrode", "separator", "positive electrode"]
+            0,
+            ["negative electrode", "separator", "positive electrode"],
+            "current collector",
         )
 
         variables.update(self._get_standard_flux_variables(N_ox))

pybamm/models/submodels/oxygen_diffusion/no_oxygen.py

@@ -22,15 +22,17 @@ def __init__(self, param):
         super().__init__(param)
 
     def get_fundamental_variables(self):
-        c_ox_n = pybamm.FullBroadcast(0, ["negative electrode"])
-        c_ox_s = pybamm.FullBroadcast(0, ["separator"])
-        c_ox_p = pybamm.FullBroadcast(0, ["positive electrode"])
+        c_ox_n = pybamm.FullBroadcast(0, ["negative electrode"], "current collector")
+        c_ox_s = pybamm.FullBroadcast(0, ["separator"], "current collector")
+        c_ox_p = pybamm.FullBroadcast(0, ["positive electrode"], "current collector")
         c_ox = pybamm.Concatenation(c_ox_n, c_ox_s, c_ox_p)
 
         variables = self._get_standard_concentration_variables(c_ox)
 
         N_e = pybamm.FullBroadcast(
-            0, ["negative electrode", "separator", "positive electrode"]
+            0,
+            ["negative electrode", "separator", "positive electrode"],
+            "current collector",
         )
 
         variables.update(self._get_standard_flux_variables(N_e))

pybamm/models/submodels/thermal/isothermal.py

@@ -34,7 +34,9 @@ def get_fundamental_variables(self):
     def _flux_law(self, T):
         """Zero heat flux since temperature is constant"""
         q = pybamm.FullBroadcast(
-            pybamm.Scalar(0), ["negative electrode", "separator", "positive electrode"]
+            pybamm.Scalar(0),
+            ["negative electrode", "separator", "positive electrode"],
+            "current collector",
         )
         return q
 

pybamm/parameters/standard_parameters_lead_acid.py

@@ -309,9 +309,9 @@ def U_p_dimensional(c_e, T):
 s_n = -(s_plus_n_S + t_plus)  # Dimensionless rection rate (neg)
 s_p = -(s_plus_p_S + t_plus)  # Dimensionless rection rate (pos)
 s = pybamm.Concatenation(
-    pybamm.FullBroadcast(s_n, ["negative electrode"]),
-    pybamm.FullBroadcast(0, ["separator"]),
-    pybamm.FullBroadcast(s_p, ["positive electrode"]),
+    pybamm.FullBroadcast(s_n, ["negative electrode"], "current collector"),
+    pybamm.FullBroadcast(0, ["separator"], "current collector"),
+    pybamm.FullBroadcast(s_p, ["positive electrode"], "current collector"),
 )
 j0_n_S_ref = j0_n_S_ref_dimensional / interfacial_current_scale_n
 j0_p_S_ref = j0_p_S_ref_dimensional / interfacial_current_scale_p
@@ -343,9 +343,9 @@ def U_p_dimensional(c_e, T):
 beta_surf_n = -c_e_typ * DeltaVsurf_n / ne_n_S  # Molar volume change (lead)
 beta_surf_p = -c_e_typ * DeltaVsurf_p / ne_p_S  # Molar volume change (lead dioxide)
 beta_surf = pybamm.Concatenation(
-    pybamm.FullBroadcast(beta_surf_n, ["negative electrode"]),
-    pybamm.FullBroadcast(0, ["separator"]),
-    pybamm.FullBroadcast(beta_surf_p, ["positive electrode"]),
+    pybamm.FullBroadcast(beta_surf_n, ["negative electrode"], "current collector"),
+    pybamm.FullBroadcast(0, ["separator"], "current collector"),
+    pybamm.FullBroadcast(beta_surf_p, ["positive electrode"], "current collector"),
 )
 beta_liq_n = -c_e_typ * DeltaVliq_n / ne_n_S  # Molar volume change (electrolyte, neg)
 beta_liq_p = -c_e_typ * DeltaVliq_p / ne_p_S  # Molar volume change (electrolyte, pos)
@@ -378,9 +378,9 @@ def U_p_dimensional(c_e, T):
 eps_s_init = eps_s_max
 eps_p_init = eps_p_max + beta_surf_p * Q_e_max / l_p * (1 - q_init)
 eps_init = pybamm.Concatenation(
-    pybamm.FullBroadcast(eps_n_init, ["negative electrode"]),
-    pybamm.FullBroadcast(eps_s_init, ["separator"]),
-    pybamm.FullBroadcast(eps_p_init, ["positive electrode"]),
+    pybamm.FullBroadcast(eps_n_init, ["negative electrode"], "current collector"),
+    pybamm.FullBroadcast(eps_s_init, ["separator"], "current collector"),
+    pybamm.FullBroadcast(eps_p_init, ["positive electrode"], "current collector"),
 )
 curlyU_n_init = Q_e_max * (1.2 - q_init) / (Q_n_max * l_n)
 curlyU_p_init = Q_e_max * (1.2 - q_init) / (Q_p_max * l_p)

pybamm/parameters/standard_parameters_lithium_ion.py

@@ -76,9 +76,9 @@
 a_n_dim = pybamm.geometric_parameters.a_n_dim
 a_p_dim = pybamm.geometric_parameters.a_p_dim
 a_k_dim = pybamm.Concatenation(
-    pybamm.FullBroadcast(a_n_dim, ["negative electrode"]),
-    pybamm.FullBroadcast(0, ["separator"]),
-    pybamm.FullBroadcast(a_p_dim, ["positive electrode"]),
+    pybamm.FullBroadcast(a_n_dim, ["negative electrode"], "current collector"),
+    pybamm.FullBroadcast(0, ["separator"], "current collector"),
+    pybamm.FullBroadcast(a_p_dim, ["positive electrode"], "current collector"),
 )
 R_n = pybamm.geometric_parameters.R_n
 R_p = pybamm.geometric_parameters.R_p
@@ -260,9 +260,9 @@ def U_p_dimensional(sto, T):
 epsilon_s = pybamm.Parameter("Separator porosity")
 epsilon_p = pybamm.Parameter("Positive electrode porosity")
 epsilon = pybamm.Concatenation(
-    pybamm.FullBroadcast(epsilon_n, ["negative electrode"]),
-    pybamm.FullBroadcast(epsilon_s, ["separator"]),
-    pybamm.FullBroadcast(epsilon_p, ["positive electrode"]),
+    pybamm.FullBroadcast(epsilon_n, ["negative electrode"], "current collector"),
+    pybamm.FullBroadcast(epsilon_s, ["separator"], "current collector"),
+    pybamm.FullBroadcast(epsilon_p, ["positive electrode"], "current collector"),
 )
 a_n = a_n_dim * R_n
 a_p = a_p_dim * R_p

pybamm/parameters/thermal_parameters.py

@@ -69,9 +69,9 @@
 rho_cp = rho_cp_dim * c_p_cp_dim / rho_eff_dim
 
 rho_k = pybamm.Concatenation(
-    pybamm.FullBroadcast(rho_n, ["negative electrode"]),
-    pybamm.FullBroadcast(rho_s, ["separator"]),
-    pybamm.FullBroadcast(rho_p, ["positive electrode"]),
+    pybamm.FullBroadcast(rho_n, ["negative electrode"], "current collector"),
+    pybamm.FullBroadcast(rho_s, ["separator"], "current collector"),
+    pybamm.FullBroadcast(rho_p, ["positive electrode"], "current collector"),
 )
 
 lambda_cn = lambda_cn_dim / lambda_eff_dim
@@ -81,9 +81,9 @@
 lambda_cp = lambda_cp_dim / lambda_eff_dim
 
 lambda_k = pybamm.Concatenation(
-    pybamm.FullBroadcast(lambda_n, ["negative electrode"]),
-    pybamm.FullBroadcast(lambda_s, ["separator"]),
-    pybamm.FullBroadcast(lambda_p, ["positive electrode"]),
+    pybamm.FullBroadcast(lambda_n, ["negative electrode"], "current collector"),
+    pybamm.FullBroadcast(lambda_s, ["separator"], "current collector"),
+    pybamm.FullBroadcast(lambda_p, ["positive electrode"], "current collector"),
 )