Repository: tinosulzer/PyBaMM

Issue:
Clean up parameters
After discussions with @Scottmar93 and @rtimms we have come up with a set of parameters that is common to both lead-acid and lithium-ion models.

We now need to clean up the files `standard_parameters` and `standard_parameters_lead_acid` to use this common parameter framework. We should also use more informative names in the parameter strings as there is no reason to use an abbreviation there, e.g. 
```python3
c_max = Parameter("maximum electrolyte concentration")
```

Discussion:

Patch:
diff --git a/input/parameters/lead-acid/darken_thermodynamic_factor_Chapman1968.py b/input/parameters/lead-acid/darken_thermodynamic_factor_Chapman1968.py
new file mode 100644
index 00000000..2eb9f1b4
--- /dev/null
+++ b/input/parameters/lead-acid/darken_thermodynamic_factor_Chapman1968.py
@@ -0,0 +1,21 @@
+#
+# Darken thermodynamic factor
+#
+
+
+def darken_thermodynamic_factor_Chapman1968(c_e):
+    """
+    Dimensional Darken thermodynamic factor in the electrolyte [-], from data in
+    [1, 2]_, as a function of the electrolyte concentration c_e [mol.m-3].
+
+    References
+    ----------
+    .. [1] TW Chapman and J Newman. Compilation of selected thermodynamic and transport
+           properties of binary electrolytes in aqueous solution. Technical report,
+           California Univ., Berkeley. Lawrence Radiation Lab., 1968.
+    .. [2] KS Pitzer, RN Roy, and LF Silvester. Thermodynamics of electrolytes. 7.
+           sulfuric acid. Journal of the American Chemical Society, 99(15):4930–4936,
+           1977.
+
+    """
+    return 0.49 + 4.1e-4 * c_e
diff --git a/input/parameters/lead-acid/default.csv b/input/parameters/lead-acid/default.csv
index bcb23d07..76db0662 100644
--- a/input/parameters/lead-acid/default.csv
+++ b/input/parameters/lead-acid/default.csv
@@ -1,70 +1,70 @@
-Name,Value,Units,Meaning,Reference,Notes
-# Empty rows and rows starting with ‘#’ will be ignored,,,,,
-,,,,,
-# Constants,,,,,
-R,8.314,J.K-1.mol-1,Ideal gas constant,-,
-F,96487,C.mol-1,Faraday’s constant,-,
-T_ref,294.85,K,Reference Temperature,Room temperature,
-,,,,,
-# Geometric,,,,,
-Ln,0.0009,m,Half-width of negative electrode,Manufacturer,
-Ls,0.0015,m,Width of separator,Manufacturer,
-Lp,0.00125,m,Half-width of positive electrode,Manufacturer,
-H,0.114,m,Electrode height,Manufacturer,
-W,0.065,m,Electrode depth,Manufacturer,
-,,,,,
-# Electrical,,,,,
-Q,17,A.h,Cell capacity,Manufacturer,
-voltage_cutoff_circuit,10.5,V,Voltage cutoff point for a 6-cell battery,-,
-number of electrodes in parallel,8,-,Number of electrodes connected in parallel to make a cell,Manufacturer,
-number of cells in series,6,-,Number of cells connected in series to make a battery,Manufacturer,
-q_init,1,-,Initial State of Charge,-,
-,,,,,
-# Reactions,,,,,
-s_plus_n,-1,-,s_+ in the negative electrode,,
-s_plus_p,-3,-,s_+ in the positive electrode,,
-ne_n,2,-,number of electrons involved in the reaction (neg electrode),,
-ne_p,2,-,number of electrons involved in the reaction (pos electrode),,
-,,,,,
-# Microstructure,,,,,
-Anmax,2300000,m-1,Negative electrode surface area density,,
-Apmax,23000000,m-1,Positive electrode surface area density,,
-epsn_max,0.53,-,Max porosity of negative electrode,,
-epss_max,0.92,-,Max porosity of separator,,
-epsp_max,0.57,,Max porosity of positive electrode,,
-Qnmax_hat,3473000000,C.m-3,Negative electrode capacity,,
-Qpmax_hat,2745000000,C.m-3,Positive electrode capacity,,
-,,,,,
-# Electrolyte physical properties,,,,,
-cmax,5650,mol.m-3,Maximum electrolyte concentration,,
-t_plus,0.7,-,Cation transference number,,
-Vw,1.75E-05,m3.mol-1,Partial molar volume of water,,
-V_minus,3.15E-05,m3.mol-1,Partial molar volume of anions,,
-V_plus,1.35E-05,m3.mol-1,Partial molar volume of cations,,
-Mw,0.01801,m3.mol-1,Molar mass of water,,
-nu_plus,1,-,Stoichiometry of hydrogen cations,,
-nu_minus,1,-,Stoichiometry of hydrogen sulfate anions,,
-,,,,,
-# Electrode physical properties,,,,,
-VPb,1.82539682539683E-05,m3.mol-1,Molar volume of lead ,,Calculated as () divided by ()
-VPbO2,2.54797441364606E-05,m3.mol-1,Molar volume of lead-dioxide,,
-VPbSO4,4.81717011128776E-05,m3.mol-1,Molar volume of lead sulfate,,
-sigma_n,4800000,S.m-1,Conductivity of lead,,
-sigma_p,80000,S.m-1,Conductivity of lead-dioxide,,
-d,1E-07,m,Pore size,,
-,,,,,
-# Interfacial reactions,,,,,
-Cdl,0.2,F.m-2,Double-layer capacity,,
-U_Pb_ref,-0.294,V,Lead reference OCP vs SHE,,
-U_PbO2_ref,1.628,V,Lead-dioxide reference OCP vs SHE,,
-jref_n,0.06,A.m-2,Reference exchange-current density (neg electrode),,
-jref_p,0.004,A.m-2,Reference exchange-current density (pos electrode),,
-U_O2_hat,1.229,V,Oxygen reference OCP vs SHE,,
-jrefO2_n,2.5E-32,A.m-2,"Ref exchange-current density (O2 reaction, neg electrode)",,
-jrefO2_p,1.56E-11,A.m-2,"Ref exchange-current density (O2 reaction,pos electrode)",,
-U_H2_hat,0,V,Hydrogen reference OCP vs SHE,,
-jrefH2_n,2.5E-23,A.m-2,"Ref exchange-current density (H2 reaction, neg electrode)",,
-jrefH2_p,0,A.m-2,"Ref exchange-current density (H2 reaction,pos electrode)",,
-,,,,,
-# Temperature,,,,,
-T_max,333.15,K,Maximum temperature,,
+Name,Value,Units,Reference,Notes
+# Empty rows and rows starting with ‘#’ will be ignored,,,,
+,,,,
+# Physical constants,,,,
+Ideal gas constant,8.314,J.K-1.mol-1,-,
+Faraday's constant,96487,C.mol-1,-,
+Reference temperature,294.85,K,Room temperature,
+,,,,
+# Macroscale geometry,,,,
+Negative electrode width,0.0009,m,Manufacturer,
+Separator width,0.0015,m,Manufacturer,
+Positive electrode width,0.00125,m,Manufacturer,
+Electrode height,0.114,m,Manufacturer,
+Electrode depth,0.065,m,Manufacturer,
+,,,,
+# Electrical,,,,
+Cell capacity,17,A.h,Manufacturer,
+Number of electrodes connected in parallel to make a cell,8,-,Manufacturer,
+Number of cells connected in series to make a battery,6,-,Manufacturer,
+Lower voltage cut-off,1.75,V,,10.5V across 6-cell battery
+Upper voltage cut-off,2.42,V,,14.5V across 6-cell battery
+Initial State of Charge,1,-,-,
+,,,,
+# Electrolyte properties,,,,
+Typical electrolyte concentration,5650,mol.m-3,,
+Cation transference number,0.7,-,,
+Partial molar volume of water,1.75E-05,m3.mol-1,,
+Partial molar volume of anions,3.15E-05,m3.mol-1,,
+Partial molar volume of cations,1.35E-05,m3.mol-1,,
+Cation stoichiometry,1,-,,Hydrogen cations
+Anion stoichiometry,1,-,,Hydrogen sulfate anions
+Molar mass of water,0.01801,m3.mol-1,,
+Molar mass of cations,,,,Hydrogen cations
+Molar mass of anions,,,,Hydrogen sulfate anions
+,,,,
+# Electrode properties,,,,
+Negative electrode conductivity,4800000,S.m-1,,Lead
+Positive electrode conductivity,80000,S.m-1,,Lead-oxide
+Pore size,1E-07,m,,
+Maximum porosity of negative electrode,0.53,-,,
+Maximum porosity of separator,0.92,-,,
+Maximum porosity of positive electrode,0.57,,,
+Molar volume of lead,1.82539682539683E-05,m3.mol-1,,Calculated as () divided by ()
+Molar volume of lead-dioxide,2.54797441364606E-05,m3.mol-1,,
+Molar volume of lead sulfate,4.81717011128776E-05,m3.mol-1,,
+,,,,
+# Microstructure,,,,
+Negative electrode surface area density,2300000,m-1,,
+Positive electrode surface area density,23000000,m-1,,
+Bruggeman coefficient,1.5,-,,
+Negative electrode capacity,3473000000,C.m-3,,
+Positive electrode capacity,2745000000,C.m-3,,
+,,,,
+# Interfacial reactions,,,,
+Negative electrode cation signed stoichiometry,-1,-,,
+Positive electrode cation signed stoichiometry,-3,-,,
+Negative electrode electrons in reaction,2,-,,
+Positive electrode electrons in reaction,2,-,,
+Double-layer capacity,0.2,F.m-2,,
+Negative electrode reference exchange-current density,0.06,A.m-2,,
+Positive electrode reference exchange-current density,0.004,A.m-2,,
+Oxygen reference OCP vs SHE,1.229,V,,
+"Ref exchange-current density (O2 reaction, neg electrode)",2.5E-32,A.m-2,,
+"Ref exchange-current density (O2 reaction,pos electrode)",1.56E-11,A.m-2,,
+Hydrogen reference OCP vs SHE,0,V,,
+"Ref exchange-current density (H2 reaction, neg electrode)",2.5E-23,A.m-2,,
+"Ref exchange-current density (H2 reaction,pos electrode)",0,A.m-2,,
+,,,,
+# Temperature,,,,
+Maximum temperature,333.15,K,,
diff --git a/input/parameters/lead-acid/electrolyte_conductivity_Gu1997.py b/input/parameters/lead-acid/electrolyte_conductivity_Gu1997.py
new file mode 100644
index 00000000..ce260acc
--- /dev/null
+++ b/input/parameters/lead-acid/electrolyte_conductivity_Gu1997.py
@@ -0,0 +1,26 @@
+#
+# Electrolyte conductivity
+#
+import numpy as np
+
+
+def electrolyte_conductivity_Gu1997(c_e):
+    """
+    Dimensional conductivity in the electrolyte [S.m-1], from [1]_ citing [2]_ and
+    agreeing with data in [3]_, as a function of the electrolyte concentration
+    c_e [mol.m-3].
+
+    References
+    ----------
+    .. [1] WB Gu, CY Wang, and BY Liaw. Numerical modeling of coupled electrochemical
+           and transport processes in lead-acid batteries. Journal of The
+           Electrochemical Society, 144(6):2053–2061, 1997.
+    .. [2] WH Tiedemann and J Newman. Battery design and optimization. Journal of
+           Electrochemical Society, Softbound Proceeding Series, Princeton, New York,
+           79(1):23, 1979.
+    .. [3] TW Chapman and J Newman. Compilation of selected thermodynamic and transport
+           properties of binary electrolytes in aqueous solution. Technical report,
+           California Univ., Berkeley. Lawrence Radiation Lab., 1968.
+
+    """
+    return c_e * np.exp(6.23 - 1.34e-4 * c_e - 1.61e-8 * c_e ** 2) * 1e-4
diff --git a/input/parameters/lead-acid/electrolyte_diffusivity.py b/input/parameters/lead-acid/electrolyte_diffusivity.py
deleted file mode 100644
index d7d9f3c5..00000000
--- a/input/parameters/lead-acid/electrolyte_diffusivity.py
+++ /dev/null
@@ -1,193 +0,0 @@
-#
-# Electrolyte diffusivity
-#
-
-
-def electrolyte_diffusivity(c):
-    """
-    Dimensional effective Fickian diffusivity in the electrolyte [m2.s-1].
-
-    Parameters
-    ----------
-    c
-        Electrolyte concentration [mol.m-3]
-    """
-    return (1.75 + 260e-6 * c) * 1e-9
-
-
-#
-# def kappa_hat(param, c):
-#     """Dimensional effective conductivity in the electrolyte [S.m-1]"""
-#     return c * np.exp(6.23 - 1.34e-4 * c - 1.61e-8 * c ** 2) * 1e-4
-#
-#
-# def kappa_eff(param, c, eps):
-#     """Dimensionless molar conductivity in the electrolyte"""
-#     kappa_scale = (
-#         param._raw["F"] ** 2
-#         * param._raw["cmax"]
-#         * D_hat(param._raw["cmax"])
-#         / (param._raw["R"] * param._raw["T_ref"])
-#     )
-#     return kappa_hat(param, c * param._raw["cmax"]) / kappa_scale * (eps ** 1.5)
-#
-#
-# def chi_hat(c):
-#     """Dimensional Darken thermodynamic factor in the electrolyte [-]"""
-#     return 0.49 + 4.1e-4 * c
-#
-#
-# def chi(param, c):
-#     """Dimensionless Darken thermodynamic factor in the electrolyte"""
-#     # Excluded volume fraction
-#     alpha = (2 * param._raw["Vw"] - param._raw["Ve"]) * param.scales["conc"]
-#     chi_scale = 1 / (2 * (1 - param._raw["tpw"]))
-#     return chi_hat(c * param._raw["cmax"]) / chi_scale / (1 + alpha * c)
-#
-#
-# # def curlyK_hat(param, eps):
-# #     """Dimensional permeability [m2]"""
-# #     return eps ** 3 * param._raw["d"] ** 2 / (180 * (1 - eps) ** 2)
-# #
-# #
-# # def curlyK(param, eps):
-# #     """Dimensionless permeability"""
-# #     return curlyK_hat(eps) / param._raw["d"] ** 2
-# #
-#
-#
-# def mu_hat(c):
-#     """Dimensional viscosity of electrolyte [kg.m-1.s-1]"""
-#     return 0.89e-3 + 1.11e-7 * c + 3.29e-11 * c ** 2
-#
-#
-# #
-# # def mu(param, c):
-# #     """Dimensionless viscosity of electrolyte"""
-# #     return mu_hat(c * param._raw["cmax"]) / mu_hat(param._raw["cmax"])
-# #
-# #
-# # def rho_hat(param, c):
-# #     """Dimensional density of electrolyte [kg.m-3]"""
-# #     return (
-# #         Mw
-# #         / param._raw["Vw"]
-# #         * (
-# #             1
-# #             + (
-# #                 param._raw["Me"] * param._raw["Vw"] / param._raw["Mw"]
-# #                 - param._raw["Ve"]
-# #             )
-# #             * c
-# #         )
-# #     )
-# #
-# #
-# # def rho(param, c):
-# #     """Dimensionless density of electrolyte"""
-# #     return rho_hat(c * param._raw["cmax"]) / rho_hat(param._raw["cmax"])
-#
-#
-# def cw_hat(param, c):
-#     """Dimensional solvent concentration [mol.m-3]"""
-#     return (1 - c * param._raw["Ve"]) / param._raw["Vw"]
-#
-#
-# def cw(param, c):
-#     """Dimensionless solvent concentration"""
-#     return cw_hat(param, c * param._raw["cmax"]) / cw_hat(param, param._raw["cmax"])
-#
-#
-# # def dcwdc(param, c):
-# #     """Dimensionless derivative of cw with respect to c"""
-# #     return 0 * c - param._raw["Ve"] / param._raw["Vw"]
-#
-#
-# def m(param, c):
-#     """Dimensional electrolyte molar mass [mol.kg-1]"""
-#     return c * param._raw["Vw"] / ((1 - c * param._raw["Ve"]) * param._raw["Mw"])
-#
-#
-# # def dmdc(param, c):
-# #     """Dimensional derivative of m with respect to c [kg-1]"""
-# #     return param.Vw / ((1 - c * param._raw["Ve"]) ** 2 * param._raw["Mw"])
-#
-#
-# def U_Pb(param, c):
-#     """Dimensionless OCP in the negative electrode"""
-#     m_ = m(param, c * param._raw["cmax"])  # dimensionless
-#     U = (
-#         param._raw["F"]
-#         / (param._raw["R"] * param._raw["T_ref"])
-#         * (
-#             -0.074 * np.log10(m_)
-#             - 0.030 * np.log10(m_) ** 2
-#             - 0.031 * np.log10(m_) ** 3
-#             - 0.012 * np.log10(m_) ** 4
-#         )
-#     )
-#     return U
-#
-#
-# # def U_Pb_hat(param, c):
-# #     """Dimensional OCP in the negative electrode [V]"""
-#     return param._raw["U_Pb_ref"] + param._raw["R"] * param._raw["T_ref"] /param._raw[
-# #         "F"
-# #     ] * U_Pb(c / param._raw["cmax"])
-#
-#
-# # def dUPbdc(param, c):
-# #     """Dimensionless derivative of U_Pb with respect to c"""
-# #     m_ = m(c * param._raw["cmax"])  # dimensionless
-# #     dUdm = (
-# #         param._raw["F"]
-# #         / (param._raw["R"] * param._raw["T_ref"])
-# #         * (
-# #             -0.074 / m_ / np.log(10)
-# #             - 0.030 * 2 * np.log(m_) / (m_ * np.log(10) ** 2)
-# #             - 0.031 * 3 * np.log(m_) ** 2 / m_ / np.log(10) ** 3
-# #             - 0.012 * 4 * np.log(m_) ** 3 / m_ / np.log(10) ** 4
-# #         )
-# #     )
-# #     dmdc = dmdc(c * param._raw["cmax"]) * param._raw["cmax"]  # dimensionless
-# #     return dmdc * dUdm
-#
-#
-# def U_PbO2(param, c):
-#     """Dimensionless OCP in the positive electrode"""
-#     m_ = m(param, c * param._raw["cmax"])
-#     U = (
-#         param._raw["F"]
-#         / (param._raw["R"] * param._raw["T_ref"])
-#         * (
-#             0.074 * np.log10(m_)
-#             + 0.033 * np.log10(m_) ** 2
-#             + 0.043 * np.log10(m_) ** 3
-#             + 0.022 * np.log10(m_) ** 4
-#         )
-#     )
-#     return U
-#
-#
-# # def U_PbO2_hat(param, c):
-# #     """Dimensional OCP in the positive electrode [V]"""
-# #     return param._raw["U_PbO2_ref"] + param._raw["R"] * param._raw[
-# #         "T_ref"
-# #     ] / param._raw["F"] * U_PbO2(c / param._raw["cmax"])
-# #
-# #
-# # def dUPbO2dc(param, c):
-# #     """Dimensionless derivative of U_PbO2 with respect to c"""
-# #     m_ = m(c * param._raw["cmax"])  # dimensionless
-# #     dUdm = (
-# #         param._raw["F"]
-# #         / (param._raw["R"] * param._raw["T_ref"])
-# #         * (
-# #             0.074 / m_ / np.log(10)
-# #             + 0.033 * 2 * np.log(m_) / (m_ * np.log(10) ** 2)
-# #             + 0.043 * 3 * np.log(m_) ** 2 / m_ / np.log(10) ** 3
-# #             + 0.022 * 4 * np.log(m_) ** 3 / m_ / np.log(10) ** 4
-# #         )
-# #     )
-# #     dmdc = dmdc(c * param._raw["cmax"]) * param._raw["cmax"]  # dimensionless
-# #     return dmdc * dUdm
diff --git a/input/parameters/lead-acid/electrolyte_diffusivity_Gu1997.py b/input/parameters/lead-acid/electrolyte_diffusivity_Gu1997.py
new file mode 100644
index 00000000..f6e3b45e
--- /dev/null
+++ b/input/parameters/lead-acid/electrolyte_diffusivity_Gu1997.py
@@ -0,0 +1,25 @@
+#
+# Electrolyte diffusivity
+#
+
+
+def electrolyte_diffusivity_Gu1997(c_e):
+    """
+    Dimensional Fickian diffusivity in the electrolyte [m2.s-1], from [1]_ citing [2]_
+    and agreeing with data in [3]_, as a function of the electrolyte concentration
+    c_e [mol.m-3].
+
+    References
+    ----------
+    .. [1] WB Gu, CY Wang, and BY Liaw. Numerical modeling of coupled electrochemical
+           and transport processes in lead-acid batteries. Journal of The
+           Electrochemical Society, 144(6):2053–2061, 1997.
+    .. [2] WH Tiedemann and J Newman. Battery design and optimization. Journal of
+           Electrochemical Society, Softbound Proceeding Series, Princeton, New York,
+           79(1):23, 1979.
+    .. [3] TW Chapman and J Newman. Compilation of selected thermodynamic and transport
+           properties of binary electrolytes in aqueous solution. Technical report,
+           California Univ., Berkeley. Lawrence Radiation Lab., 1968.
+
+    """
+    return (1.75 + 260e-6 * c_e) * 1e-9
diff --git a/input/parameters/lead-acid/electrolyte_viscosity_Chapman1968.py b/input/parameters/lead-acid/electrolyte_viscosity_Chapman1968.py
new file mode 100644
index 00000000..95094f4b
--- /dev/null
+++ b/input/parameters/lead-acid/electrolyte_viscosity_Chapman1968.py
@@ -0,0 +1,18 @@
+#
+# Electrolyte viscosity
+#
+
+
+def electrolyte_viscosity_Chapman1968(c_e):
+    """
+    Dimensional viscosity of electrolyte [kg.m-1.s-1], from data in [1]_, as a function
+    of the electrolyte concentration c_e [mol.m-3].
+
+    References
+    ----------
+    .. [1] TW Chapman and J Newman. Compilation of selected thermodynamic and transport
+           properties of binary electrolytes in aqueous solution. Technical report,
+           California Univ., Berkeley. Lawrence Radiation Lab., 1968.
+
+    """
+    return 0.89e-3 + 1.11e-7 * c_e + 3.29e-11 * c_e ** 2
diff --git a/input/parameters/lead-acid/lead_dioxide_electrode_ocv_Bode1977.py b/input/parameters/lead-acid/lead_dioxide_electrode_ocv_Bode1977.py
new file mode 100644
index 00000000..a4adabb3
--- /dev/null
+++ b/input/parameters/lead-acid/lead_dioxide_electrode_ocv_Bode1977.py
@@ -0,0 +1,24 @@
+#
+# Open-circuit voltage in the positive (lead-dioxide) electrode
+#
+import numpy as np
+
+
+def lead_dioxide_electrode_ocv_Bode1977(m):
+    """
+    Dimensional open-circuit voltage in the positive (lead-dioxide) electrode [V],
+    from [1]_, as a function of the molar mass m [mol.kg-1].
+
+    References
+    ----------
+    .. [1] H Bode. Lead-acid batteries. John Wiley and Sons, Inc., New York, NY, 1977.
+
+    """
+    U = (
+        1.628
+        + 0.074 * np.log10(m)
+        + 0.033 * np.log10(m) ** 2
+        + 0.043 * np.log10(m) ** 3
+        + 0.022 * np.log10(m) ** 4
+    )
+    return U
diff --git a/input/parameters/lead-acid/lead_electrode_ocv_Bode1977.py b/input/parameters/lead-acid/lead_electrode_ocv_Bode1977.py
new file mode 100644
index 00000000..14117c81
--- /dev/null
+++ b/input/parameters/lead-acid/lead_electrode_ocv_Bode1977.py
@@ -0,0 +1,24 @@
+#
+# Open-circuit voltage in the negative (lead) electrode
+#
+import numpy as np
+
+
+def lead_electrode_ocv_Bode1977(m):
+    """
+    Dimensional open-circuit voltage in the negative (lead) electrode [V], from [1]_,
+    as a function of the molar mass m [mol.kg-1].
+
+    References
+    ----------
+    .. [1] H Bode. Lead-acid batteries. John Wiley and Sons, Inc., New York, NY, 1977.
+
+    """
+    U = (
+        -0.294
+        - 0.074 * np.log10(m)
+        - 0.030 * np.log10(m) ** 2
+        - 0.031 * np.log10(m) ** 3
+        - 0.012 * np.log10(m) ** 4
+    )
+    return U
diff --git a/input/parameters/lithium-ion/experimental_functions/electrolyte_conductivity.py b/input/parameters/lithium-ion/experimental_functions/electrolyte_conductivity.py
index 40a418d3..205465a7 100644
--- a/input/parameters/lithium-ion/experimental_functions/electrolyte_conductivity.py
+++ b/input/parameters/lithium-ion/experimental_functions/electrolyte_conductivity.py
@@ -1,4 +1,4 @@
-def lfp_cond(c):
+def electrolyte_conducivity(c):
     """
     Conductivity of LiPF6 in EC:DMC as in Newman's Dualfoil code. This
     function is in dimensional form.
diff --git a/input/parameters/lithium-ion/experimental_functions/electrolyte_diffusivity.py b/input/parameters/lithium-ion/experimental_functions/electrolyte_diffusivity.py
index 61f7f4c5..4712173f 100644
--- a/input/parameters/lithium-ion/experimental_functions/electrolyte_diffusivity.py
+++ b/input/parameters/lithium-ion/experimental_functions/electrolyte_diffusivity.py
@@ -1,15 +1,15 @@
 import numpy as np
 
 
-def lfp_diff(c):
+def electrolyte_diffusivity(c):
     """
-           Diffusivity of LiPF6 in EC:DMC as in Newman's Dualfoil code. This
-           function is in dimensional form.
+    Diffusivity of LiPF6 in EC:DMC as in Newman's Dualfoil code. This
+    function is in dimensional form.
 
-           Parameters
-           ----------
-           c: double
-                lithium-ion concentration
+    Parameters
+    ----------
+    c: double
+        lithium-ion concentration
 
-           """
+    """
     return 5.34e-10 * np.exp(-0.65 * c / 1000)
diff --git a/input/parameters/lithium-ion/parameters/LCO.csv b/input/parameters/lithium-ion/parameters/LCO.csv
index 9d8b59c2..d7542199 100644
--- a/input/parameters/lithium-ion/parameters/LCO.csv
+++ b/input/parameters/lithium-ion/parameters/LCO.csv
@@ -1,55 +1,61 @@
-Name,Value,Units,Meaning,Reference,Notes
-# Empty rows and rows starting with ‘#’ will be ignored,,,,,
-,,,,,
-# Constants,,,,,
-R,8.314,J.K-1.mol-1,Ideal gas constant,-,
-F,96487,C.mol-1,Faraday’s constant,-,
-T_ref,298.15,K,Reference Temperature,25C,
-,,,,,
-# Geometric,,,,,
-Ln,0.0001,m,Half-width of negative electrode,Scott Moura,
-Ls,2.5E-05,m,Width of separator,Scott Moura,
-Lp,0.0001,m,Half-width of positive electrode,Scott Moura,
-H,0.137,m,Electrode height,KOKAM SLPB78205130H,Not needed for 1D
-W,0.207,m,Electrode depth,KOKAM SLPB78205130H,Not needed for 1D
-L_ccn,2.5E-05,m,Negative current collector thickness,Scott Moura,
-L_ccp,2.5E-05,m,Positive current collector thickness,Scott Moura,
-,,,,,
-# Electrical,,,,,
-voltage_low_cut,3.105,V,Lower voltage cut-off,-,
-voltage_high_cut,4.7,V,Upper voltage cut-off,-,
-I_typ,24,A/m^2,Typical current density,-,
-Phi_typ,1,V,Typical voltage drop across cell,-,
-,,,,,
-# Microstructure,,,,,
-epsilon_n,0.3,-,Electrolyte volume fraction in negative electrode region,Scott Moura,
-epsilon_s,1,-,Electrolyte volume fraction in separator region,Scott Moura,
-epsilon_p,0.3,,Electrolyte volume fraction in positive electrode region,Scott Moura,
-R_n,1E-05,m,Negative electrode particle radius,Scott Moura,
-R_p,1E-05,m,Positive electrode particle radius,Scott Moura,
-a_n,90000,m-1,Negative electrode surface area density, Scott Moura,
-a_p,90000,m-1,Positive electrode surface area density, Scott Moura,
-b,1.5,-,Bruggeman coefficient,Scott Moura,
-,,,,,
-# Electrolyte physical properties,,,,,
-ce_typ,1000,mol.m-3,Typical lithium ion concentration in electrolyte,,
-t_plus,0.4,-,Cation transference number,,
-De_typ,5.34E-10,m2/s,Typical lithium ion diffusivity,Scott Moura,
-,,,,,
-# Electrode physical properties,,,,,
-sigma_n,100,S.m-1,Conductivity of graphite,Scott Moura,
-sigma_p,10,S.m-1,Conductivity of Lithium Cobalt Oxide,Scott Moura,
-cn_max,24983.2619938437,mol.m-3,Maximum lithium concentration in negative electrode ,Scott Moura,
-cp_max,51217.9257309275,mol.m-3,Maximum lithium concentration in positive electrode ,Scott Moura,
-Dn_typ,3.9E-14,m2/s,Negative electrode diffusion coefficient,Scott Moura,
-Dp_typ,1E-13,m2/s,Positive electrode diffusion coefficient,Scott Moura,
-,,,,,
-# Interfacial reactions,,,,,
-m_n_dim,2E-05,Am-2(m3/mol)1.5,Reaction rate in negative electrode,Scott Moura,Be careful how we implement BV
-m_p_dim,6E-07,Am-2(m3/mol)1.5,Reaction rate in positive electrode,Scott Moura,Be careful how we implement BV
-alpha,0.5,,Charge transfer coefficient,Scott Moura,
-,,,,,
-# Initial Conditions,,,,,
-ce0,1000,mol.m-3, Initial lithium ion concentration in electrolyte,,
-cn0,1998.6,mol.m-3, Initial lithium concentration in positive electrode,,
-cp0,3073.1,mol.m-3, Initial lithium concentration in negative electrode,,
+Name,Value,Units,Reference,Notes
+# Empty rows and rows starting with ‘#’ will be ignored,,,,
+,,,,
+# Physical constants,,,,
+Ideal gas constant,8.314,J.K-1.mol-1,-,
+Faraday's constant,96487,C.mol-1,-,
+Reference temperature,298.15,K,25C,
+,,,,
+# Macroscale geometry,,,,
+Negative electrode width,0.0001,m,Scott Moura,
+Separator width,2.5E-05,m,Scott Moura,
+Positive electrode width,0.0001,m,Scott Moura,
+Electrode height,0.137,m,KOKAM SLPB78205130H,Not needed for 1D
+Electrode depth,0.207,m,KOKAM SLPB78205130H,Not needed for 1D
+Negative current collector thickness,2.5E-05,m,Scott Moura,
+Positive current collector thickness,2.5E-05,m,Scott Moura,
+,,,,
+# Electrical,,,,
+Number of electrodes connected in parallel to make a cell,1,-,Manufacturer,
+Lower voltage cut-off,3.105,V,-,
+Upper voltage cut-off,4.7,V,-,
+Typical current density,24,A/m^2,-,
+,,,,
+# Electrolyte properties,,,,
+Typical electrolyte concentration,1000,mol.m-3,,
+Cation transference number,0.4,-,,
+Typical lithium ion diffusivity,5.34E-10,m2/s,Scott Moura,
+,,,,
+# Electrode properties,,,,
+Conductivity of graphite,100,S.m-1,Scott Moura,
+Conductivity of Lithium Cobalt Oxide,10,S.m-1,Scott Moura,
+Maximum concentration in negative electrode,24983.2619938437,mol.m-3,Scott Moura,
+Maximum concentration in positive electrode,51217.9257309275,mol.m-3,Scott Moura,
+Negative electrode diffusion coefficient,3.9E-14,m2/s,Scott Moura,
+Positive electrode diffusion coefficient,1E-13,m2/s,Scott Moura,
+,,,,
+# Microstructure,,,,
+Negative electrode porosity,0.3,-,Scott Moura,
+Separator porosity,1,-,Scott Moura,
+Positive electrode porosity,0.3,,Scott Moura,
+Negative particle radius,1E-05,m,Scott Moura,
+Positive particle radius,1E-05,m,Scott Moura,
+Negative electrode surface area density,90000,m-1, Scott Moura,
+Positive electrode surface area density,90000,m-1, Scott Moura,
+Bruggeman coefficient,1.5,-,Scott Moura,
+,,,,
+# Interfacial reactions,,,,
+Negative electrode cation signed stoichiometry,-1,-,,
+Positive electrode cation signed stoichiometry,-1,-,,
+Negative electrode electrons in reaction,1,-,,
+Positive electrode electrons in reaction,1,-,,
+Negative electrode reference exchange-current density,2E-05,Am-2(m3/mol)1.5,Scott Moura,Be careful how we implement BV
+Positive electrode reference exchange-current density,6E-07,Am-2(m3/mol)1.5,Scott Moura,Be careful how we implement BV
+Reference OCP vs SHE in the negative electrode,0.02230,V,,
+Reference OCP vs SHE in the positive electrode,4.1212,V,,
+Charge transfer coefficient,0.5,,Scott Moura,
+,,,,
+# Initial Conditions,,,,
+Initial concentration in electrolyte,1000,mol.m-3,,
+Initial concentration in positive electrode,1998.6,mol.m-3,,
+Initial concentration in negative electrode,3073.1,mol.m-3,,
diff --git a/pybamm/__init__.py b/pybamm/__init__.py
index 06979c74..ef9af796 100644
--- a/pybamm/__init__.py
+++ b/pybamm/__init__.py
@@ -117,7 +117,9 @@ from .meshes.meshes import KNOWN_DOMAINS  # need this for importing standard par
 from .parameters.parameter_values import ParameterValues
 from .parameters import standard_current_functions
 from .parameters import standard_parameters
-from .parameters import standard_parameters_lead_acid  # calls standard_parameters
+
+# The following modules call standard_parameters
+from .parameters import standard_parameters_lithium_ion, standard_parameters_lead_acid
 
 #
 # Geometry
@@ -133,7 +135,6 @@ from .geometry.geometry import (
 # Mesh and Discretisation classes
 #
 from .discretisations.discretisation import Discretisation
-from .meshes.meshes import KNOWN_DOMAINS
 from .meshes.meshes import Mesh
 from .meshes.submeshes import SubMesh1D, Uniform1DSubMesh
 
diff --git a/pybamm/geometry/geometry.py b/pybamm/geometry/geometry.py
index 2179e760..ccf007bf 100644
--- a/pybamm/geometry/geometry.py
+++ b/pybamm/geometry/geometry.py
@@ -39,12 +39,12 @@ class Geometry1DMacro(Geometry):
         super().__init__()
         whole_cell = ["negative electrode", "separator", "positive electrode"]
         x = pybamm.SpatialVariable("x", whole_cell)
-        ln = pybamm.standard_parameters.ln
-        ls = pybamm.standard_parameters.ls
+        l_n = pybamm.standard_parameters.l_n
+        l_s = pybamm.standard_parameters.l_s
 
-        self["negative electrode"] = {x: {"min": pybamm.Scalar(0), "max": ln}}
-        self["separator"] = {x: {"min": ln, "max": ln + ls}}
-        self["positive electrode"] = {x: {"min": ln + ls, "max": pybamm.Scalar(1)}}
+        self["negative electrode"] = {x: {"min": pybamm.Scalar(0), "max": l_n}}
+        self["separator"] = {x: {"min": l_n, "max": l_n + l_s}}
+        self["positive electrode"] = {x: {"min": l_n + l_s, "max": pybamm.Scalar(1)}}
 
         # update with custom geometry if non empty
         self.update(custom_geometry)
@@ -54,14 +54,14 @@ class Geometry1DMicro(Geometry):
     def __init__(self, custom_geometry={}):
         super().__init__()
 
-        rn = pybamm.SpatialVariable("r", ["negative particle"])
-        rp = pybamm.SpatialVariable("r", ["positive particle"])
+        r_n = pybamm.SpatialVariable("r", ["negative particle"])
+        r_p = pybamm.SpatialVariable("r", ["positive particle"])
 
         self["negative particle"] = {
-            rn: {"min": pybamm.Scalar(0), "max": pybamm.Scalar(1)}
+            r_n: {"min": pybamm.Scalar(0), "max": pybamm.Scalar(1)}
         }
         self["positive particle"] = {
-            rp: {"min": pybamm.Scalar(0), "max": pybamm.Scalar(1)}
+            r_p: {"min": pybamm.Scalar(0), "max": pybamm.Scalar(1)}
         }
         # update with custom geometry if non empty
         self.update(custom_geometry)
@@ -85,9 +85,9 @@ class Geometry3DMacro(Geometry1DMacro):
         y = pybamm.SpatialVariable("y", whole_cell)
         z = pybamm.SpatialVariable("z", whole_cell)
 
-        y_lim = {"min": pybamm.Scalar(0), "max": pybamm.standard_parameters.ly}
+        y_lim = {"min": pybamm.Scalar(0), "max": pybamm.standard_parameters.l_y}
 
-        z_lim = {"min": pybamm.Scalar(0), "max": pybamm.Scalar(1)}
+        z_lim = {"min": pybamm.Scalar(0), "max": pybamm.standard_parameters.l_z}
 
         MACRO_DOMAINS = ["negative electrode", "separator", "positive electrode"]
         for domain in MACRO_DOMAINS:
diff --git a/pybamm/models/base_model.py b/pybamm/models/base_model.py
index e816c24a..79469c05 100644
--- a/pybamm/models/base_model.py
+++ b/pybamm/models/base_model.py
@@ -54,17 +54,26 @@ class BaseModel(object):
         self._concatenated_initial_conditions = None
 
         # Default parameter values, geometry, submesh, spatial methods and solver
+        input_path = os.path.join(
+            os.getcwd(), "input", "parameters", "lithium-ion", "experimental_functions"
+        )
         self.default_parameter_values = pybamm.ParameterValues(
             "input/parameters/lithium-ion/parameters/LCO.csv",
             {
-                "I_typ": 1,
-                "current function": os.path.join(
+                "Typical current density": 1,
+                "Current function": os.path.join(
                     os.getcwd(),
                     "pybamm",
                     "parameters",
                     "standard_current_functions",
                     "constant_current.py",
                 ),
+                "Electrolyte diffusivity": os.path.join(
+                    input_path, "electrolyte_diffusivity.py"
+                ),
+                "Electrolyte conductivity": os.path.join(
+                    input_path, "electrolyte_conducivity.py"
+                ),
             },
         )
         self.default_geometry = pybamm.Geometry("1D macro", "1D micro")
diff --git a/pybamm/models/lead_acid/loqs.py b/pybamm/models/lead_acid/loqs.py
index 6a259504..c9cbb05c 100644
--- a/pybamm/models/lead_acid/loqs.py
+++ b/pybamm/models/lead_acid/loqs.py
@@ -4,28 +4,14 @@
 from __future__ import absolute_import, division
 from __future__ import print_function, unicode_literals
 import pybamm
-
+import numpy as np
 import os
 
 
 class LOQS(pybamm.BaseModel):
     """Leading-Order Quasi-Static model for lead-acid.
 
-    Attributes
-    ----------
-
-    rhs: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the rhs
-    initial_conditions: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the initial conditions
-    boundary_conditions: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the boundary conditions
-    variables: dict
-        A dictionary that maps strings to expressions that represent
-        the useful variables
+    **Extends**: :class:`pybamm.BaseModel`
 
     """
 
@@ -34,82 +20,90 @@ class LOQS(pybamm.BaseModel):
 
         whole_cell = ["negative electrode", "separator", "positive electrode"]
         # Variables
-        c = pybamm.Variable("c", domain=[])
-        epsn = pybamm.Variable("epsn", domain=[])
-        epss = pybamm.Variable("epss", domain=[])
-        epsp = pybamm.Variable("epsp", domain=[])
+        c_e = pybamm.Variable("Concentration", domain=[])
+        eps_n = pybamm.Variable("Negative electrode porosity", domain=[])
+        eps_s = pybamm.Variable("Separator porosity", domain=[])
+        eps_p = pybamm.Variable("Positive electrode porosity", domain=[])
 
+        # Parameters
+        sp = pybamm.standard_parameters
+        spla = pybamm.standard_parameters_lead_acid
         # Current function
-        icell = pybamm.standard_parameters_lead_acid.current_with_time
-        # Parameters and functions
-        ln = pybamm.standard_parameters.ln
-        ls = pybamm.standard_parameters.ls
-        lp = pybamm.standard_parameters.lp
-        sn = pybamm.standard_parameters_lead_acid.sn
-        sp = pybamm.standard_parameters_lead_acid.sp
-        beta_surf_n = pybamm.standard_parameters_lead_acid.beta_surf_n
-        beta_surf_p = pybamm.standard_parameters_lead_acid.beta_surf_p
-        iota_ref_n = pybamm.standard_parameters_lead_acid.iota_ref_n
-        iota_ref_p = pybamm.standard_parameters_lead_acid.iota_ref_p
-        U_Pb = pybamm.standard_parameters_lead_acid.U_Pb_ref
-        U_PbO2 = pybamm.standard_parameters_lead_acid.U_PbO2_ref
-        # Initial conditions
-        c_init = pybamm.standard_parameters_lead_acid.c_init
-        epsn_init = pybamm.standard_parameters_lead_acid.epsn_init
-        epss_init = pybamm.standard_parameters_lead_acid.epss_init
-        epsp_init = pybamm.standard_parameters_lead_acid.epsp_init
+        i_cell = sp.current_with_time
 
         # ODEs
-        jn = icell / ln
-        jp = -icell / lp
-        depsndt = -beta_surf_n * jn
-        depspdt = -beta_surf_p * jp
-        dcdt = (
+        j_n = i_cell / sp.l_n
+        j_p = -i_cell / sp.l_p
+        deps_n_dt = -spla.beta_surf_n * j_n
+        deps_p_dt = -spla.beta_surf_p * j_p
+        dc_e_dt = (
             1
-            / (ln * epsn + ls * epss + lp * epsp)
-            * ((sn - sp) * icell - c * (ln * depsndt + lp * depspdt))
+            / (sp.l_n * eps_n + sp.l_s * eps_s + sp.l_p * eps_p)
+            * (
+                (sp.s_n - sp.s_p) * i_cell
+                - c_e * (sp.l_n * deps_n_dt + sp.l_p * deps_p_dt)
+            )
         )
-        self.rhs = {c: dcdt, epsn: depsndt, epss: pybamm.Scalar(0), epsp: depspdt}
+        self.rhs = {c_e: dc_e_dt, eps_n: deps_n_dt, eps_s: 0, eps_p: deps_p_dt}
         # Initial conditions
         self.initial_conditions = {
-            c: c_init,
-            epsn: epsn_init,
-            epss: epss_init,
-            epsp: epsp_init,
+            c_e: spla.c_e_init,
+            eps_n: spla.eps_n_init,
+            eps_s: spla.eps_s_init,
+            eps_p: spla.eps_p_init,
         }
         # ODE model -> no boundary conditions
         self.boundary_conditions = {}
 
         # Variables
-        Phi = -U_Pb - jn / (2 * iota_ref_n * c)
-        V = Phi + U_PbO2 - jp / (2 * iota_ref_p * c)
-        # Phisn = pybamm.Scalar(0)
-        # Phisp = V
+        j0_n = pybamm.interface.exchange_current_density(c_e, ["negative electrode"])
+        j0_p = pybamm.interface.exchange_current_density(c_e, ["positive electrode"])
+        Phi = -spla.U_n(c_e) - pybamm.Function(np.arcsinh, j_n / (2 * j0_n * sp.l_n))
+        V = Phi + spla.U_p(c_e) - pybamm.Function(np.arcsinh, j_p / (2 * j0_p * sp.l_p))
+        # Phis_n = pybamm.Scalar(0)
+        # Phis_p = V
         # Concatenate variables
-        # eps = pybamm.Concatenation(epsn, epss, epsp)
-        # Phis = pybamm.Concatenation(Phisn, pybamm.Scalar(0), Phisp)
+        # eps = pybamm.Concatenation(eps_n, eps_s, eps_p)
+        # Phis = pybamm.Concatenation(Phis_n, pybamm.Scalar(0), Phis_p)
         # self.variables = {"c": c, "eps": eps, "Phi": Phi, "Phis": Phis, "V": V}
         self.variables = {
-            "c": pybamm.Broadcast(c, whole_cell),
+            "c": pybamm.Broadcast(c_e, whole_cell),
             "Phi": pybamm.Broadcast(Phi, whole_cell),
             "V": V,
-            "int(epsilon_times_c)dx": (ln * epsn + ls * epss + lp * epsp) * c,
+            "int(epsilon_times_c)dx": (sp.l_n * eps_n + sp.l_s * eps_s + sp.l_p * eps_p)
+            * c_e,
         }
 
         # Terminate if concentration goes below zero
-        self.events = [c]
+        self.events = [c_e]
 
         # Overwrite default parameter values
+        input_path = os.path.join(os.getcwd(), "input", "parameters", "lead-acid")
         self.default_parameter_values = pybamm.ParameterValues(
             "input/parameters/lead-acid/default.csv",
             {
-                "current scale": 1,
-                "current function": os.path.join(
+                "Typical current density": 1,
+                "Current function": os.path.join(
                     os.getcwd(),
                     "pybamm",
                     "parameters",
                     "standard_current_functions",
                     "constant_current.py",
                 ),
+                "Electrolyte diffusivity": os.path.join(
+                    input_path, "electrolyte_diffusivity_Gu1997.py"
+                ),
+                "Electrolyte conductivity": os.path.join(
+                    input_path, "electrolyte_conductivity_Gu1997.py"
+                ),
+                "Darken thermodynamic factor": os.path.join(
+                    input_path, "darken_thermodynamic_factor_Chapman1968.py"
+                ),
+                "Negative electrode OCV": os.path.join(
+                    input_path, "lead_electrode_ocv_Bode1977.py"
+                ),
+                "Positive electrode OCV": os.path.join(
+                    input_path, "lead_dioxide_electrode_ocv_Bode1977.py"
+                ),
             },
         )
diff --git a/pybamm/models/li_ion/single_particle_model.py b/pybamm/models/li_ion/single_particle_model.py
index 268e9e91..a1ed9657 100644
--- a/pybamm/models/li_ion/single_particle_model.py
+++ b/pybamm/models/li_ion/single_particle_model.py
@@ -10,21 +10,7 @@ import numpy as np
 class SPM(pybamm.BaseModel):
     """Single Particle Model for li-ion.
 
-    Attributes
-    ----------
-
-    rhs: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the rhs
-    initial_conditions: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the initial conditions
-    boundary_conditions: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the boundary conditions
-    variables: dict
-        A dictionary that maps strings to expressions that represent
-        the useful variables
+    **Extends**: :class:`pybamm.BaseModel`
 
     """
 
@@ -32,69 +18,58 @@ class SPM(pybamm.BaseModel):
         super().__init__()
 
         # Variables
-        cn = pybamm.Variable("cn", domain="negative particle")
-        cp = pybamm.Variable("cp", domain="positive particle")
+        c_n = pybamm.Variable(
+            "Negative particle concentration", domain="negative particle"
+        )
+        c_p = pybamm.Variable(
+            "Positive particle concentration", domain="positive particle"
+        )
 
         # Parameters
-        ln = pybamm.standard_parameters.ln
-        lp = pybamm.standard_parameters.lp
-        gamma_n = pybamm.standard_parameters.gamma_n
-        gamma_p = pybamm.standard_parameters.gamma_p
-        beta_n = pybamm.standard_parameters.beta_n
-        beta_p = pybamm.standard_parameters.beta_p
-        C_hat_p = pybamm.standard_parameters.C_hat_p
-        m_n = pybamm.standard_parameters.m_n
-        m_p = pybamm.standard_parameters.m_p
-        D_n = pybamm.standard_parameters.D_n
-        D_p = pybamm.standard_parameters.D_p
-        U_n = pybamm.standard_parameters.U_n
-        U_p = pybamm.standard_parameters.U_p
-        Lambda = pybamm.standard_parameters.Lambda
-
-        # Initial conditions
-        cn_init = pybamm.standard_parameters.cn0
-        cp_init = pybamm.standard_parameters.cp0
+        sp = pybamm.standard_parameters
+        spli = pybamm.standard_parameters_lithium_ion
+        # Current function
+        i_cell = sp.current_with_time
 
         # PDE RHS
-        Nn = -gamma_n * D_n(cn) * pybamm.grad(cn)
-        dcndt = -pybamm.div(Nn)
-        Np = -gamma_p * D_p(cp) * pybamm.grad(cp)
-        dcpdt = -pybamm.div(Np)
-        self.rhs = {cn: dcndt, cp: dcpdt}
+        N_n = -spli.C_n * spli.D_n(c_n) * pybamm.grad(c_n)
+        dc_n_dt = -pybamm.div(N_n)
+        N_p = -spli.C_p * spli.D_p(c_p) * pybamm.grad(c_p)
+        dc_p_dt = -pybamm.div(N_p)
+        self.rhs = {c_n: dc_n_dt, c_p: dc_p_dt}
 
         # Boundary conditions
-        # Note: this is for constant current discharge only
         self.boundary_conditions = {
-            Nn: {"left": pybamm.Scalar(0), "right": pybamm.Scalar(1) / ln / beta_n},
-            Np: {
-                "left": pybamm.Scalar(0),
-                "right": -pybamm.Scalar(1) / lp / beta_p / C_hat_p,
+            N_n: {"left": 0, "right": i_cell / sp.l_n / spli.beta_n},
+            N_p: {
+                "left": 0,
+                "right": -i_cell / sp.l_p / spli.beta_p / spli.gamma_hat_p,
             },
         }
 
         # Initial conditions
-        self.initial_conditions = {cn: cn_init, cp: cp_init}
+        self.initial_conditions = {c_n: spli.c_n_init, c_p: spli.c_p_init}
 
         # Variables
-        cn_surf = pybamm.surf(cn)
-        cp_surf = pybamm.surf(cp)
-        gn = m_n * cn_surf ** 0.5 * (1 - cn_surf) ** 0.5
-        gp = m_p * C_hat_p * cp_surf ** 0.5 * (1 - cp_surf) ** 0.5
+        c_n_surf = pybamm.surf(c_n)
+        c_p_surf = pybamm.surf(c_p)
+        j0_n = sp.m_n * c_n_surf ** 0.5 * (1 - c_n_surf) ** 0.5
+        j0_p = sp.m_p * spli.gamma_hat_p * c_p_surf ** 0.5 * (1 - c_p_surf) ** 0.5
         # linearise BV for now
         V = (
-            U_p(cp_surf)
-            - U_n(cn_surf)
-            - (2 / Lambda) * (1 / (gp * lp))
-            - (2 / Lambda) * (1 / (gn * ln))
+            spli.U_p(c_p_surf)
+            - spli.U_n(c_n_surf)
+            - 2 * (i_cell / (j0_p * sp.l_p))
+            - 2 * (i_cell / (j0_n * sp.l_n))
         )
 
         self.variables = {
-            "cn": cn,
-            "cp": cp,
-            "cn_surf": cn_surf,
-            "cp_surf": cp_surf,
+            "cn": c_n,
+            "cp": c_p,
+            "cn_surf": c_n_surf,
+            "cp_surf": c_p_surf,
             "V": V,
         }
 
         # Cut-off if either concentration goes negative
-        self.events = [pybamm.Function(np.min, cn), pybamm.Function(np.min, cp)]
+        self.events = [pybamm.Function(np.min, c_n), pybamm.Function(np.min, c_p)]
diff --git a/pybamm/models/reaction_diffusion.py b/pybamm/models/reaction_diffusion.py
index 43ed1c28..cccdd005 100644
--- a/pybamm/models/reaction_diffusion.py
+++ b/pybamm/models/reaction_diffusion.py
@@ -9,21 +9,7 @@ import pybamm
 class ReactionDiffusionModel(pybamm.BaseModel):
     """Reaction-diffusion model.
 
-    Attributes
-    ----------
-
-    rhs: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the rhs
-    initial_conditions: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the initial conditions
-    boundary_conditions: dict
-        A dictionary that maps expressions (variables) to expressions that represent
-        the boundary conditions
-    variables: dict
-        A dictionary that maps strings to expressions that represent
-        the useful variables
+    **Extends**: :class:`pybamm.BaseModel`
 
     """
 
diff --git a/pybamm/models/submodels/electrolyte.py b/pybamm/models/submodels/electrolyte.py
index af16d682..7b85dd9e 100644
--- a/pybamm/models/submodels/electrolyte.py
+++ b/pybamm/models/submodels/electrolyte.py
@@ -12,8 +12,8 @@ class StefanMaxwellDiffusion(pybamm.BaseModel):
 
     Parameters
     ----------
-    G : :class:`pybamm.Symbol`
-        An expression tree that represents the concentration flux at the
+    j : :class:`pybamm.Symbol`
+        An expression tree that represents the interfacial current density at the
         electrode-electrolyte interface
 
     Attributes
@@ -35,25 +35,24 @@ class StefanMaxwellDiffusion(pybamm.BaseModel):
     *Extends:* :class:`BaseModel`
     """
 
-    def __init__(self, G):
+    def __init__(self, j):
         super().__init__()
 
-        epsilon = pybamm.standard_parameters.epsilon_s  # make issue for spatially
-        # dependent parameters
-        b = pybamm.standard_parameters.b
-        delta = pybamm.standard_parameters.delta
-        nu = pybamm.standard_parameters.nu
-        t_plus = pybamm.standard_parameters.t_plus
-        ce0 = pybamm.standard_parameters.ce0
+        # Parameters
+        sp = pybamm.standard_parameters
+        spli = pybamm.standard_parameters_lithium_ion
 
         electrolyte_domain = ["negative electrode", "separator", "positive electrode"]
 
         c_e = pybamm.Variable("c_e", electrolyte_domain)
 
-        N_e = -(epsilon ** b) * pybamm.grad(c_e)
+        N_e = -sp.D_e(c_e) * (spli.epsilon ** sp.b) * pybamm.grad(c_e)
 
-        self.rhs = {c_e: -pybamm.div(N_e) / delta / epsilon + nu * (1 - t_plus) * G}
-        self.initial_conditions = {c_e: ce0}
+        self.rhs = {
+            c_e: -pybamm.div(N_e) / spli.C_e / spli.epsilon
+            + sp.s / spli.gamma_hat_e * j
+        }
+        self.initial_conditions = {c_e: spli.c_e_init}
         self.boundary_conditions = {
             N_e: {"left": pybamm.Scalar(0), "right": pybamm.Scalar(0)}
         }
diff --git a/pybamm/models/submodels/interface.py b/pybamm/models/submodels/interface.py
index 75fac64d..3f3bbd22 100644
--- a/pybamm/models/submodels/interface.py
+++ b/pybamm/models/submodels/interface.py
@@ -4,6 +4,7 @@
 from __future__ import absolute_import, division
 from __future__ import print_function, unicode_literals
 import pybamm
+import numpy as np
 
 
 def homogeneous_reaction(current):
@@ -12,10 +13,10 @@ def homogeneous_reaction(current):
     """
     # hack to make the concatenation work. Concatenation needs some work
     current_neg = pybamm.Broadcast(
-        current / pybamm.standard_parameters.ln, ["negative electrode"]
+        current / pybamm.standard_parameters.l_n, ["negative electrode"]
     )
     current_pos = pybamm.Broadcast(
-        -current / pybamm.standard_parameters.lp, ["positive electrode"]
+        -current / pybamm.standard_parameters.l_p, ["positive electrode"]
     )
     return pybamm.Concatenation(
         current_neg, pybamm.Broadcast(0, ["separator"]), current_pos
@@ -65,20 +66,20 @@ def butler_volmer_lead_acid(c, phi, domain=None):
 
     # Get the current densities based on domain
     if domain == ["negative electrode"]:
-        j0n = exchange_current_density(c, ["negative electrode"])
-        etan = phi - pybamm.standard_parameters_lead_acid.U_Pb(c)
-        return j0n * etan  # Function(etan, np.sinh)
+        j0_n = exchange_current_density(c, ["negative electrode"])
+        eta_n = phi - pybamm.standard_parameters_lead_acid.U_n(c)
+        return j0_n * pybamm.Function(np.sinh, eta_n)
     elif domain == ["positive electrode"]:
-        j0p = exchange_current_density(c, ["positive electrode"])
-        etap = phi - pybamm.standard_parameters_lead_acid.U_PbO2(c)
-        return j0p * etap  # Function(etap, np.sinh)
+        j0_p = exchange_current_density(c, ["positive electrode"])
+        eta_p = phi - pybamm.standard_parameters_lead_acid.U_p(c)
+        return j0_p * pybamm.Function(np.sinh, eta_p)
     # To get current density across the whole domain, unpack and call this function
     # again in the subdomains, then concatenate
     elif domain == ["negative electrode", "separator", "positive electrode"]:
         # Unpack c
         if all([isinstance(var, pybamm.Concatenation) for var in [c, phi]]):
-            cn, cs, cp = c.orphans
-            phin, phis, phip = phi.orphans
+            c_n, c_s, c_p = c.orphans
+            phi_n, phi_s, phi_p = phi.orphans
         else:
             raise ValueError(
                 "c and phi must both be Concatenations, not '{}' and '{}'".format(
@@ -86,23 +87,23 @@ def butler_volmer_lead_acid(c, phi, domain=None):
                 )
             )
         # Negative electrode
-        current_neg = butler_volmer_lead_acid(cn, phin, domain=["negative electrode"])
+        current_neg = butler_volmer_lead_acid(c_n, phi_n, domain=["negative electrode"])
         # Separator
         current_sep = pybamm.Broadcast(0, ["separator"])
         # Positive electrode
-        current_pos = butler_volmer_lead_acid(cp, phip, domain=["positive electrode"])
+        current_pos = butler_volmer_lead_acid(c_p, phi_p, domain=["positive electrode"])
         # Concatenate
         return pybamm.Concatenation(current_neg, current_sep, current_pos)
     else:
         raise pybamm.DomainError("domain '{}' not recognised".format(domain))
 
 
-def exchange_current_density(c, domain=None):
+def exchange_current_density(c_e, domain=None):
     """The exchange current-density as a function of concentration
 
     Parameters
     ----------
-    c : :class:`pybamm.Variable`
+    c_e : :class:`pybamm.Variable`
         A Variable representing the concentration
     domain : string
         Which domain to calculate the exchange current density in ("negative electrode"
@@ -115,26 +116,20 @@ def exchange_current_density(c, domain=None):
     """
     if domain is None:
         # read domain from c if it exists
-        if c.domain != []:
-            domain = c.domain
+        if c_e.domain != []:
+            domain = c_e.domain
         # otherwise raise error
         else:
             raise ValueError("domain cannot be None if c.domain is empty")
+    # concentration domain should be empty or the same as domain
+    if c_e.domain not in [domain, []]:
+        raise pybamm.DomainError("""concentration and domain do not match""")
 
+    sp = pybamm.standard_parameters
     if domain == ["negative electrode"]:
-        # concentration domain should be empty or the same as domain
-        if c.domain not in [["negative electrode"], []]:
-            raise pybamm.DomainError("""concentration and domain do not match""")
-        iota_ref_n = pybamm.standard_parameters_lead_acid.iota_ref_n
-        return iota_ref_n * c
+        return sp.m_n * c_e
     elif domain == ["positive electrode"]:
-        # concentration domain should be empty or the same as domain
-        if c.domain not in [["positive electrode"], []]:
-            raise pybamm.DomainError("""concentration and domain do not match""")
-        iota_ref_p = pybamm.standard_parameters_lead_acid.iota_ref_p
-        Ve = pybamm.standard_parameters_lead_acid.Ve
-        Vw = pybamm.standard_parameters_lead_acid.Vw
-        cw = (1 - c * Ve) / Vw
-        return iota_ref_p * c ** 2 * cw
+        c_w = (1 - c_e * sp.V_e) / sp.V_w
+        return sp.m_p * c_e ** 2 * c_w
     else:
         raise pybamm.DomainError("domain '{}' not recognised".format(domain))
diff --git a/pybamm/parameters/standard_parameters.py b/pybamm/parameters/standard_parameters.py
index b335cb90..a083753f 100644
--- a/pybamm/parameters/standard_parameters.py
+++ b/pybamm/parameters/standard_parameters.py
@@ -16,11 +16,11 @@ T
 Macroscale Geometry
 -------------------
 
-Ln, Ls, Lp
+L_n, L_s, L_p
     The widths of the negative electrode, separator and positive electrode, respectively
 Lx
     The width of a single cell
-ln, ls, lp
+l_n, l_s, l_p
     The dimesionless widths of the negative electrode, separator and positive
     electrode respectively
 
@@ -44,7 +44,7 @@ sigma_n, sigma_p
     Electrical conductivities of the negative and positive electrode
 cn_max, cp_max
     Maximum lithium concentration in the negative and positive electrode
-Dn_typ, Dp_typ
+D_n_typ, Dp_typ
     Typical diffusivitites in the solid electrode material
 
 Electrochemical Reactions
@@ -75,164 +75,132 @@ import pybamm
 # --------------------------------------------------------------------------------------
 """Dimensional Parameters"""
 
-# Physical Constants
-R = pybamm.Parameter("R")
-F = pybamm.Parameter("F")
-T = pybamm.Parameter("T_ref")
+# Physical constants
+R = pybamm.Parameter("Ideal gas constant")
+F = pybamm.Parameter("Faraday's constant")
+T = pybamm.Parameter("Reference temperature")
 
-# Macroscale Geometry
-Ln = pybamm.Parameter("Ln")
-Ls = pybamm.Parameter("Ls")
-Lp = pybamm.Parameter("Lp")
-Lx = Ln + Ls + Lp
-
-# 3D Geometry
-Ly = pybamm.Parameter("Ly")
-Lz = pybamm.Parameter("Lz")
-
-# Microscale Geometry
-R_n = pybamm.Parameter("R_n")
-R_p = pybamm.Parameter("R_p")
-a_n = pybamm.Parameter("a_n")
-a_p = pybamm.Parameter("a_p")
-
-# Electrolyte Properties
-ce_typ = pybamm.Parameter("ce_typ")  # Typical lithium ion concentration in electrolyte
-De_typ = pybamm.Parameter("De_typ")  # Typical electrolyte diffusivity
-
-# Electrode Properties
-sigma_n = pybamm.Parameter("sigma_n")  # Conductivity in negative electrode
-sigma_p = pybamm.Parameter("sigma_p")  # Conductivity in positive electrode
-cn_max = pybamm.Parameter("cn_max")  # Max concentration in negative electrode
-cp_max = pybamm.Parameter("cp_max")  # Max concentration in positive electrode
-Dn_typ = pybamm.Parameter("Dn_typ")  # Typical negative particle diffusivity
-Dp_typ = pybamm.Parameter("Dp_typ")  # Typical positive particle diffusivity
-
-# Electrochemical Reactions
-m_n_dim = pybamm.Parameter("m_n_dim")  # Reaction rate in negative electrode
-m_p_dim = pybamm.Parameter("m_p_dim")  # Reaction rate in positive electrode
+# Macroscale geometry
+L_n = pybamm.Parameter("Negative electrode width")
+L_s = pybamm.Parameter("Separator width")
+L_p = pybamm.Parameter("Positive electrode width")
+L_x = L_n + L_s + L_p  # Total cell width
+L_y = pybamm.Parameter("Electrode depth")
+L_z = pybamm.Parameter("Electrode height")
+A_cc = L_y * L_z  # Area of current collector
 
 # Electrical
-voltage_low_cut = pybamm.Parameter("voltage_low_cut")  # Lower voltage cut-off
-voltage_high_cut = pybamm.Parameter("voltage_high_cut")  # Upper voltage cut-off
-I_typ = pybamm.Parameter("I_typ")  # Typical current density
-Phi_typ = pybamm.Parameter("Phi_typ")  # Typical voltage drop
-current_with_time = pybamm.FunctionParameter("current function", pybamm.t)
-dimensional_current_with_time = I_typ * current_with_time
-
-# Initial Conditions
-ce0_dimensional = pybamm.Parameter("ce0")  # Initial li ion concentration in electrolyte
-cn0_dimensional = pybamm.Parameter("cn0")  # Initial li concentration in neg electrode
-cp0_dimensional = pybamm.Parameter("cp0")  # Initial li concentration in pos electrode
-
-# --------------------------------------------------------------------------------------
-"""Dimensionless Parameters"""
-
-# Macroscale Geometry
-ln = Ln / Lx
-ls = Ls / Lx
-lp = Lp / Lx
-ly = Ly / Lz
-lz = Lz / Lz
-
-# Microscale Geometry
-epsilon_n = pybamm.Parameter(
-    "epsilon_n"
-)  # Electrolyte volume fraction in neg electrode
-epsilon_s = pybamm.Parameter("epsilon_s")  # Electrolyte volume fraction in separator
-epsilon_p = pybamm.Parameter(
-    "epsilon_p"
-)  # Electrolyte volume fraction in pos electrode
-b = pybamm.Parameter("b")  # Bruggeman coefficient
-beta_n = a_n * R_n
-beta_p = a_p * R_p
-
-# Discharge timescale
-tau_d = (F * cn_max * Lx) / I_typ
-
-# Particle diffusion timescales
-tau_n = R_n ** 2 / Dn_typ
-tau_p = R_n ** 2 / Dp_typ
-
-# Reaction timescales
-tau_r_n = F / (m_n_dim * a_n * ce_typ ** 0.5)
-tau_r_p = F / (m_p_dim * a_p * ce_typ ** 0.5)
-
-# Scaled maximum concentration in positive particle
-# Note: C_hat_n == 1, so not needed
-C_hat_p = cp_max / cn_max
-
-# Ratio of discharge and solid diffusion timescales
-gamma_n = tau_d / tau_n
-gamma_p = tau_d / tau_p
-
-# Reaction properties
-m_n = tau_d / tau_r_n
-m_p = tau_d / tau_r_n
-
-# Electrolyte Properties
-t_plus = pybamm.Parameter("t_plus")  # cation transference number
-delta = (Lx ** 2 / De_typ) * (I_typ / (F * cn_max * Lx))
-nu = cn_max / ce_typ
-
-# Ratio of typical to thermal voltage
-Lambda = Phi_typ / (R * T / F)
-
-# Initial conditions
-ce0 = ce0_dimensional / ce_typ
-cn0 = cn0_dimensional / cn_max
-cp0 = cp0_dimensional / cp_max
+I_typ = pybamm.Parameter("Typical current density")
+Q = pybamm.Parameter("Cell capacity")
+C_rate = I_typ / Q
+n_electrodes_parallel = pybamm.Parameter(
+    "Number of electrodes connected in parallel to make a cell"
+)
+i_typ = I_typ / (n_electrodes_parallel * A_cc)
+voltage_low_cut_dimensional = pybamm.Parameter("Lower voltage cut-off")
+voltage_high_cut_dimensional = pybamm.Parameter("Upper voltage cut-off")
+current_with_time = pybamm.FunctionParameter("Current function", pybamm.t)
+dimensional_current_with_time = i_typ * current_with_time
+
+# Electrolyte properties
+c_e_typ = pybamm.Parameter("Typical electrolyte concentration")
+t_plus = pybamm.Parameter("Cation transference number")
+V_w = pybamm.Parameter("Partial molar volume of water")
+V_plus = pybamm.Parameter("Partial molar volume of cations")
+V_minus = pybamm.Parameter("Partial molar volume of anions")
+V_e = V_minus + V_plus  # Partial molar volume of electrolyte [m3.mol-1]
+nu_plus = pybamm.Parameter("Cation stoichiometry")
+nu_minus = pybamm.Parameter("Anion stoichiometry")
+nu = nu_plus + nu_minus
+
+# Electrode properties
+sigma_n_dimensional = pybamm.Parameter("Negative electrode conductivity")
+sigma_p_dimensional = pybamm.Parameter("Positive electrode conductivity")
+
+# Microstructure
+a_n = pybamm.Parameter("Negative electrode surface area density")
+a_p = pybamm.Parameter("Positive electrode surface area density")
+b = pybamm.Parameter("Bruggeman coefficient")
+
+# Electrochemical reactions
+m_n_dimensional = pybamm.Parameter(
+    "Negative electrode reference exchange-current density"
+)
+m_p_dimensional = pybamm.Parameter(
+    "Positive electrode reference exchange-current density"
+)
+s_plus_n = pybamm.Parameter("Negative electrode cation signed stoichiometry")
+s_plus_p = pybamm.Parameter("Positive electrode cation signed stoichiometry")
+ne_n = pybamm.Parameter("Negative electrode electrons in reaction")
+ne_p = pybamm.Parameter("Positive electrode electrons in reaction")
+C_dl_dimensional = pybamm.Parameter("Double-layer capacity")
 
 # -----------------------------------------------------------------------------
 """Functions"""
 
 
-def D_n_dim(c):
-    "Dimensional diffusivity in negative particle"
-    return Dn_typ
+def D_e_dimensional(c_e):
+    "Dimensional diffusivity in electrolyte"
+    return pybamm.FunctionParameter("Electrolyte diffusivity", c_e)
 
 
-def D_n(c):
-    "Dimensionless negative particle diffusivity"
-    return D_n_dim(c) / Dn_typ
+def D_e(c_e):
+    "Dimensionless electrolyte diffusivity"
+    c_e_dimensional = c_e * c_e_typ
+    return D_e_dimensional(c_e_dimensional) / D_e_dimensional(c_e_typ)
 
 
-def D_p_dim(c):
-    "Dimensional diffusivity in positive particle"
-    return Dp_typ
+def kappa_e_dimensional(c_e):
+    "Dimensional electrolyte conductivity"
+    return pybamm.FunctionParameter("Electrolyte conductivity", c_e)
 
 
-def D_p(c):
-    "Dimensionless positive particle diffusivity"
-    return D_p_dim(c) / Dp_typ
+def kappa_e(c_e):
+    "Dimensionless electrolyte conductivity"
+    c_e_dimensional = c_e * c_e_typ
+    kappa_scale = F ** 2 * D_e_dimensional(c_e_typ) * c_e_typ / (R * T)
+    return kappa_e_dimensional(c_e_dimensional) / kappa_scale
 
 
-def U_n(c):
-    "Dimensionless open circuit potential in the negative electrode"
-    #  out = (0.194 + 1.5 * np.exp(-120.0 * c)
-    #       + 0.0351 * np.tanh((c - 0.286) / 0.083)
-    #       - 0.0045 * np.tanh((c - 0.849) / 0.119)
-    #       - 0.035 * np.tanh((c - 0.9233) / 0.05)
-    #       - 0.0147 * np.tanh((c - 0.5) / 0.034)
-    #       - 0.102 * np.tanh((c - 0.194) / 0.142)
-    #       - 0.022 * np.tanh((c - 0.9) / 0.0164)
-    #       - 0.011 * np.tanh((c - 0.124) / 0.0226)
-    #       + 0.0155 * np.tanh((c - 0.105) / 0.029))
-    # Set constant until functions implemented correctly
-    out = 0.2230
-    return out / Phi_typ
+# --------------------------------------------------------------------------------------
+"""Scales"""
+concentration_scale = c_e_typ
+length_scale = L_x
+potential_scale = R * T / F
+current_scale = i_typ
+interfacial_current_scale_n = i_typ / (a_n * L_x)
+interfacial_current_scale_p = i_typ / (a_p * L_x)
+
+# Timescales
+# Reaction timescales
+tau_rxn_n = 1 / (m_n_dimensional * a_n * c_e_typ ** 0.5)
+tau_rxn_p = 1 / (m_p_dimensional * a_p * c_e_typ ** 0.5)
+# Diffusion timescale
+tau_diffusion_e = L_x ** 2 / D_e_dimensional(c_e_typ)
 
+# --------------------------------------------------------------------------------------
+"""Dimensionless Parameters"""
+
+# Macroscale Geometry
+l_n = L_n / length_scale
+l_s = L_s / length_scale
+l_p = L_p / length_scale
+l_y = L_y / L_z
+l_z = L_z / L_z
 
-def U_p(c):
-    "Dimensionless open circuit potential in the positive electrode"
-    # stretch = 1.062
-    # sto = stretch * c
-    # out = (2.16216 + 0.07645 * np.tanh(30.834 - 54.4806 * sto)
-    #       + 2.1581 * np.tanh(52.294 - 50.294 * sto)
-    #       - 0.14169 * np.tanh(11.0923 - 19.8543 * sto)
-    #       + 0.2051 * np.tanh(1.4684 - 5.4888 * sto)
-    #       + 0.2531 * np.tanh((-sto + 0.56478) / 0.1316)
-    #       - 0.02167 * np.tanh((sto - 0.525) / 0.006))
-    # Set constant until functions implemented correctly
-    out = 4.1212
-    return out / Phi_typ
+# Electrochemical Reactions
+s_n = -(s_plus_n + ne_n * t_plus) / ne_n  # Dimensionless rection rate (neg)
+s_p = -(s_plus_p + ne_p * t_plus) / ne_p  # Dimensionless rection rate (pos)
+s = pybamm.Concatenation(
+    pybamm.Broadcast(s_n, ["negative electrode"]),
+    pybamm.Broadcast(0, ["separator"]),
+    pybamm.Broadcast(s_p, ["positive electrode"]),
+)
+m_n = m_n_dimensional / interfacial_current_scale_n
+m_p = m_p_dimensional / interfacial_current_scale_p
+# m_n = time_scale / tau_rxn_n
+# m_p = time_scale / tau_rxn_n
+
+# Electrode Properties
+sigma_n = sigma_n_dimensional * potential_scale / current_scale
+sigma_p = sigma_p_dimensional * potential_scale / current_scale
diff --git a/pybamm/parameters/standard_parameters_lead_acid.py b/pybamm/parameters/standard_parameters_lead_acid.py
index f91b1a81..e37d5faf 100644
--- a/pybamm/parameters/standard_parameters_lead_acid.py
+++ b/pybamm/parameters/standard_parameters_lead_acid.py
@@ -22,206 +22,171 @@ from __future__ import absolute_import, division
 from __future__ import print_function, unicode_literals
 import pybamm
 
+sp = pybamm.standard_parameters
+
 # --------------------------------------------------------------------------------------
 """Dimensional Parameters"""
 
-# Current collectors / Electrical properties
-H = pybamm.Parameter("H")
-W = pybamm.Parameter("W")
-A_cs = H * W  # Area of the current collectors [m2]
-Ibar = pybamm.Parameter("current scale")
-n_electrodes_parallel = pybamm.Parameter("number of electrodes in parallel")
-ibar = Ibar / (n_electrodes_parallel * A_cs)  # Specified scale for the current [A.m-2]
-Q = 17  # Capacity [Ah]
-Crate = Ibar / Q  # C-rate [-]
-current_with_time = pybamm.FunctionParameter("current function", pybamm.t)
-dimensional_current_with_time = ibar * current_with_time
-
-
-# Microstructure
-An = pybamm.Parameter(
-    "Anmax"
-)  # Negative electrode surface area density [m-1] (or 1e4 or 1e6?)
-Ap = pybamm.Parameter("Apmax")  # Positive electrode surface area density [m-1]
-epsn_max = pybamm.Parameter("epsn_max")  # Max porosity of negative electrode [-]
-epss_max = pybamm.Parameter("epss_max")  # Max porosity of separator [-]
-epsp_max = pybamm.Parameter("epsp_max")  # Max porosity of positive electrode [-]
-
-# Reactions
-s_plus_n = pybamm.Parameter("s_plus_n")
-s_plus_p = pybamm.Parameter("s_plus_p")
-ne_n = pybamm.Parameter("ne_n")
-ne_p = pybamm.Parameter("ne_p")
-
-# Electrolyte physical properties
-cmax = pybamm.Parameter("cmax")  # Maximum electrolye concentration [mol.m-3]
-Vw = pybamm.Parameter("Vw")  # Partial molar volume of water [m3.mol-1]
-V_plus = pybamm.Parameter("V_plus")  # Partial molar volume of cations [m3.mol-1]
-V_minus = pybamm.Parameter("V_minus")  # Partial molar volume of anions [m3.mol-1]
-Ve = V_minus + V_plus  # Partial molar volume of electrolyte [m3.mol-1]
-Mw = pybamm.Parameter("Mw")  # Molar mass of water [kg.mol-1]
-Mp = pybamm.Parameter("Mp")  # Molar mass of cations [kg.mol-1]
-Mn = pybamm.Parameter("Mn")  # Molar mass of anions [kg.mol-1]
-Me = Mn + Mp  # Molar mass of electrolyte [kg.mol-1]
+# Electrolyte properties
+M_w = pybamm.Parameter("Molar mass of water")
+M_p = pybamm.Parameter("Molar mass of cations")
+M_n = pybamm.Parameter("Molar mass of anions")
+M_e = M_n + M_p  # Molar mass of electrolyte [kg.mol-1]
 DeltaVliq_n = (
-    V_minus - V_plus
+    sp.V_minus - sp.V_plus
 )  # Net Molar Volume consumed in electrolyte (neg) [m3.mol-1]
 DeltaVliq_p = (
-    2 * Vw - V_minus - 3 * V_plus
+    2 * sp.V_w - sp.V_minus - 3 * sp.V_plus
 )  # Net Molar Volume consumed in electrolyte (neg) [m3.mol-1]
-nu_plus = pybamm.Parameter("nu_plus")
-nu_minus = pybamm.Parameter("nu_minus")
-nu = nu_plus + nu_minus
-
-# Electrode physical properties
-VPb = pybamm.Parameter("VPb")  # Molar volume of lead [m3.mol-1]
-VPbO2 = pybamm.Parameter("VPbO2")  # Molar volume of lead dioxide [m3.mol-1]
-VPbSO4 = pybamm.Parameter("VPbSO4")  # Molar volume of lead sulfate [m3.mol-1]
-DeltaVsurf_n = VPb - VPbSO4  # Net Molar Volume consumed in neg electrode [m3.mol-1]
-DeltaVsurf_p = VPbSO4 - VPbO2  # Net Molar Volume consumed in pos electrode [m3.mol-1]
-sigma_eff_n = (
-    pybamm.standard_parameters.sigma_n * (1 - epsn_max) ** 1.5
-)  # Effective lead conductivity [S/m-1]
-sigma_eff_p = (
-    pybamm.standard_parameters.sigma_p * (1 - epsp_max) ** 1.5
-)  # Effective lead dioxide conductivity [S/m-1]
-d = pybamm.Parameter("d")  # Pore size [m]
-
-# Butler-Volmer
-jref_n = pybamm.Parameter("jref_n")  # Reference exchange-current density (neg) [A.m-2]
-jref_p = pybamm.Parameter("jref_p")  # Reference exchange-current density (pos) [A.m-2]
-Cdl = pybamm.Parameter("Cdl")  # Double-layer capacity [F.m-2]
-U_Pb_ref = pybamm.Parameter("U_Pb_ref")  # Reference OCP in the lead [V]
-U_PbO2_ref = pybamm.Parameter("U_PbO2_ref")  # Reference OCP in the lead dioxide [V]
 
-# --------------------------------------------------------------------------------------
-"""Scales"""
-Lx = pybamm.standard_parameters.Lx
-F = pybamm.standard_parameters.F
-R = pybamm.standard_parameters.R
-T = pybamm.standard_parameters.T
-
-concentration_scale = cmax
-length_scale = Lx
-time_scale = cmax * F * Lx / ibar  # discharge time scale
-potential_scale = R * T / F
-current_scale = ibar
-interfacial_current_scale_neg = ibar / (An * Lx)
-interfacial_current_scale_pos = ibar / (Ap * Lx)
-velocity_scale = ibar / (cmax * F)  # Reaction velocity scale
+# Electrode properties
+sp.V_Pb = pybamm.Parameter("Molar volume of lead")
+sp.V_PbO2 = pybamm.Parameter("Molar volume of lead-dioxide")
+sp.V_PbSO4 = pybamm.Parameter("Molar volume of lead sulfate")
+DeltaVsurf_n = (
+    sp.V_Pb - sp.V_PbSO4
+)  # Net Molar Volume consumed in neg electrode [m3.mol-1]
+DeltaVsurf_p = (
+    sp.V_PbSO4 - sp.V_PbO2
+)  # Net Molar Volume consumed in pos electrode [m3.mol-1]
+d = pybamm.Parameter("Pore size")
+eps_n_max = pybamm.Parameter("Maximum porosity of negative electrode")
+eps_s_max = pybamm.Parameter("Maximum porosity of separator")
+eps_p_max = pybamm.Parameter("Maximum porosity of positive electrode")
 
 # --------------------------------------------------------------------------------------
 """Functions"""
 
-rho_dim = pybamm.Parameter("epsn_max")
-mu_dim = pybamm.Parameter("epsn_max")
+
+def chi_dimensional(c_e):
+    return pybamm.FunctionParameter("Darken thermodynamic factor", c_e)
+
+
+def chi(c_e):
+    c_e_dimensional = c_e * sp.c_e_typ
+    alpha = (sp.nu * sp.V_w - sp.V_e) * sp.c_e_typ
+    return chi_dimensional(c_e_dimensional) * 2 * (1 - sp.t_plus) / (1 - alpha * c_e)
+
+
+def rho_dimensional(c_e):
+    """
+    Dimensional density of electrolyte [kg.m-3], from thermodynamics. c_e in [mol.m-3].
+
+    """
+    return M_w / sp.V_w * (1 + (M_e * sp.V_w / M_w - sp.V_e) * c_e)
+
+
+def m_dimensional(c_e):
+    """
+    Dimensional electrolyte molar mass [mol.kg-1], from thermodynamics.
+    c_e in [mol.m-3].
+
+    """
+    return c_e * sp.V_w / ((1 - c_e * sp.V_e) * M_w)
+
+
+def mu_dimensional(c_e):
+    """
+    Dimensional viscosity of electrolyte [kg.m-1.s-1].
+
+    """
+    return pybamm.FunctionParameter("Electrolyte viscosity", c_e)
 
 
-def D_dim(c):
-    "Dimensional electrolyte diffusivity"
-    return 1  # pybamm.FunctionParameter("electrolyte_diffusivity", c)
+def U_n_dimensional(c_e):
+    "Dimensional open-circuit voltage in the negative electrode [V]"
+    return pybamm.FunctionParameter("Negative electrode OCV", m_dimensional(c_e))
 
 
-def D(c):
-    "Dimensionless electrolyte diffusivity"
-    return D_dim(c * concentration_scale) / D_dim(concentration_scale)
+U_n_ref = pybamm.FunctionParameter("Negative electrode OCV", pybamm.Scalar(1))
 
 
-def U_Pb(c):
-    "Dimensional open-circuit potential for lead electrode"
-    return U_Pb_ref
+def U_p_dimensional(c_e):
+    "Dimensional open-circuit voltage in the positive electrode [V]"
+    return pybamm.FunctionParameter("Positive electrode OCV", m_dimensional(c_e))
 
 
-def U_PbO2(c):
-    "Dimensionless open-circuit potential for lead-dioxide electrode"
-    return U_PbO2_ref
+U_p_ref = pybamm.FunctionParameter("Positive electrode OCV", pybamm.Scalar(1))
 
 
+def U_n(c_en):
+    "Dimensionless open-circuit voltage in the negative electrode"
+    c_en_dimensional = c_en * sp.c_e_typ
+    return (U_n_dimensional(c_en_dimensional) - U_n_ref) / sp.potential_scale
+
+
+def U_p(c_ep):
+    "Dimensionless open-circuit voltage in the positive electrode"
+    c_ep_dimensional = c_ep * sp.c_e_typ
+    return (U_p_dimensional(c_ep_dimensional) - U_p_ref) / sp.potential_scale
+
+
+# --------------------------------------------------------------------------------------
+"""Scales"""
+
+tau_discharge = sp.F * sp.c_e_typ * sp.L_x / sp.i_typ
+velocity_scale = sp.i_typ / (sp.c_e_typ * sp.F)  # Reaction velocity scale
+
 # --------------------------------------------------------------------------------------
 """Dimensionless Parameters"""
 
-Cd = (
-    (Lx ** 2) / D_dim(cmax) / time_scale
-)  # Diffusional C-rate: diffusion timescale/discharge timescale
-alpha = (nu * Vw - Ve) * cmax  # Excluded volume fraction
-sn = (
-    -(s_plus_n + ne_n * pybamm.standard_parameters.t_plus) / ne_n
-)  # Dimensionless rection rate (neg)
-sp = (
-    -(s_plus_p + ne_p * pybamm.standard_parameters.t_plus) / ne_p
-)  # Dimensionless rection rate (pos)
-iota_s_n = (
-    sigma_eff_n * potential_scale / current_scale
-)  # Dimensionless lead conductivity
-iota_s_p = (
-    sigma_eff_p * potential_scale / current_scale
-)  # Dimensionless lead dioxide conductivity
-iota_ref_n = (
-    jref_n / interfacial_current_scale_neg
-)  # Dimensionless exchange-current density (neg)
-iota_ref_p = (
-    jref_p / interfacial_current_scale_pos
-)  # Dimensionless exchange-current density (pos)
-beta_surf_n = -cmax * DeltaVsurf_n / ne_n  # Molar volume change (lead)
-beta_surf_p = -cmax * DeltaVsurf_p / ne_p  # Molar volume change (lead dioxide)
-beta_liq_n = -cmax * DeltaVliq_n / ne_n  # Molar volume change (electrolyte, neg)
-beta_liq_p = -cmax * DeltaVliq_p / ne_p  # Molar volume change (electrolyte, pos)
+# Electrolyte properties
+beta_surf_n = -sp.c_e_typ * DeltaVsurf_n / sp.ne_n  # Molar volume change (lead)
+beta_surf_p = -sp.c_e_typ * DeltaVsurf_p / sp.ne_p  # Molar volume change (lead dioxide)
+beta_liq_n = (
+    -sp.c_e_typ * DeltaVliq_n / sp.ne_n
+)  # Molar volume change (electrolyte, neg)
+beta_liq_p = (
+    -sp.c_e_typ * DeltaVliq_p / sp.ne_p
+)  # Molar volume change (electrolyte, pos)
 beta_n = beta_surf_n + beta_liq_n  # Total molar volume change (neg)
 beta_p = beta_surf_p + beta_liq_p  # Total molar volume change (pos)
 omega_i = (
-    cmax * Me / rho_dim * (1 - Mw * Ve / Vw * Me)
+    sp.c_e_typ * M_e / rho_dimensional(sp.c_e_typ) * (1 - M_w * sp.V_e / sp.V_w * M_e)
 )  # Diffusive kinematic relationship coefficient
 omega_c = (
-    cmax * Me / rho_dim * (pybamm.standard_parameters.t_plus + Mn / Me)
+    sp.c_e_typ * M_e / rho_dimensional(sp.c_e_typ) * (sp.t_plus + M_n / M_e)
 )  # Migrative kinematic relationship coefficient
-gamma_dl_n = (
-    Cdl * potential_scale / interfacial_current_scale_neg / time_scale
-)  # Dimensionless double-layer capacity (neg)
-gamma_dl_p = (
-    Cdl * potential_scale / interfacial_current_scale_pos / time_scale
-)  # Dimensionless double-layer capacity (pos)
-voltage_cutoff = (
-    1
-    / potential_scale
-    * (pybamm.standard_parameters.voltage_low_cut - (U_PbO2_ref - U_Pb_ref))
-)  # Dimensionless voltage cut-off
+C_e = sp.tau_diffusion_e / tau_discharge
 pi_os = (
-    mu_dim * velocity_scale * Lx / (d ** 2 * R * T * cmax)
+    mu_dimensional(sp.c_e_typ)
+    * velocity_scale
+    * sp.L_x
+    / (d ** 2 * sp.R * sp.T * sp.c_e_typ)
 )  # Ratio of viscous pressure scale to osmotic pressure scale
 
+# Electrochemical reactions
+C_dl_n = (
+    sp.C_dl_dimensional
+    * sp.potential_scale
+    / sp.interfacial_current_scale_n
+    / tau_discharge
+)
+C_dl_p = (
+    sp.C_dl_dimensional
+    * sp.potential_scale
+    / sp.interfacial_current_scale_p
+    / tau_discharge
+)
+
+# Electrical
+voltage_low_cut = (
+    sp.voltage_low_cut_dimensional - (U_p_ref - U_n_ref)
+) / sp.potential_scale
+voltage_high_cut = (
+    sp.voltage_high_cut_dimensional - (U_p_ref - U_n_ref)
+) / sp.potential_scale
 
 # Initial conditions
-q_init = pybamm.Parameter("q_init")  # Initial SOC [-]
-qmax = (
-    (
-        pybamm.standard_parameters.Ln * epsn_max
-        + pybamm.standard_parameters.Ls * epss_max
-        + pybamm.standard_parameters.Lp * epsp_max
-    )
-    / Lx
-    / (sp - sn)
+q_init = pybamm.Parameter("Initial State of Charge")
+q_max = (
+    (sp.L_n * eps_n_max + sp.L_s * eps_s_max + sp.L_p * eps_p_max)
+    / sp.L_x
+    / (sp.s_p - sp.s_n)
 )  # Dimensionless max capacity
-epsDelta_n = beta_surf_n / pybamm.standard_parameters.Ln * qmax
-epsDelta_p = beta_surf_p / pybamm.standard_parameters.Lp * qmax
-c_init = q_init
-epsn_init = epsn_max - epsDelta_n * (1 - q_init)  # Initial pororsity (neg) [-]
-epss_init = epss_max  # Initial pororsity (sep) [-]
-epsp_init = epsp_max - epsDelta_p * (1 - q_init)  # Initial pororsity (pos) [-]
-
-
-# Concatenated symbols
-s = pybamm.Concatenation(
-    pybamm.Broadcast(sn, ["negative electrode"]),
-    pybamm.Broadcast(0, ["separator"]),
-    pybamm.Broadcast(sp, ["positive electrode"]),
-)
-beta_surf = pybamm.Concatenation(
-    pybamm.Broadcast(beta_surf_n, ["negative electrode"]),
-    pybamm.Broadcast(0, ["separator"]),
-    pybamm.Broadcast(beta_surf_p, ["positive electrode"]),
-)
-eps_init = pybamm.Concatenation(
-    pybamm.Broadcast(epsn_init, ["negative electrode"]),
-    pybamm.Broadcast(epss_init, ["separator"]),
-    pybamm.Broadcast(epsp_init, ["positive electrode"]),
-)
+epsDelta_n = beta_surf_n / sp.L_n * q_max
+epsDelta_p = beta_surf_p / sp.L_p * q_max
+c_e_init = q_init
+eps_n_init = eps_n_max - epsDelta_n * (1 - q_init)  # Initial pororsity (neg) [-]
+eps_s_init = eps_s_max  # Initial pororsity (sep) [-]
+eps_p_init = eps_p_max - epsDelta_p * (1 - q_init)  # Initial pororsity (pos) [-]
diff --git a/pybamm/parameters/standard_parameters_lithium_ion.py b/pybamm/parameters/standard_parameters_lithium_ion.py
new file mode 100644
index 00000000..7f9a0047
--- /dev/null
+++ b/pybamm/parameters/standard_parameters_lithium_ion.py
@@ -0,0 +1,234 @@
+#
+# Standard parameters for battery models
+#
+"""
+Standard pybamm.Parameters for battery models
+
+Physical Constants
+------------------
+R
+    Ideal gas constant
+sp.F
+    Faraday's constant
+T
+    Reference temperature
+
+Macroscale Geometry
+-------------------
+
+L_n, L_s, L_p
+    The widths of the negative electrode, separator and positive electrode, respectively
+L_x
+    The width of a single cell
+l_n, l_s, l_p
+    The dimesionless widths of the negative electrode, separator and positive
+    electrode respectively
+
+Microscale Geometry
+-------------------
+R_n, R_p
+    Negative and positive particle radii
+sp.a_n, sp.a_p
+    Negative and positive electrode surface area densities
+
+Electrolyte Properties
+----------------------
+ce_typ
+    Typical lithium ion concentration in electrolyte
+De_typ
+    Typical lithium ion diffusivity in the electrolyte
+
+Electrode Properties
+--------------------
+sigma_n, sigma_p
+    Electrical conductivities of the negative and positive electrode
+cn_max, cp_max
+    Maximum lithium concentration in the negative and positive electrode
+D_n_typ, Dp_typ
+    Typical diffusivitites in the solid electrode material
+
+Electrochemical Reactions
+--------------------------
+m_n, m_p
+    Reaction rates in negative and positive electrode regions
+
+Electrical
+----------
+voltage_low_cut, voltage_high_cut
+    Low and high voltage cut-offs
+I_typ
+    Typical current density
+Phi_typ
+    Typical voltage drop across the cell
+
+Initial Conditions
+-------------------
+ce0_dimensional
+    Initial lithium ion concentration in the electrolyte
+cn0_dimensional, cp0_dimensional
+    Initial lithium concentration in the negative and positive electrodes
+"""
+from __future__ import absolute_import, division
+from __future__ import print_function, unicode_literals
+import pybamm
+
+sp = pybamm.standard_parameters
+
+# --------------------------------------------------------------------------------------
+"""Dimensional Parameters"""
+
+# Microscale geometry
+R_n = pybamm.Parameter("Negative particle radius")
+R_p = pybamm.Parameter("Positive particle radius")
+
+# Electrolyte properties
+# QUESTION: should this be (1-2*t_plus) or 2*(1-t_plus)? See
+# Bizeray et al (2016) "Resolving a discrepancy ..."
+chi = 1 - 2 * sp.t_plus
+
+# Electrode properties
+c_n_max = pybamm.Parameter("Maximum concentration in negative electrode")
+c_p_max = pybamm.Parameter("Maximum concentration in positive electrode")
+
+# Initial conditions
+c_e_init_dimensional = pybamm.Parameter("Initial concentration in electrolyte")
+c_n_init_dimensional = pybamm.Parameter("Initial concentration in negative electrode")
+c_p_init_dimensional = pybamm.Parameter("Initial concentration in positive electrode")
+
+# --------------------------------------------------------------------------------------
+"""Functions"""
+
+
+def D_n_dimensional(c_n):
+    "Dimensional diffusivity in negative particle"
+    return 1  # pybamm.FunctionParameter("Negative electrode diffusivity", c_n)
+
+
+def D_n(c_n):
+    "Dimensionless negative particle diffusivity"
+    c_n_dimensional = c_n * c_n_max
+    return D_n_dimensional(c_n_dimensional) / D_n_dimensional(c_n_max)
+
+
+def D_p_dimensional(c_p):
+    "Dimensional diffusivity in positive particle"
+    return 1  # pybamm.FunctionParameter("Positive electrode diffusivity", c_p)
+
+
+def D_p(c_p):
+    "Dimensionless positive particle diffusivity"
+    c_p_dimensional = c_p * c_p_max
+    return D_p_dimensional(c_p_dimensional) / D_p_dimensional(c_p_max)
+
+
+def U_n_dimensional(c):
+    "Dimensionless open circuit potential in the negative electrode"
+    #  out = (0.194 + 1.5 * np.exp(-120.0 * c)
+    #       + 0.0351 * np.tanh((c - 0.286) / 0.083)
+    #       - 0.0045 * np.tanh((c - 0.849) / 0.119)
+    #       - 0.035 * np.tanh((c - 0.9233) / 0.05)
+    #       - 0.0147 * np.tanh((c - 0.5) / 0.034)
+    #       - 0.102 * np.tanh((c - 0.194) / 0.142)
+    #       - 0.022 * np.tanh((c - 0.9) / 0.0164)
+    #       - 0.011 * np.tanh((c - 0.124) / 0.0226)
+    #       + 0.0155 * np.tanh((c - 0.105) / 0.029))
+    # Set constant until functions implemented correctly
+    out = 0.2230
+    return out
+
+
+U_n_ref = U_n_dimensional(1)
+
+
+def U_p_dimensional(c):
+    "Dimensionless open circuit potential in the positive electrode"
+    # stretch = 1.062
+    # sto = stretch * c
+    # out = (2.16216 + 0.07645 * np.tanh(30.834 - 54.4806 * sto)
+    #       + 2.1581 * np.tanh(52.294 - 50.294 * sto)
+    #       - 0.14169 * np.tanh(11.0923 - 19.8543 * sto)
+    #       + 0.2051 * np.tanh(1.4684 - 5.4888 * sto)
+    #       + 0.2531 * np.tanh((-sto + 0.56478) / 0.1316)
+    #       - 0.02167 * np.tanh((sto - 0.525) / 0.006))
+    # Set constant until functions implemented correctly
+    out = 4.1212
+    return out
+
+
+U_p_ref = U_p_dimensional(1)
+
+
+def U_n(c_n):
+    "Dimensionless open-circuit sp.potential in the negative electrode"
+    c_n_dimensional = c_n * c_n_max
+    return (U_n_dimensional(c_n_dimensional) - U_n_ref) / sp.potential_scale
+
+
+def U_p(c_p):
+    "Dimensionless open-circuit sp.potential in the positive electrode"
+    c_p_dimensional = c_p * c_p_max
+    return (U_p_dimensional(c_p_dimensional) - U_p_ref) / sp.potential_scale
+
+
+# --------------------------------------------------------------------------------------
+"""Scales"""
+
+# Timescales
+# Discharge timescale
+tau_discharge = sp.F * c_n_max * sp.L_x / sp.i_typ
+# Particle diffusion timescales
+tau_diffusion_n = R_n ** 2 / D_n_dimensional(c_n_max)
+tau_diffusion_p = R_n ** 2 / D_p_dimensional(c_p_max)
+
+# --------------------------------------------------------------------------------------
+"""Dimensionless Parameters"""
+
+# Microscale geometry
+epsilon_n = pybamm.Parameter("Negative electrode porosity")
+epsilon_s = pybamm.Parameter("Separator porosity")
+epsilon_p = pybamm.Parameter("Positive electrode porosity")
+epsilon = pybamm.Concatenation(
+    pybamm.Broadcast(epsilon_n, ["negative electrode"]),
+    pybamm.Broadcast(epsilon_s, ["separator"]),
+    pybamm.Broadcast(epsilon_p, ["positive electrode"]),
+)
+# QUESTION: can we call these something different? they clash with the betas in Pb-acid
+beta_n = sp.a_n * R_n
+beta_p = sp.a_p * R_p
+
+# Microscale properties
+# Note: gamma_hat_n == 1, so not needed
+gamma_hat_p = c_p_max / c_n_max
+C_n = tau_discharge / tau_diffusion_n  # diffusional C-rate in negative electrode
+C_p = tau_discharge / tau_diffusion_p  # diffusional C-rate in positive electrode
+
+# Electrolyte Properties
+C_e = sp.tau_diffusion_e / tau_discharge  # diffusional C-rate in electrolyte
+gamma_hat_e = sp.c_e_typ / c_n_max
+
+# Electrochemical Reactions
+C_dl_n = (
+    sp.C_dl_dimensional
+    * sp.potential_scale
+    / sp.interfacial_current_scale_n
+    / tau_discharge
+)
+C_dl_p = (
+    sp.C_dl_dimensional
+    * sp.potential_scale
+    / sp.interfacial_current_scale_p
+    / tau_discharge
+)
+
+# Electrical
+voltage_low_cut = (
+    sp.voltage_low_cut_dimensional - (U_p_ref - U_n_ref)
+) / sp.potential_scale
+voltage_high_cut = (
+    sp.voltage_high_cut_dimensional - (U_p_ref - U_n_ref)
+) / sp.potential_scale
+
+# Initial conditions
+c_e_init = c_e_init_dimensional / sp.c_e_typ
+c_n_init = c_n_init_dimensional / c_n_max
+c_p_init = c_p_init_dimensional / c_p_max


Test patch:
diff --git a/input/parameters/lead-acid/optional_test.csv b/input/parameters/lead-acid/optional_test.csv
index 979c62d9..2272b9d6 100644
--- a/input/parameters/lead-acid/optional_test.csv
+++ b/input/parameters/lead-acid/optional_test.csv
@@ -1,5 +1,5 @@
 Name,Value,Units,Meaning,Reference
 # Geometric parameters,,,,
-Ln,0.5,,,
-Ls,0.5,,,
-Lp,0.5,,,
+Negative electrode width,0.5,,,
+Separator width,0.5,,,
+Positive electrode width,0.5,,,
diff --git a/tests/shared.py b/tests/shared.py
index 6333f29a..b13ab334 100644
--- a/tests/shared.py
+++ b/tests/shared.py
@@ -51,7 +51,13 @@ class SpatialMethodForTesting(pybamm.SpatialMethod):
 
 
 def get_mesh_for_testing(npts=None):
-    param = pybamm.ParameterValues(base_parameters={"Ln": 0.3, "Ls": 0.3, "Lp": 0.3})
+    param = pybamm.ParameterValues(
+        base_parameters={
+            "Negative electrode width": 0.3,
+            "Separator width": 0.3,
+            "Positive electrode width": 0.3,
+        }
+    )
 
     geometry = pybamm.Geometry("1D macro", "1D micro")
     param.process_geometry(geometry)
diff --git a/tests/test_meshes/test_meshes.py b/tests/test_meshes/test_meshes.py
index a3c6bad2..9f6b2483 100644
--- a/tests/test_meshes/test_meshes.py
+++ b/tests/test_meshes/test_meshes.py
@@ -9,7 +9,11 @@ import unittest
 class TestMesh(unittest.TestCase):
     def test_mesh_creation(self):
         param = pybamm.ParameterValues(
-            base_parameters={"Ln": 0.1, "Ls": 0.2, "Lp": 0.3}
+            base_parameters={
+                "Negative electrode width": 0.1,
+                "Separator width": 0.2,
+                "Positive electrode width": 0.3,
+            }
         )
 
         geometry = pybamm.Geometry1DMacro()
@@ -52,7 +56,11 @@ class TestMesh(unittest.TestCase):
 
     def test_mesh_sizes(self):
         param = pybamm.ParameterValues(
-            base_parameters={"Ln": 0.1, "Ls": 0.2, "Lp": 0.3}
+            base_parameters={
+                "Negative electrode width": 0.1,
+                "Separator width": 0.2,
+                "Positive electrode width": 0.3,
+            }
         )
 
         geometry = pybamm.Geometry1DMacro()
@@ -84,7 +92,11 @@ class TestMesh(unittest.TestCase):
 
     def test_combine_submeshes(self):
         param = pybamm.ParameterValues(
-            base_parameters={"Ln": 0.1, "Ls": 0.2, "Lp": 0.3}
+            base_parameters={
+                "Negative electrode width": 0.1,
+                "Separator width": 0.2,
+                "Positive electrode width": 0.3,
+            }
         )
 
         geometry = pybamm.Geometry1DMacro()
@@ -129,7 +141,11 @@ class TestMesh(unittest.TestCase):
 
     def test_ghost_cells(self):
         param = pybamm.ParameterValues(
-            base_parameters={"Ln": 0.1, "Ls": 0.2, "Lp": 0.3}
+            base_parameters={
+                "Negative electrode width": 0.1,
+                "Separator width": 0.2,
+                "Positive electrode width": 0.3,
+            }
         )
 
         geometry = pybamm.Geometry1DMacro()
diff --git a/tests/test_models/test_interface.py b/tests/test_models/test_interface.py
index a2a84a9c..0be6ecd9 100644
--- a/tests/test_models/test_interface.py
+++ b/tests/test_models/test_interface.py
@@ -8,6 +8,7 @@ from tests import get_discretisation_for_testing
 
 import unittest
 import numpy as np
+import os
 
 
 class TestHomogeneousReaction(unittest.TestCase):
@@ -62,18 +63,18 @@ class TestHomogeneousReaction(unittest.TestCase):
         self.assertEqual(processed_rxn.shape, combined_submeshes.nodes.shape)
 
         # test values
-        ln = param.process_symbol(pybamm.standard_parameters.ln)
-        lp = param.process_symbol(pybamm.standard_parameters.lp)
+        l_n = param.process_symbol(pybamm.standard_parameters.l_n)
+        l_p = param.process_symbol(pybamm.standard_parameters.l_p)
         npts_n = mesh["negative electrode"].npts
         npts_s = mesh["separator"].npts
         np.testing.assert_array_equal(
-            processed_rxn.evaluate()[:npts_n] * ln.evaluate(), 1
+            processed_rxn.evaluate()[:npts_n] * l_n.evaluate(), 1
         )
         np.testing.assert_array_equal(
             processed_rxn.evaluate()[npts_n : npts_n + npts_s], 0
         )
         np.testing.assert_array_equal(
-            processed_rxn.evaluate()[npts_n + npts_s :] * lp.evaluate(), -1
+            processed_rxn.evaluate()[npts_n + npts_s :] * l_p.evaluate(), -1
         )
 
 
@@ -152,8 +153,18 @@ class TestButlerVolmerLeadAcid(unittest.TestCase):
 
     def test_set_parameters(self):
         bv = pybamm.interface.butler_volmer_lead_acid(self.c, self.phi)
+        input_path = os.path.join(os.getcwd(), "input", "parameters", "lead-acid")
         param = pybamm.ParameterValues(
-            "input/parameters/lead-acid/default.csv", {"current scale": 1}
+            "input/parameters/lead-acid/default.csv",
+            {
+                "Typical current density": 1,
+                "Negative electrode OCV": os.path.join(
+                    input_path, "lead_electrode_ocv_Bode1977.py"
+                ),
+                "Positive electrode OCV": os.path.join(
+                    input_path, "lead_dioxide_electrode_ocv_Bode1977.py"
+                ),
+            },
         )
         proc_bv = param.process_symbol(bv)
         [self.assertNotIsInstance(x, pybamm.Parameter) for x in proc_bv.pre_order()]
@@ -163,8 +174,18 @@ class TestButlerVolmerLeadAcid(unittest.TestCase):
         bv_p = pybamm.interface.butler_volmer_lead_acid(self.cp, self.phip)
 
         # process parameters
+        input_path = os.path.join(os.getcwd(), "input", "parameters", "lead-acid")
         param = pybamm.ParameterValues(
-            "input/parameters/lead-acid/default.csv", {"current scale": 1}
+            "input/parameters/lead-acid/default.csv",
+            {
+                "Typical current density": 1,
+                "Negative electrode OCV": os.path.join(
+                    input_path, "lead_electrode_ocv_Bode1977.py"
+                ),
+                "Positive electrode OCV": os.path.join(
+                    input_path, "lead_dioxide_electrode_ocv_Bode1977.py"
+                ),
+            },
         )
         param_bv_n = param.process_symbol(bv_n)
         param_bv_p = param.process_symbol(bv_p)
@@ -196,8 +217,18 @@ class TestButlerVolmerLeadAcid(unittest.TestCase):
         bv_whole = pybamm.interface.butler_volmer_lead_acid(self.c, self.phi)
 
         # process parameters
+        input_path = os.path.join(os.getcwd(), "input", "parameters", "lead-acid")
         param = pybamm.ParameterValues(
-            "input/parameters/lead-acid/default.csv", {"current scale": 1}
+            "input/parameters/lead-acid/default.csv",
+            {
+                "Typical current density": 1,
+                "Negative electrode OCV": os.path.join(
+                    input_path, "lead_electrode_ocv_Bode1977.py"
+                ),
+                "Positive electrode OCV": os.path.join(
+                    input_path, "lead_dioxide_electrode_ocv_Bode1977.py"
+                ),
+            },
         )
         param_bv_whole = param.process_symbol(bv_whole)
 
@@ -257,11 +288,13 @@ class TestExchangeCurrentDensity(unittest.TestCase):
 
     def test_failure(self):
         with self.assertRaises(pybamm.DomainError):
-            pybamm.interface.exchange_current_density(None, ["not a domain"])
+            pybamm.interface.exchange_current_density(
+                pybamm.Scalar(3), ["not a domain"]
+            )
 
     def test_set_parameters(self):
         param = pybamm.ParameterValues(
-            "input/parameters/lead-acid/default.csv", {"current scale": 1}
+            "input/parameters/lead-acid/default.csv", {"Typical current density": 1}
         )
         j0n = pybamm.interface.exchange_current_density(self.cn)
         j0p = pybamm.interface.exchange_current_density(self.cp)
@@ -277,7 +310,7 @@ class TestExchangeCurrentDensity(unittest.TestCase):
 
         # process parameters
         param = pybamm.ParameterValues(
-            "input/parameters/lead-acid/default.csv", {"current scale": 1}
+            "input/parameters/lead-acid/default.csv", {"Typical current density": 1}
         )
         param_j0n = param.process_symbol(j0n)
         param_j0p = param.process_symbol(j0p)
diff --git a/tests/test_parameters/test_parameter_values.py b/tests/test_parameters/test_parameter_values.py
index 0ae3b722..19a4448f 100644
--- a/tests/test_parameters/test_parameter_values.py
+++ b/tests/test_parameters/test_parameter_values.py
@@ -12,7 +12,7 @@ class TestParameterValues(unittest.TestCase):
         data = pybamm.ParameterValues().read_parameters_csv(
             "input/parameters/lead-acid/default.csv"
         )
-        self.assertEqual(data["R"], 8.314)
+        self.assertEqual(data["Ideal gas constant"], 8.314)
 
     def test_init(self):
         # from dict
@@ -20,7 +20,7 @@ class TestParameterValues(unittest.TestCase):
         self.assertEqual(param["a"], 1)
         # from file
         param = pybamm.ParameterValues("input/parameters/lead-acid/default.csv")
-        self.assertEqual(param["R"], 8.314)
+        self.assertEqual(param["Ideal gas constant"], 8.314)
 
     def test_overwrite(self):
         # from dicts
@@ -36,8 +36,8 @@ class TestParameterValues(unittest.TestCase):
             base_parameters="input/parameters/lead-acid/default.csv",
             optional_parameters="input/parameters/lead-acid/optional_test.csv",
         )
-        self.assertEqual(param["R"], 8.314)
-        self.assertEqual(param["Ln"], 0.5)
+        self.assertEqual(param["Ideal gas constant"], 8.314)
+        self.assertEqual(param["Negative electrode width"], 0.5)
 
     def test_get_parameter_value(self):
         parameter_values = pybamm.ParameterValues({"a": 1})
@@ -120,7 +120,8 @@ class TestParameterValues(unittest.TestCase):
 
     def test_process_function_parameter(self):
         parameter_values = pybamm.ParameterValues(
-            {"a": 3, "func": 'process_symbol_test_function.py'})
+            {"a": 3, "func": "process_symbol_test_function.py"}
+        )
 
         # process parameter
         a = pybamm.Parameter("a")
diff --git a/tests/test_parameters/test_standard_parameters.py b/tests/test_parameters/test_standard_parameters.py
index d264a7f0..cee368e2 100644
--- a/tests/test_parameters/test_standard_parameters.py
+++ b/tests/test_parameters/test_standard_parameters.py
@@ -9,38 +9,47 @@ import unittest
 
 class TestStandardParameters(unittest.TestCase):
     def test_geometric_parameters(self):
-        Ln = pybamm.standard_parameters.Ln
-        Ls = pybamm.standard_parameters.Ls
-        Lp = pybamm.standard_parameters.Lp
-        Lx = pybamm.standard_parameters.Lx
-        ln = pybamm.standard_parameters.ln
-        ls = pybamm.standard_parameters.ls
-        lp = pybamm.standard_parameters.lp
+        L_n = pybamm.standard_parameters.L_n
+        L_s = pybamm.standard_parameters.L_s
+        L_p = pybamm.standard_parameters.L_p
+        L_x = pybamm.standard_parameters.L_x
+        l_n = pybamm.standard_parameters.l_n
+        l_s = pybamm.standard_parameters.l_s
+        l_p = pybamm.standard_parameters.l_p
 
         parameter_values = pybamm.ParameterValues(
-            base_parameters={"Ln": 0.05, "Ls": 0.02, "Lp": 0.21}
+            base_parameters={
+                "Negative electrode width": 0.05,
+                "Separator width": 0.02,
+                "Positive electrode width": 0.21,
+            }
+        )
+        L_n_eval = parameter_values.process_symbol(L_n)
+        L_s_eval = parameter_values.process_symbol(L_s)
+        L_p_eval = parameter_values.process_symbol(L_p)
+        L_x_eval = parameter_values.process_symbol(L_x)
+        self.assertEqual(
+            (L_n_eval + L_s_eval + L_p_eval).evaluate(), L_x_eval.evaluate()
         )
-        Ln_eval = parameter_values.process_symbol(Ln)
-        Ls_eval = parameter_values.process_symbol(Ls)
-        Lp_eval = parameter_values.process_symbol(Lp)
-        Lx_eval = parameter_values.process_symbol(Lx)
-        self.assertEqual((Ln_eval + Ls_eval + Lp_eval).evaluate(), Lx_eval.evaluate())
-        self.assertEqual((Ln_eval + Ls_eval + Lp_eval).id, Lx_eval.id)
-        ln_eval = parameter_values.process_symbol(ln)
-        ls_eval = parameter_values.process_symbol(ls)
-        lp_eval = parameter_values.process_symbol(lp)
-        self.assertAlmostEqual((ln_eval + ls_eval + lp_eval).evaluate(), 1)
+        self.assertEqual((L_n_eval + L_s_eval + L_p_eval).id, L_x_eval.id)
+        l_n_eval = parameter_values.process_symbol(l_n)
+        l_s_eval = parameter_values.process_symbol(l_s)
+        l_p_eval = parameter_values.process_symbol(l_p)
+        self.assertAlmostEqual((l_n_eval + l_s_eval + l_p_eval).evaluate(), 1)
 
-    def test_functions(self):
+    def test_current_functions(self):
         # create current functions
-        current = pybamm.standard_parameters.dimensional_current_with_time
+        dimensional_current = pybamm.standard_parameters.dimensional_current_with_time
         dimensionless_current = pybamm.standard_parameters.current_with_time
 
         # process
         parameter_values = pybamm.ParameterValues(
             {
-                "I_typ": 2,
-                "current function": os.path.join(
+                "Electrode height": 0.1,
+                "Electrode depth": 0.1,
+                "Number of electrodes connected in parallel to make a cell": 8,
+                "Typical current density": 2,
+                "Current function": os.path.join(
                     os.getcwd(),
                     "pybamm",
                     "parameters",
@@ -49,11 +58,13 @@ class TestStandardParameters(unittest.TestCase):
                 ),
             }
         )
-        current_eval = parameter_values.process_symbol(current)
+        dimensional_current_eval = parameter_values.process_symbol(dimensional_current)
         dimensionless_current_eval = parameter_values.process_symbol(
             dimensionless_current
         )
-        self.assertEqual(current_eval.evaluate(t=3), 2)
+        self.assertAlmostEqual(
+            dimensional_current_eval.evaluate(t=3), 2 / (8 * 0.1 * 0.1)
+        )
         self.assertEqual(dimensionless_current_eval.evaluate(t=3), 1)
 
 
diff --git a/tests/test_parameters/test_standard_parameters_lead_acid.py b/tests/test_parameters/test_standard_parameters_lead_acid.py
index d0f26033..1ccd4513 100644
--- a/tests/test_parameters/test_standard_parameters_lead_acid.py
+++ b/tests/test_parameters/test_standard_parameters_lead_acid.py
@@ -14,19 +14,25 @@ class TestStandardParametersLeadAcid(unittest.TestCase):
     def test_parameters_defaults_lead_acid(self):
         # Load parameters to be tested
         parameters = {
-            "Cd": pybamm.standard_parameters_lead_acid.Cd,
-            "Crate": pybamm.standard_parameters_lead_acid.Crate,
-            "iota_s_n": pybamm.standard_parameters_lead_acid.iota_s_n,
-            "iota_s_p": pybamm.standard_parameters_lead_acid.iota_s_p,
-            "gamma_dl_n": pybamm.standard_parameters_lead_acid.gamma_dl_n,
-            "gamma_dl_p": pybamm.standard_parameters_lead_acid.gamma_dl_p,
+            "C_e": pybamm.standard_parameters_lead_acid.C_e,
+            "C_rate": pybamm.standard_parameters.C_rate,
+            "sigma_n": pybamm.standard_parameters.sigma_n,
+            "sigma_p": pybamm.standard_parameters.sigma_p,
+            "C_dl_n": pybamm.standard_parameters_lead_acid.C_dl_n,
+            "C_dl_p": pybamm.standard_parameters_lead_acid.C_dl_p,
             "DeltaVsurf_n": pybamm.standard_parameters_lead_acid.DeltaVsurf_n,
             "DeltaVsurf_p": pybamm.standard_parameters_lead_acid.DeltaVsurf_p,
-            "alpha": pybamm.standard_parameters_lead_acid.alpha,
         }
         # Process
+        input_path = os.path.join(os.getcwd(), "input", "parameters", "lead-acid")
         parameter_values = pybamm.ParameterValues(
-            "input/parameters/lead-acid/default.csv", {"current scale": 1}
+            "input/parameters/lead-acid/default.csv",
+            {
+                "Typical current density": 1,
+                "Electrolyte diffusivity": os.path.join(
+                    input_path, "electrolyte_diffusivity_Gu1997.py"
+                ),
+            },
         )
         param_eval = {
             name: parameter_values.process_symbol(parameter).evaluate()
@@ -34,24 +40,22 @@ class TestStandardParametersLeadAcid(unittest.TestCase):
         }
 
         # Diffusional C-rate should be smaller than C-rate
-        self.assertLess(param_eval["Cd"], param_eval["Crate"])
+        self.assertLess(param_eval["C_e"], param_eval["C_rate"])
 
         # Dimensionless electrode conductivities should be large
-        self.assertGreater(param_eval["iota_s_n"], 10)
-        self.assertGreater(param_eval["iota_s_p"], 10)
+        self.assertGreater(param_eval["sigma_n"], 10)
+        self.assertGreater(param_eval["sigma_p"], 10)
         # Dimensionless double-layer capacity should be small
-        self.assertLess(param_eval["gamma_dl_n"], 1e-3)
-        self.assertLess(param_eval["gamma_dl_p"], 1e-3)
+        self.assertLess(param_eval["C_dl_n"], 1e-3)
+        self.assertLess(param_eval["C_dl_p"], 1e-3)
         # Volume change positive in negative electrode and negative in positive
         # electrode
         self.assertLess(param_eval["DeltaVsurf_n"], 0)
         self.assertGreater(param_eval["DeltaVsurf_p"], 0)
-        # Excluded volume fraction should be less than 0.1
-        self.assertLess(abs(param_eval["alpha"]), 1e-1)
 
     def test_concatenated_parameters(self):
         # create
-        s = pybamm.standard_parameters_lead_acid.s
+        s = pybamm.standard_parameters.s
         self.assertIsInstance(s, pybamm.Concatenation)
         self.assertEqual(
             s.domain, ["negative electrode", "separator", "positive electrode"]
@@ -59,7 +63,7 @@ class TestStandardParametersLeadAcid(unittest.TestCase):
 
         # process parameters and discretise
         parameter_values = pybamm.ParameterValues(
-            "input/parameters/lead-acid/default.csv", {"current scale": 1}
+            "input/parameters/lead-acid/default.csv", {"Typical current density": 1}
         )
         disc = get_discretisation_for_testing()
         processed_s = disc.process_symbol(parameter_values.process_symbol(s))
@@ -74,17 +78,17 @@ class TestStandardParametersLeadAcid(unittest.TestCase):
 
     def test_current_functions(self):
         # create current functions
-        current = pybamm.standard_parameters_lead_acid.dimensional_current_with_time
-        dimensionless_current = pybamm.standard_parameters_lead_acid.current_with_time
+        dimensional_current = pybamm.standard_parameters.dimensional_current_with_time
+        dimensionless_current = pybamm.standard_parameters.current_with_time
 
         # process
         parameter_values = pybamm.ParameterValues(
             {
-                "H": 0.1,
-                "W": 0.1,
-                "number of electrodes in parallel": 8,
-                "current scale": 2,
-                "current function": os.path.join(
+                "Electrode height": 0.1,
+                "Electrode depth": 0.1,
+                "Number of electrodes connected in parallel to make a cell": 8,
+                "Typical current density": 2,
+                "Current function": os.path.join(
                     os.getcwd(),
                     "pybamm",
                     "parameters",
@@ -93,31 +97,69 @@ class TestStandardParametersLeadAcid(unittest.TestCase):
                 ),
             }
         )
-        current_eval = parameter_values.process_symbol(current)
+        dimensional_current_eval = parameter_values.process_symbol(dimensional_current)
         dimensionless_current_eval = parameter_values.process_symbol(
             dimensionless_current
         )
-        self.assertAlmostEqual(current_eval.evaluate(t=3), 2 / (8 * 0.1 * 0.1))
+        self.assertAlmostEqual(
+            dimensional_current_eval.evaluate(t=3), 2 / (8 * 0.1 * 0.1)
+        )
         self.assertEqual(dimensionless_current_eval.evaluate(t=3), 1)
 
-    @unittest.skip("lead acid functions not yet implemented")
     def test_functions_lead_acid(self):
-        # Tests on how the parameters interact
-        param = pybamm.ParameterValues(chemistry="lead-acid")
-        mesh = pybamm.Mesh(param, 10)
-        param.set_mesh(mesh)
+        # Load parameters to be tested
+        parameters = {
+            "D_e_1": pybamm.standard_parameters.D_e(pybamm.Scalar(1)),
+            "kappa_e_0": pybamm.standard_parameters.kappa_e(pybamm.Scalar(0)),
+            "chi_1": pybamm.standard_parameters_lead_acid.chi(pybamm.Scalar(1)),
+            "chi_0.5": pybamm.standard_parameters_lead_acid.chi(pybamm.Scalar(0.5)),
+            "U_n_1": pybamm.standard_parameters_lead_acid.U_n(pybamm.Scalar(1)),
+            "U_n_0.5": pybamm.standard_parameters_lead_acid.U_n(pybamm.Scalar(0.5)),
+            "U_p_1": pybamm.standard_parameters_lead_acid.U_p(pybamm.Scalar(1)),
+            "U_p_0.5": pybamm.standard_parameters_lead_acid.U_p(pybamm.Scalar(0.5)),
+        }
+        # Process
+        input_path = os.path.join(os.getcwd(), "input", "parameters", "lead-acid")
+        parameter_values = pybamm.ParameterValues(
+            "input/parameters/lead-acid/default.csv",
+            {
+                "Typical current density": 1,
+                "Current function": os.path.join(
+                    os.getcwd(),
+                    "pybamm",
+                    "parameters",
+                    "standard_current_functions",
+                    "constant_current.py",
+                ),
+                "Electrolyte diffusivity": os.path.join(
+                    input_path, "electrolyte_diffusivity_Gu1997.py"
+                ),
+                "Electrolyte conductivity": os.path.join(
+                    input_path, "electrolyte_conductivity_Gu1997.py"
+                ),
+                "Darken thermodynamic factor": os.path.join(
+                    input_path, "darken_thermodynamic_factor_Chapman1968.py"
+                ),
+                "Negative electrode OCV": os.path.join(
+                    input_path, "lead_electrode_ocv_Bode1977.py"
+                ),
+                "Positive electrode OCV": os.path.join(
+                    input_path, "lead_dioxide_electrode_ocv_Bode1977.py"
+                ),
+            },
+        )
+        param_eval = {
+            name: parameter_values.process_symbol(parameter).evaluate()
+            for name, parameter in parameters.items()
+        }
+
         # Known values for dimensionless functions
-        self.assertEqual(param.D_eff(1, 1), 1)
-        self.assertEqual(param.kappa_eff(0, 1), 0)
-        self.assertEqual(param.kappa_eff(1, 0), 0)
-        self.assertEqual(param.neg_reactions.j0(0), 0)
-        self.assertEqual(param.pos_reactions.j0(0), 0)
+        self.assertEqual(param_eval["D_e_1"], 1)
+        self.assertEqual(param_eval["kappa_e_0"], 0)
         # Known monotonicity for dimensionless functions
-        self.assertLess(param.neg_reactions.j0(1), param.neg_reactions.j0(2))
-        self.assertLess(param.pos_reactions.j0(1), param.pos_reactions.j0(2))
-        self.assertGreater(param.lead_acid_misc.chi(1), param.lead_acid_misc.chi(0.5))
-        self.assertLess(param.neg_reactions.U(1), param.neg_reactions.U(0.5))
-        self.assertGreater(param.pos_reactions.U(1), param.pos_reactions.U(0.5))
+        self.assertGreater(param_eval["chi_1"], param_eval["chi_0.5"])
+        self.assertLess(param_eval["U_n_1"], param_eval["U_n_0.5"])
+        self.assertGreater(param_eval["U_p_1"], param_eval["U_p_0.5"])
 
 
 if __name__ == "__main__":