diff --git a/CHANGELOG.md b/CHANGELOG.md
index be84324020..7a68ee6a5c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,14 +4,16 @@
 
 -   Added `BackwardIndefiniteIntegral` symbol ([#1014](https://github.com/pybamm-team/PyBaMM/pull/1014))
 -   Added `plot` and `plot2D` to enable easy plotting of `pybamm.Array` objects ([#1008](https://github.com/pybamm-team/PyBaMM/pull/1008))
+-   Updated effective current collector models and added example notebook ([#1007](https://github.com/pybamm-team/PyBaMM/pull/1007))
 -   Added SEI film resistance as an option ([#994](https://github.com/pybamm-team/PyBaMM/pull/994))
+-   Added `parameters` attribute to `pybamm.BaseModel` and `pybamm.Geometry` that lists all of the required parameters ([#993](https://github.com/pybamm-team/PyBaMM/pull/993))
 -   Added tab, edge, and surface cooling ([#965](https://github.com/pybamm-team/PyBaMM/pull/965))
 -   Added functionality to solver to automatically discretise a 0D model ([#947](https://github.com/pybamm-team/PyBaMM/pull/947))
 -   Added sensitivity to `CasadiAlgebraicSolver` ([#940](https://github.com/pybamm-team/PyBaMM/pull/940))
 -   Added `ProcessedSymbolicVariable` class, which can handle symbolic variables (i.e. variables for which the inputs are symbolic) ([#940](https://github.com/pybamm-team/PyBaMM/pull/940))
 -   Made `QuickPlot` compatible with Google Colab ([#935](https://github.com/pybamm-team/PyBaMM/pull/935))
 -   Added `BasicFull` model for lead-acid ([#932](https://github.com/pybamm-team/PyBaMM/pull/932))
--   Added 'arctan' function  ([#973]https://github.com/pybamm-team/PyBaMM/pull/973)
+-   Added 'arctan' function  ([#973](https://github.com/pybamm-team/PyBaMM/pull/973))
 
 ## Optimizations
 
diff --git a/docs/source/models/submodels/current_collector/effective_resistance_current_collector.rst b/docs/source/models/submodels/current_collector/effective_resistance_current_collector.rst
index ead0244857..7210f2c510 100644
--- a/docs/source/models/submodels/current_collector/effective_resistance_current_collector.rst
+++ b/docs/source/models/submodels/current_collector/effective_resistance_current_collector.rst
@@ -1,5 +1,8 @@
 Effective Current collector Resistance models
 =============================================
 
-.. autoclass:: pybamm.current_collector.EffectiveResistance2D
+.. autoclass:: pybamm.current_collector.EffectiveResistance
+    :members:
+
+.. autoclass:: pybamm.current_collector.AlternativeEffectiveResistance2D
     :members:
diff --git a/examples/notebooks/Creating Models/2-a-pde-model.ipynb b/examples/notebooks/Creating Models/2-a-pde-model.ipynb
index 09acd1e1c5..384f016072 100644
--- a/examples/notebooks/Creating Models/2-a-pde-model.ipynb	
+++ b/examples/notebooks/Creating Models/2-a-pde-model.ipynb	
@@ -298,7 +298,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.5"
+   "version": "3.6.9"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebooks/Creating Models/5-a-simple-SEI-model.ipynb b/examples/notebooks/Creating Models/5-a-simple-SEI-model.ipynb
index d9ae44aa71..4e74a1c3cd 100644
--- a/examples/notebooks/Creating Models/5-a-simple-SEI-model.ipynb	
+++ b/examples/notebooks/Creating Models/5-a-simple-SEI-model.ipynb	
@@ -653,7 +653,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.5"
+   "version": "3.6.9"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebooks/Getting Started/Tutorial 4 - Model Options.ipynb b/examples/notebooks/Getting Started/Tutorial 4 - Model Options.ipynb
index 3b21989fcd..3cbcea305a 100644
--- a/examples/notebooks/Getting Started/Tutorial 4 - Model Options.ipynb	
+++ b/examples/notebooks/Getting Started/Tutorial 4 - Model Options.ipynb	
@@ -50,7 +50,18 @@
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<pybamm.solvers.solution.Solution at 0x7fabe3f3e6a0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "model = pybamm.lithium_ion.SPMe(options=options) # loading in options\n",
     "sim = pybamm.Simulation(model)\n",
@@ -78,12 +89,12 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "17368df63d2b44d3982c151286110d41",
+       "model_id": "6424823b40b548c8ad170e2e6797b5cb",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "interactive(children=(FloatSlider(value=0.0, description='t', max=0.2014814814814815, step=0.05), Output()), _…"
+       "interactive(children=(FloatSlider(value=0.0, description='t', max=1.0, step=0.01), Output()), _dom_classes=('w…"
       ]
      },
      "metadata": {},
@@ -125,7 +136,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.8"
+   "version": "3.6.9"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebooks/models/SPM.ipynb b/examples/notebooks/models/SPM.ipynb
index dbb53e4ec1..53d70da811 100644
--- a/examples/notebooks/models/SPM.ipynb
+++ b/examples/notebooks/models/SPM.ipynb
@@ -894,7 +894,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.6.9"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebooks/models/SPMe.ipynb b/examples/notebooks/models/SPMe.ipynb
index e20dbb19cf..8a46bd1f53 100644
--- a/examples/notebooks/models/SPMe.ipynb
+++ b/examples/notebooks/models/SPMe.ipynb
@@ -262,7 +262,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.6.9"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebooks/models/pouch-cell-model.ipynb b/examples/notebooks/models/pouch-cell-model.ipynb
new file mode 100644
index 0000000000..2beba71799
--- /dev/null
+++ b/examples/notebooks/models/pouch-cell-model.ipynb
@@ -0,0 +1,816 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Pouch cell model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this notebook we compare the solutions of two reduced-order models of a lithium-ion pouch cell with the full solution obtained using COMSOL. This example is based on the results in [[1]](#ref). The code used to produce the results in [[1]](#ref) can be found [here](https://github.com/rtimms/asymptotic-pouch-cell).\n",
+    "\n",
+    "The full model is based on the Doyle-Fuller-Newman model [[2]](#ref2) and, in the interest of simplicity, considers a one-dimensional current collector (i.e. variation in one of the current collector dimensions is ignored), resulting in a 2D macroscopic model.\n",
+    "\n",
+    "The first of the reduced order models, which is applicable in the limit of large conductivity in the current collectors, solves a one-dimensional problem in the current collectors coupled to a one-dimensional DFN model describing the through-cell electrochemistry at each point. We refer to this as a 1+1D model, though since the DFN is already a pseudo-two-dimensional model, perhaps it is more properly a 1+1+1D model.\n",
+    "\n",
+    "The second reduced order model, which is applicable in the limit of very large conductivity in the current collectors, solves a single (averaged) one-dimensional DFN model for the through-cell behaviour and an uncoupled problem for the distribution of potential in the current collectors (from which the resistance and heat source can be calculated). We refer to this model as the DFNCC, where the \"CC\" indicates the additional (uncoupled) current collector problem.\n",
+    "\n",
+    "All of the model equations, and derivations of the reduced-order models, can be found in [[1]](#ref)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### References\n",
+    "<a name=\"ref\">[1]</a> R Timms, SG Marquis, V Sulzer, CP Please and SJ Chapman. Asymptotic\n",
+    "           Reduction of a Lithium-ion Pouch Cell Model. Submitted, 2020\n",
+    "           \n",
+    "<a name=\"ref2\">[2]</a>  M Doyle,  TF Fuller,  and J Newman.  Modeling of galvanostatic charge and discharge of thelithium/polymer/insertion cell. Journal of the Electrochemical society, 140(6):1526–1533, 1993"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Solving the reduced-order pouch cell models in PyBaMM"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We begin by importing PyBaMM along with the other packages required in this notebook"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pybamm\n",
+    "import sys\n",
+    "import pickle\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import scipy.interpolate as interp\n",
+    "\n",
+    "# increase recursion limit for large expression trees\n",
+    "sys.setrecursionlimit(100000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then need to load up the appropriate models. For the DFNCC we require a 1D model of the current collectors and an average 1D DFN model for the through-cell electrochemistry. The 1+1D pouch cell model is built directly into PyBaMM and are accessed by passing the model option \"dimensionality\" which can be 1 or 2, corresponding to 1D or 2D current collectors. This option can be passed to any existing electrochemical model (e.g. [SPM](./SPM.ipynb), [SPMe](./SPMe.ipynb), [DFN](./DFN.ipynb)). Here we choose the DFN model. \n",
+    "\n",
+    "For both electrochemical models we choose an \"x-lumped\" thermal model, meaning we assume that the temperature is uniform in the through-cell direction $x$, but account for the variation in temperature in the transverse direction $z$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/user/Documents/PyBaMM/pybamm/models/full_battery_models/base_battery_model.py:308: UserWarning: 1+1D Thermal models are only valid if both tabs are placed at the top of the cell.\n",
+      "  \"1+1D Thermal models are only valid if both tabs are \"\n"
+     ]
+    }
+   ],
+   "source": [
+    "cc_model = pybamm.current_collector.EffectiveResistance({\"dimensionality\": 1})\n",
+    "dfn_av = pybamm.lithium_ion.DFN({\"thermal\": \"x-lumped\"}, name=\"Average DFN\")\n",
+    "dfn = pybamm.lithium_ion.DFN(\n",
+    "    {\"current collector\": \"potential pair\", \"dimensionality\": 1, \"thermal\": \"x-lumped\"},\n",
+    "    name=\"1+1D DFN\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then add the models to a dictionary for easy access later"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "models = {\"Current collector\": cc_model, \"Average DFN\": dfn_av, \"1+1D DFN\": dfn}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we update the parameters to match those used in the COMSOL simulation. In particular, we set the current to correspond to a 3C discharge and assume uniform Newton cooling on all boundaries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "param = dfn.default_parameter_values\n",
+    "I_1C = param[\"Cell capacity [A.h]\"]  # 1C current is cell capacity multipled by 1 hour\n",
+    "param.update(\n",
+    "    {\n",
+    "        \"Current function [A]\": I_1C * 3,\n",
+    "        \"Negative electrode diffusivity [m2.s-1]\": 3.9 * 10 ** (-14),\n",
+    "        \"Positive electrode diffusivity [m2.s-1]\": 10 ** (-13),\n",
+    "        \"Negative current collector surface heat transfer coefficient [W.m-2.K-1]\": 10,\n",
+    "        \"Positive current collector surface heat transfer coefficient [W.m-2.K-1]\": 10,\n",
+    "        \"Negative tab heat transfer coefficient [W.m-2.K-1]\": 10,\n",
+    "        \"Positive tab heat transfer coefficient [W.m-2.K-1]\": 10,\n",
+    "        \"Edge heat transfer coefficient [W.m-2.K-1]\": 10,\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example we choose to discretise in space using 16 nodes per domain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "var = pybamm.standard_spatial_vars\n",
+    "npts = 16\n",
+    "var_pts = {\n",
+    "    var.x_n: npts,\n",
+    "    var.x_s: npts,\n",
+    "    var.x_p: npts,\n",
+    "    var.r_n: npts,\n",
+    "    var.r_p: npts,\n",
+    "    var.z: npts,\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before solving the models we load the COMSOL data so that we can request the output at the times in the COMSOL solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comsol_results_path = pybamm.get_parameters_filepath(\n",
+    "    \"input/comsol_results/comsol_1plus1D_3C.pickle\"\n",
+    ")\n",
+    "comsol_variables = pickle.load(open(comsol_results_path, \"rb\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we loop over the models, creating and solving a simulation for each."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "simulations = {}\n",
+    "solutions = {}  # store solutions in a separate dict for easy access later\n",
+    "for name, model in models.items():\n",
+    "    sim = pybamm.Simulation(model, parameter_values=param, var_pts=var_pts)\n",
+    "    simulations[name] = sim  # store simulation for later\n",
+    "    if name == \"Current collector\":\n",
+    "        # model is independent of time, so just solve arbitrarily at t=0 using \n",
+    "        # the default algebraic solver\n",
+    "        t_eval = np.array([0])\n",
+    "        solutions[name] = sim.solve(t_eval=t_eval)        \n",
+    "    else:\n",
+    "        # solve at COMSOL times using Casadi solver in \"fast\" mode\n",
+    "        t_eval = comsol_variables[\"time\"]       \n",
+    "        solutions[name] = sim.solve(solver=pybamm.CasadiSolver(mode=\"fast\"), t_eval=t_eval)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating the COMSOL model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this section we show how to create a PyBaMM \"model\" from the COMSOL solution. If you are just interested in seeing the comparison the skip ahead to the section \"Comparing the full and reduced-order models\".\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To create a PyBaMM model from the COMSOL data we must create a `pybamm.Function` object for each variable. We do this by interpolating in space to match the PyBaMM mesh and then creating a function to interpolate in time. The following cell defines the function that handles the creation of the `pybamm.Function` object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set up times\n",
+    "tau = param.evaluate(pybamm.standard_parameters_lithium_ion.tau_discharge)\n",
+    "comsol_t = comsol_variables[\"time\"]\n",
+    "pybamm_t = comsol_t / tau\n",
+    "# set up space\n",
+    "mesh = simulations[\"1+1D DFN\"].mesh\n",
+    "L_z = param.evaluate(pybamm.standard_parameters_lithium_ion.L_z)\n",
+    "pybamm_z = mesh[\"current collector\"][0].nodes\n",
+    "z_interp = pybamm_z * L_z\n",
+    "\n",
+    "    \n",
+    "def get_interp_fun_curr_coll(variable_name):\n",
+    "    \"\"\"\n",
+    "    Create a :class:`pybamm.Function` object using the variable (interpolate in space \n",
+    "    to match nodes, and then create function to interpolate in time)\n",
+    "    \"\"\"\n",
+    "\n",
+    "    comsol_z = comsol_variables[variable_name + \"_z\"]\n",
+    "    variable = comsol_variables[variable_name]\n",
+    "    variable = interp.interp1d(comsol_z, variable, axis=0, kind=\"linear\")(z_interp)\n",
+    "\n",
+    "    def myinterp(t):\n",
+    "        return interp.interp1d(comsol_t, variable, kind=\"linear\")(t)[:, np.newaxis]\n",
+    "\n",
+    "    # Make sure to use dimensional time\n",
+    "    fun = pybamm.Function(myinterp, pybamm.t * tau, name=variable_name + \"_comsol\")\n",
+    "    fun.domain = \"current collector\"\n",
+    "    fun.mesh = mesh.combine_submeshes(\"current collector\")\n",
+    "    fun.secondary_mesh = None\n",
+    "    \n",
+    "    return fun"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then pass the variables of interest to the interpolating function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comsol_voltage = pybamm.Function(\n",
+    "    interp.interp1d(comsol_t, comsol_variables[\"voltage\"], kind=\"linear\"),\n",
+    "    pybamm.t * tau,\n",
+    "    name=\"voltage_comsol\",\n",
+    ")\n",
+    "comsol_voltage.mesh = None\n",
+    "comsol_voltage.secondary_mesh = None\n",
+    "comsol_phi_s_cn = get_interp_fun_curr_coll(\"phi_s_cn\")\n",
+    "comsol_phi_s_cp = get_interp_fun_curr_coll(\"phi_s_cp\")\n",
+    "comsol_current = get_interp_fun_curr_coll(\"current\")\n",
+    "comsol_temperature = get_interp_fun_curr_coll(\"temperature\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "and add them to a `pybamm.BaseModel` object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comsol_model = pybamm.BaseModel()\n",
+    "comsol_model.variables = {\n",
+    "    \"Terminal voltage [V]\": comsol_voltage,\n",
+    "    \"Negative current collector potential [V]\": comsol_phi_s_cn,\n",
+    "    \"Positive current collector potential [V]\": comsol_phi_s_cp,\n",
+    "    \"Current collector current density [A.m-2]\": comsol_current,\n",
+    "    \"X-averaged cell temperature [K]\": comsol_temperature,\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then add the solution object from the 1+1D model. This is just so that PyBaMM uses the same times behind the scenes when dealing with COMSOL model and the reduced-order models: the variables in `comsol_model.variables` are functions of time only that return the (interpolated in space) COMSOL solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "comsol_solution = pybamm.Solution(solutions[\"1+1D DFN\"].t, solutions[\"1+1D DFN\"].y)\n",
+    "comsol_solution.model = comsol_model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Comparing the full and reduced-order models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The DFNCC requires some post-processing to extract the solution variables. In particular, we need to pass the current and voltage from the average DFN model to the current collector model in order to compute the distribution of the potential in the current collectors and to account for the effect of the current collector resistance in the terminal voltage. \n",
+    "\n",
+    "This process is automated by the method `post_process` which accepts the current collector solution object, the parameters and the voltage and current from the average DFN model. The results are stored in the dictionary `dfncc_vars`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V_av = solutions[\"Average DFN\"][\"Terminal voltage\"]\n",
+    "I_av = solutions[\"Average DFN\"][\"Total current density\"]\n",
+    "\n",
+    "dfncc_vars = cc_model.post_process(\n",
+    "    solutions[\"Current collector\"], param, V_av, I_av\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we create a function to create some custom plots. For a given variable the plots will show: (a) the COMSOL results as a function of position in the current collector $z$ and time $t$; (b) a comparison of the full and reduced-order models and a sequence of times; (c) the time-averaged error between the full and reduced-order models as a function of space; and (d) the space-averaged error between the full and reduced-order models as a function of time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot(\n",
+    "    t_plot,\n",
+    "    z_plot,\n",
+    "    t_slices,\n",
+    "    var_name,\n",
+    "    units,\n",
+    "    comsol_var_fun,\n",
+    "    dfn_var_fun,\n",
+    "    dfncc_var_fun,\n",
+    "    param,\n",
+    "    cmap=\"viridis\",\n",
+    "):\n",
+    "    # non-dimensionalise t and z\n",
+    "    z_plot_non_dim = z_plot / L_z\n",
+    "    t_non_dim = t_plot / tau\n",
+    "    t_slices_non_dim = t_slices / tau\n",
+    "\n",
+    "    fig, ax = plt.subplots(2, 2, figsize=(13, 7))\n",
+    "    fig.subplots_adjust(\n",
+    "        left=0.15, bottom=0.1, right=0.95, top=0.95, wspace=0.4, hspace=0.8\n",
+    "    )\n",
+    "    # plot comsol var\n",
+    "    comsol_var = comsol_var_fun(t=t_non_dim, z=z_plot_non_dim)\n",
+    "    comsol_var_plot = ax[0, 0].pcolormesh(\n",
+    "        z_plot * 1e3, t_plot, np.transpose(comsol_var), shading=\"gouraud\", cmap=cmap\n",
+    "    )\n",
+    "    if \"cn\" in var_name:\n",
+    "        format = \"%.0e\"\n",
+    "    elif \"cp\" in var_name:\n",
+    "        format = \"%.0e\"\n",
+    "    else:\n",
+    "        format = None\n",
+    "    fig.colorbar(\n",
+    "        comsol_var_plot,\n",
+    "        ax=ax,\n",
+    "        format=format,\n",
+    "        location=\"top\",\n",
+    "        shrink=0.42,\n",
+    "        aspect=20,\n",
+    "        anchor=(0.0, 0.0),\n",
+    "    )\n",
+    "\n",
+    "    # plot slices\n",
+    "    ccmap = plt.get_cmap(\"inferno\")\n",
+    "    for ind, t in enumerate(t_slices_non_dim):\n",
+    "        color = ccmap(float(ind) / len(t_slices))\n",
+    "        comsol_var_slice = comsol_var_fun(t=t, z=z_plot_non_dim)\n",
+    "        dfn_var_slice = dfn_var_fun(t=t, z=z_plot_non_dim)\n",
+    "        dfncc_var_slice = dfncc_var_fun(t=np.array([t]), z=z_plot_non_dim)\n",
+    "        ax[0, 1].plot(\n",
+    "            z_plot * 1e3, comsol_var_slice, \"o\", fillstyle=\"none\", color=color\n",
+    "        )\n",
+    "        ax[0, 1].plot(\n",
+    "            z_plot * 1e3,\n",
+    "            dfn_var_slice,\n",
+    "            \"-\",\n",
+    "            color=color,\n",
+    "            label=\"{:.0f} s\".format(t_slices[ind]),\n",
+    "        )\n",
+    "        ax[0, 1].plot(z_plot * 1e3, dfncc_var_slice, \":\", color=color)\n",
+    "    # add dummy points for legend of styles\n",
+    "    comsol_p, = ax[0, 1].plot(np.nan, np.nan, \"ko\", fillstyle=\"none\")\n",
+    "    pybamm_p, = ax[0, 1].plot(np.nan, np.nan, \"k-\", fillstyle=\"none\")\n",
+    "    dfncc_p, = ax[0, 1].plot(np.nan, np.nan, \"k:\", fillstyle=\"none\")\n",
+    "\n",
+    "    # compute errors\n",
+    "    dfn_var = dfn_var_fun(t=t_non_dim, z=z_plot_non_dim)\n",
+    "    dfncc_var = dfncc_var_fun(t=t_non_dim, z=z_plot_non_dim)\n",
+    "    error = np.abs(comsol_var - dfn_var)\n",
+    "    error_bar = np.abs(comsol_var - dfncc_var)\n",
+    "\n",
+    "    # plot time averaged error\n",
+    "    ax[1, 0].plot(z_plot * 1e3, np.mean(error, axis=1), \"k-\", label=r\"$1+1$D\")\n",
+    "    ax[1, 0].plot(z_plot * 1e3, np.mean(error_bar, axis=1), \"k:\", label=\"DFNCC\")\n",
+    "\n",
+    "    # plot z averaged error\n",
+    "    ax[1, 1].plot(t_plot, np.mean(error, axis=0), \"k-\", label=r\"$1+1$D\")\n",
+    "    ax[1, 1].plot(t_plot, np.mean(error_bar, axis=0), \"k:\", label=\"DFNCC\")\n",
+    "\n",
+    "    # set ticks\n",
+    "    ax[0, 0].tick_params(which=\"both\")\n",
+    "    ax[0, 1].tick_params(which=\"both\")\n",
+    "    ax[1, 0].tick_params(which=\"both\")\n",
+    "    if var_name in [\"$\\mathcal{I}^*$\"]:\n",
+    "        ax[1, 0].set_yscale(\"log\")\n",
+    "        ax[1, 0].set_yticks = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e-2, 1e-1, 1]\n",
+    "    else:\n",
+    "        ax[1, 0].ticklabel_format(style=\"sci\", scilimits=(-2, 2), axis=\"y\")\n",
+    "    ax[1, 1].tick_params(which=\"both\")\n",
+    "    if var_name in [\"$\\phi^*_{\\mathrm{s,cn}}$\", \"$\\phi^*_{\\mathrm{s,cp}} - V^*$\"]:\n",
+    "        ax[1, 0].ticklabel_format(style=\"sci\", scilimits=(-2, 2), axis=\"y\")\n",
+    "    else:\n",
+    "        ax[1, 1].set_yscale(\"log\")\n",
+    "        ax[1, 1].set_yticks = [1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e-2, 1e-1, 1]\n",
+    "\n",
+    "    # set labels\n",
+    "    ax[0, 0].set_xlabel(r\"$z^*$ [mm]\")\n",
+    "    ax[0, 0].set_ylabel(r\"$t^*$ [s]\")\n",
+    "    ax[0, 0].set_title(r\"{} {}\".format(var_name, units), y=1.5)\n",
+    "    ax[0, 1].set_xlabel(r\"$z^*$ [mm]\")\n",
+    "    ax[0, 1].set_ylabel(r\"{}\".format(var_name))\n",
+    "    ax[1, 0].set_xlabel(r\"$z^*$ [mm]\")\n",
+    "    ax[1, 0].set_ylabel(\"Time-averaged\" + \"\\n\" + r\"absolute error {}\".format(units))\n",
+    "    ax[1, 1].set_xlabel(r\"$t^*$ [s]\")\n",
+    "    ax[1, 1].set_ylabel(\"Space-averaged\" + \"\\n\" + r\"absolute error {}\".format(units))\n",
+    "\n",
+    "    ax[0, 0].text(-0.1, 1.6, \"(a)\", transform=ax[0, 0].transAxes)\n",
+    "    ax[0, 1].text(-0.1, 1.6, \"(b)\", transform=ax[0, 1].transAxes)\n",
+    "    ax[1, 0].text(-0.1, 1.2, \"(c)\", transform=ax[1, 0].transAxes)\n",
+    "    ax[1, 1].text(-0.1, 1.2, \"(d)\", transform=ax[1, 1].transAxes)\n",
+    "\n",
+    "    leg1 = ax[0, 1].legend(\n",
+    "        bbox_to_anchor=(0, 1.1, 1.0, 0.102),\n",
+    "        loc=\"lower left\",\n",
+    "        borderaxespad=0.0,\n",
+    "        ncol=3,\n",
+    "        mode=\"expand\",\n",
+    "    )\n",
+    "\n",
+    "    leg2 = ax[0, 1].legend(\n",
+    "        [comsol_p, pybamm_p, dfncc_p],\n",
+    "        [\"COMSOL\", r\"$1+1$D\", \"DFNCC\"],\n",
+    "        bbox_to_anchor=(0, 1.5, 1.0, 0.102),\n",
+    "        loc=\"lower left\",\n",
+    "        borderaxespad=0.0,\n",
+    "        ncol=3,\n",
+    "        mode=\"expand\",\n",
+    "    )\n",
+    "    ax[0, 1].add_artist(leg1)\n",
+    "\n",
+    "    ax[1, 0].legend(\n",
+    "        bbox_to_anchor=(0.0, 1.1, 1.0, 0.102),\n",
+    "        loc=\"lower right\",\n",
+    "        borderaxespad=0.0,\n",
+    "        ncol=3,\n",
+    "    )\n",
+    "    ax[1, 1].legend(\n",
+    "        bbox_to_anchor=(0.0, 1.1, 1.0, 0.102),\n",
+    "        loc=\"lower right\",\n",
+    "        borderaxespad=0.0,\n",
+    "        ncol=3,\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then set up the times and points in space to use in the plots "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t_plot = comsol_t\n",
+    "z_plot = z_interp\n",
+    "t_slices = np.array([600, 1200, 1800, 2400, 3000]) / 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "and plot the negative current collector potential"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 936x504 with 5 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "var = \"Negative current collector potential [V]\"\n",
+    "comsol_var_fun = comsol_solution[var]\n",
+    "dfn_var_fun = solutions[\"1+1D DFN\"][var]\n",
+    "\n",
+    "dfncc_var_fun = dfncc_vars[var]\n",
+    "plot(\n",
+    "    t_plot,\n",
+    "    z_plot,\n",
+    "    t_slices,\n",
+    "    \"$\\phi^*_{\\mathrm{s,cn}}$\",\n",
+    "    \"[V]\",\n",
+    "    comsol_var_fun,\n",
+    "    dfn_var_fun,\n",
+    "    dfncc_var_fun,\n",
+    "    param,\n",
+    "    cmap=\"cividis\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "the positive current collector potential with respect to terminal voltage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 936x504 with 5 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "var = \"Positive current collector potential [V]\"\n",
+    "comsol_var = comsol_solution[var]\n",
+    "V_comsol = comsol_solution[\"Terminal voltage [V]\"]\n",
+    "\n",
+    "\n",
+    "def comsol_var_fun(t, z):\n",
+    "    return comsol_var(t=t, z=z) - V_comsol(t=t)\n",
+    "\n",
+    "\n",
+    "dfn_var = solutions[\"1+1D DFN\"][var]\n",
+    "V = solutions[\"1+1D DFN\"][\"Terminal voltage [V]\"]\n",
+    "\n",
+    "\n",
+    "def dfn_var_fun(t, z):\n",
+    "    return dfn_var(t=t, z=z) - V(t=t)\n",
+    "\n",
+    "\n",
+    "dfncc_var =  dfncc_vars[var]\n",
+    "V_dfncc = dfncc_vars[\"Terminal voltage [V]\"]\n",
+    "\n",
+    "def dfncc_var_fun(t, z):\n",
+    "    return dfncc_var(t=t, z=z) - V_dfncc(t)\n",
+    "\n",
+    "\n",
+    "plot(\n",
+    "    t_plot,\n",
+    "    z_plot,\n",
+    "    t_slices,\n",
+    "    \"$\\phi^*_{\\mathrm{s,cp}} - V^*$\",\n",
+    "    \"[V]\",\n",
+    "    comsol_var_fun,\n",
+    "    dfn_var_fun,\n",
+    "    dfncc_var_fun,\n",
+    "    param,\n",
+    "    cmap=\"viridis\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "the through-cell current "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 936x504 with 5 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "var = \"Current collector current density [A.m-2]\"\n",
+    "comsol_var_fun = comsol_solution[var]\n",
+    "dfn_var_fun = solutions[\"1+1D DFN\"][var]\n",
+    "\n",
+    "I_av = solutions[\"Average DFN\"][var]\n",
+    "\n",
+    "\n",
+    "def dfncc_var_fun(t, z):\n",
+    "    \"In the DFNCC the current is just the average current\"\n",
+    "    return np.transpose(np.repeat(I_av(t)[:, np.newaxis], len(z), axis=1))\n",
+    "\n",
+    "\n",
+    "plot(\n",
+    "    t_plot,\n",
+    "    z_plot,\n",
+    "    t_slices,\n",
+    "    \"$\\mathcal{I}^*$\",\n",
+    "    \"[A/m${}^2$]\",\n",
+    "    comsol_var_fun,\n",
+    "    dfn_var_fun,\n",
+    "    dfncc_var_fun,\n",
+    "    param,\n",
+    "    cmap=\"plasma\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "and the temperature with respect to reference temperature"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 936x504 with 5 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "T_ref = param.evaluate(pybamm.standard_parameters_lithium_ion.T_ref)\n",
+    "var = \"X-averaged cell temperature [K]\"\n",
+    "comsol_var = comsol_solution[var]\n",
+    "\n",
+    "\n",
+    "def comsol_var_fun(t, z):\n",
+    "    return comsol_var(t=t, z=z) - T_ref\n",
+    "\n",
+    "\n",
+    "dfn_var = solutions[\"1+1D DFN\"][var]\n",
+    "\n",
+    "\n",
+    "def dfn_var_fun(t, z):\n",
+    "    return dfn_var(t=t, z=z) - T_ref\n",
+    "\n",
+    "\n",
+    "T_av = solutions[\"Average DFN\"][var]\n",
+    "\n",
+    "\n",
+    "def dfncc_var_fun(t, z):\n",
+    "    \"In the DFNCC the temperature is just the average temperature\"\n",
+    "    return np.transpose(np.repeat(T_av(t)[:, np.newaxis], len(z), axis=1)) - T_ref\n",
+    "\n",
+    "\n",
+    "plot(\n",
+    "    t_plot,\n",
+    "    z_plot,\n",
+    "    t_slices,\n",
+    "    \"$\\\\bar{T}^* - \\\\bar{T}_0^*$\",\n",
+    "    \"[K]\",\n",
+    "    comsol_var_fun,\n",
+    "    dfn_var_fun,\n",
+    "    dfncc_var_fun,\n",
+    "    param,\n",
+    "    cmap=\"inferno\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We see that the electrical conductivity of the current collectors is sufficiently\n",
+    "high that the potentials remain fairly uniform in space, and both the 1+1D DFN and DFNCC models are able to accurately capture the potential distribution in the current collectors.\n",
+    "\n",
+    "\n",
+    "In the plot of the current we see that positioning both tabs at the top of the cell means that for most of the simulation the current preferentially travels through the upper part of the cell. Eventually, as the cell continues to discharge, this part becomes more (de)lithiated until the resultant local increase in through-cell resistance is sufficient for it to become preferential for the current to travel further along the current collectors and through the lower part of the cell. This behaviour is well captured by the 1+1D model. In the DFNCC formulation the through-cell current density is assumed uniform,\n",
+    "so the greatest error is found at the ends of the current collectors where the current density deviates most from its average.\n",
+    "\n",
+    "For the parameters used in this example we find that the temperature exhibits a relatively weak variation along the length of the current collectors.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pybamm/CITATIONS.txt b/pybamm/CITATIONS.txt
index eaee4de3ff..59cc6160c3 100644
--- a/pybamm/CITATIONS.txt
+++ b/pybamm/CITATIONS.txt
@@ -183,3 +183,13 @@ doi = "https://doi.org/10.1016/j.electacta.2020.135862",
 url = "http://www.sciencedirect.com/science/article/pii/S0013468620302541",
 author = "G. Richardson and I. Korotkin and R. Ranom and M. Castle and J.M. Foster",
 }
+
+@article{timms2020,
+title={Asymptotic Reduction of a Lithium-ion Pouch Cell Model}
+journal={Submitted for publication},
+author={R Timms and SG Marquis and V Sulzer and CP Please and SJ Chapman},
+year={2020},
+eprint={2005.05127},
+archivePrefix={arXiv},
+primaryClass={physics.app-ph},
+}
diff --git a/pybamm/__init__.py b/pybamm/__init__.py
index 6b7e7f8e56..a64cff083e 100644
--- a/pybamm/__init__.py
+++ b/pybamm/__init__.py
@@ -149,6 +149,7 @@ def version(formatted=False):
     Geometryxp1DMacro,
     Geometryxp0p1DMicro,
     Geometryxp1p1DMicro,
+    Geometry1DCurrentCollector,
     Geometry2DCurrentCollector,
 )
 
diff --git a/pybamm/geometry/geometry.py b/pybamm/geometry/geometry.py
index 5b680f4dca..f36ec6168a 100644
--- a/pybamm/geometry/geometry.py
+++ b/pybamm/geometry/geometry.py
@@ -47,6 +47,7 @@ class Geometry(dict):
                         along with the microscopic 1D particle geometry.
     - "(2+1)+1D micro": 1D macroscopic cell geometry, with 2D current collector model,
                         along with the microscopic 1D particle geometry.
+    - "1D current collector": macroscopic 1D current collector geometry
     - "2D current collector": macroscopic 2D current collector geometry
 
     **Extends**: :class:`dict`
@@ -84,6 +85,8 @@ def __init__(self, *geometries, custom_geometry={}):
                 geometry = Geometryxp1p1DMicro(cc_dimension=1)
             elif geometry == "(2+1)+1D micro":
                 geometry = Geometryxp1p1DMicro(cc_dimension=2)
+            elif geometry == "1D current collector":
+                geometry = Geometry1DCurrentCollector()
             elif geometry == "2D current collector":
                 geometry = Geometry2DCurrentCollector()
             # avoid combining geometries that clash
@@ -512,6 +515,37 @@ def __init__(self, cc_dimension=1, custom_geometry={}):
         self.update(custom_geometry)
 
 
+class Geometry1DCurrentCollector(Geometry):
+    """
+    A geometry class to store the details features of the macroscopic 1D
+    current collector geometry.
+
+    **Extends**: :class:`Geometry`
+
+    Parameters
+    ----------
+
+    custom_geometry : dict containing any extra user defined geometry
+    """
+
+    def __init__(self, custom_geometry={}):
+        super().__init__()
+        var = pybamm.standard_spatial_vars
+
+        self["current collector"] = {
+            "primary": {
+                var.z: {"min": pybamm.Scalar(0), "max": pybamm.geometric_parameters.l_z}
+            },
+            "tabs": {
+                "negative": {"z_centre": pybamm.geometric_parameters.centre_z_tab_n},
+                "positive": {"z_centre": pybamm.geometric_parameters.centre_z_tab_p},
+            },
+        }
+
+        # update with custom geometry if non empty
+        self.update(custom_geometry)
+
+
 class Geometry2DCurrentCollector(Geometry):
     """
     A geometry class to store the details features of the macroscopic 2D
diff --git a/pybamm/input/comsol_results/comsol_1plus1D_3C.pickle b/pybamm/input/comsol_results/comsol_1plus1D_3C.pickle
new file mode 100644
index 0000000000..85af9b637e
Binary files /dev/null and b/pybamm/input/comsol_results/comsol_1plus1D_3C.pickle differ
diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py
index d8bebe237f..a39e5f6c5c 100644
--- a/pybamm/models/full_battery_models/base_battery_model.py
+++ b/pybamm/models/full_battery_models/base_battery_model.py
@@ -282,11 +282,7 @@ def options(self, extra_options):
             "interstitial-diffusion limited",
         ]:
             raise pybamm.OptionError("Unknown sei model '{}'".format(options["sei"]))
-        if options["sei film resistance"] not in [
-            None,
-            "distributed",
-            "average",
-        ]:
+        if options["sei film resistance"] not in [None, "distributed", "average"]:
             raise pybamm.OptionError(
                 "Unknown sei film resistance model '{}'".format(
                     options["sei film resistance"]
@@ -294,9 +290,7 @@ def options(self, extra_options):
             )
 
         if options["dimensionality"] == 0:
-            if options["current collector"] not in [
-                "uniform",
-            ]:
+            if options["current collector"] not in ["uniform"]:
                 raise pybamm.OptionError(
                     "current collector model must be uniform in 0D model"
                 )
@@ -588,9 +582,7 @@ def set_thermal_submodel(self):
 
     def set_current_collector_submodel(self):
 
-        if self.options["current collector"] in [
-            "uniform",
-        ]:
+        if self.options["current collector"] in ["uniform"]:
             submodel = pybamm.current_collector.Uniform(self.param)
         elif self.options["current collector"] == "potential pair":
             if self.options["dimensionality"] == 1:
diff --git a/pybamm/models/submodels/current_collector/__init__.py b/pybamm/models/submodels/current_collector/__init__.py
index 1f765b4e30..40be04244d 100644
--- a/pybamm/models/submodels/current_collector/__init__.py
+++ b/pybamm/models/submodels/current_collector/__init__.py
@@ -1,7 +1,10 @@
 from .base_current_collector import BaseModel
 
 from .homogeneous_current_collector import Uniform
-from .effective_resistance_current_collector import EffectiveResistance2D
+from .effective_resistance_current_collector import (
+    EffectiveResistance,
+    AlternativeEffectiveResistance2D,
+)
 from .potential_pair import (
     BasePotentialPair,
     PotentialPair1plus1D,
diff --git a/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py b/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py
index e74fe39cb2..822f294949 100644
--- a/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py
+++ b/pybamm/models/submodels/current_collector/effective_resistance_current_collector.py
@@ -1,119 +1,351 @@
 #
-# Class for calcuting the effective resistance of two-dimensional current collectors
+# Classes for calcuting the effective resistance of current collectors in a pouch cell
 #
 import pybamm
 
 
-class EffectiveResistance2D(pybamm.BaseModel):
-    """A model which calculates the effective Ohmic resistance of the current
-    collectors in the limit of large electrical conductivity.
-    Note:  This submodel should be solved before a one-dimensional model to calculate
-    and return the effective current collector resistance.
+class EffectiveResistance(pybamm.BaseModel):
+    """
+    A model which calculates the effective Ohmic resistance of the current
+    collectors in the limit of large electrical conductivity. For details see [1]_.
+    Note that this formulation assumes uniform *potential* across the tabs. See
+    :class:`pybamm.AlternativeEffectiveResistance2D` for the formulation that
+    assumes a uniform *current density* at the tabs (in 1D the two formulations
+    are equivalent).
+
+    Parameters
+    ----------
+    options: dict
+        A dictionary of options to be passed to the model. The options that can
+        be set are listed below.
+
+            * "dimensionality" : int, optional
+                Sets the dimension of the current collector problem. Can be 1
+                (default) or 2.
+    name : str, optional
+        The name of the model.
+
+    References
+    ----------
+    .. [1] R Timms, SG Marquis, V Sulzer, CP Please and SJ Chapman. “Asymptotic
+           Reduction of a Lithium-ion Pouch Cell Model”. Submitted, 2020.
 
     **Extends:** :class:`pybamm.BaseModel`
     """
 
-    def __init__(self):
-        super().__init__()
-        self.name = "Effective resistance in current collector model"
+    def __init__(
+        self, options=None, name="Effective resistance in current collector model"
+    ):
+        super().__init__(name)
+        self.options = options
         self.param = pybamm.standard_parameters_lithium_ion
 
-        # Get useful parameters
+        self.variables = self.get_fundamental_variables()
+        self.set_algebraic(self.variables)
+        self.set_boundary_conditions(self.variables)
+        self.set_initial_conditions(self.variables)
+
+        pybamm.citations.register("timms2020")
+
+    def get_fundamental_variables(self):
+        # Get necessary parameters
         param = self.param
         l_cn = param.l_cn
         l_cp = param.l_cp
-        l_y = param.l_y
         sigma_cn_dbl_prime = param.sigma_cn_dbl_prime
         sigma_cp_dbl_prime = param.sigma_cp_dbl_prime
-        alpha_prime = param.alpha_prime
+        delta = param.delta  # aspect ratio
+
+        # Set model variables: Note: we solve using a scaled version that is
+        # better conditioned
+        R_cn_scaled = pybamm.Variable(
+            "Scaled negative current collector resistance", domain="current collector"
+        )
+        R_cp_scaled = pybamm.Variable(
+            "Scaled positive current collector resistance", domain="current collector"
+        )
+        R_cn = delta * R_cn_scaled / (l_cn * sigma_cn_dbl_prime)
+        R_cp = delta * R_cp_scaled / (l_cp * sigma_cp_dbl_prime)
+
+        # Define effective current collector resistance
+        if self.options["dimensionality"] == 1:
+            R_cc_n = -pybamm.z_average(R_cn)
+            R_cc_p = -pybamm.z_average(R_cp)
+        elif self.options["dimensionality"] == 2:
+            R_cc_n = -pybamm.yz_average(R_cn)
+            R_cc_p = -pybamm.yz_average(R_cp)
+        R_cc = R_cc_n + R_cc_p
+        R_scale = param.potential_scale / param.I_typ
+
+        variables = {
+            "Scaled negative current collector resistance": R_cn_scaled,
+            "Negative current collector resistance": R_cn,
+            "Negative current collector resistance [Ohm]": R_cn * R_scale,
+            "Scaled positive current collector resistance": R_cp_scaled,
+            "Positive current collector resistance": R_cp,
+            "Positive current collector resistance [Ohm]": R_cp * R_scale,
+            "Effective current collector resistance": R_cc,
+            "Effective current collector resistance [Ohm]": R_cc * R_scale,
+            "Effective negative current collector resistance": R_cc_n,
+            "Effective negative current collector resistance [Ohm]": R_cc_n * R_scale,
+            "Effective positive current collector resistance": R_cc_p,
+            "Effective positive current collector resistance [Ohm]": R_cc_p * R_scale,
+        }
+
+        return variables
+
+    def set_algebraic(self, variables):
+        R_cn_scaled = variables["Scaled negative current collector resistance"]
+        R_cp_scaled = variables["Scaled positive current collector resistance"]
+        self.algebraic = {
+            R_cn_scaled: pybamm.laplacian(R_cn_scaled) - pybamm.source(1, R_cn_scaled),
+            R_cp_scaled: pybamm.laplacian(R_cp_scaled) - pybamm.source(1, R_cp_scaled),
+        }
+
+    def set_boundary_conditions(self, variables):
+        R_cn_scaled = variables["Scaled negative current collector resistance"]
+        R_cp_scaled = variables["Scaled positive current collector resistance"]
+
+        if self.options["dimensionality"] == 1:
+            self.boundary_conditions = {
+                R_cn_scaled: {
+                    "negative tab": (0, "Dirichlet"),
+                    "no tab": (0, "Neumann"),
+                },
+                R_cp_scaled: {
+                    "positive tab": (0, "Dirichlet"),
+                    "no tab": (0, "Neumann"),
+                },
+            }
+        elif self.options["dimensionality"] == 2:
+            self.boundary_conditions = {
+                R_cn_scaled: {
+                    "negative tab": (0, "Dirichlet"),
+                    "positive tab": (0, "Neumann"),
+                },
+                R_cp_scaled: {
+                    "positive tab": (0, "Dirichlet"),
+                    "negative tab": (0, "Neumann"),
+                },
+            }
+
+    def set_initial_conditions(self, variables):
+        R_cn_scaled = variables["Scaled negative current collector resistance"]
+        R_cp_scaled = variables["Scaled positive current collector resistance"]
+        self.initial_conditions = {
+            R_cn_scaled: pybamm.Scalar(0),
+            R_cp_scaled: pybamm.Scalar(0),
+        }
 
-        # Set model variables
+    def post_process(self, solution, param_values, V_av, I_av):
+        """
+        Calculates the potentials in the current collector and the terminal
+        voltage given the average voltage and current.
+        Note: This takes in the *processed* V_av and I_av from a 1D simulation
+        representing the average cell behaviour and returns a dictionary of
+        processed potentials.
+        """
+        param = self.param
+        pot_scale = param_values.evaluate(param.potential_scale)
+        U_ref = param_values.evaluate(param.U_p_ref - param.U_n_ref)
+
+        # Process resistances
+        R_cn = solution["Negative current collector resistance"]
+        R_cp = solution["Positive current collector resistance"]
+        R_cc = solution["Effective current collector resistance"]
+
+        # Create callable combination of ProcessedVariable objects for potentials
+        # and terminal voltage
+        def V(t):
+            "Account for effective current collector resistance"
+            return V_av(t) - I_av(t) * R_cc(t)
+
+        def phi_s_cn(t, z, y=None):
+            return R_cn(y=y, z=z) * I_av(t=t)
+
+        def phi_s_cp(t, z, y=None):
+            return V(t) - R_cp(y=y, z=z) * I_av(t=t)
+
+        def V_cc(t, z, y=None):
+            return phi_s_cp(t, z, y=y) - phi_s_cn(t, z, y=y)
+
+        def V_dim(t):
+            return U_ref + V(t) * pot_scale
+
+        def phi_s_cn_dim(t, z, y=None):
+            return phi_s_cn(t, z, y=y) * pot_scale
+
+        def phi_s_cp_dim(t, z, y=None):
+            return U_ref + phi_s_cp(t, z, y=y) * pot_scale
+
+        def V_cc_dim(t, z, y=None):
+            return U_ref + V_cc(t, z, y=y) * pot_scale
+
+        processed_vars = {
+            "Negative current collector potential": phi_s_cn,
+            "Negative current collector potential [V]": phi_s_cn_dim,
+            "Positive current collector potential": phi_s_cp,
+            "Positive current collector potential [V]": phi_s_cp_dim,
+            "Local current collector potential difference": V_cc,
+            "Local current collector potential difference [V]": V_cc_dim,
+            "Terminal voltage": V,
+            "Terminal voltage [V]": V_dim,
+        }
+        return processed_vars
+
+    @property
+    def default_parameter_values(self):
+        return pybamm.ParameterValues(chemistry=pybamm.parameter_sets.Marquis2019)
+
+    @property
+    def default_geometry(self):
+        if self.options["dimensionality"] == 1:
+            return pybamm.Geometry("1D current collector")
+        elif self.options["dimensionality"] == 2:
+            return pybamm.Geometry("2D current collector")
+
+    @property
+    def default_var_pts(self):
         var = pybamm.standard_spatial_vars
+        return {var.y: 32, var.z: 32}
+
+    @property
+    def default_submesh_types(self):
+        if self.options["dimensionality"] == 1:
+            return {"current collector": pybamm.MeshGenerator(pybamm.Uniform1DSubMesh)}
+        elif self.options["dimensionality"] == 2:
+            return {
+                "current collector": pybamm.MeshGenerator(pybamm.ScikitUniform2DSubMesh)
+            }
+
+    @property
+    def default_spatial_methods(self):
+        if self.options["dimensionality"] == 1:
+            return {"current collector": pybamm.FiniteVolume()}
+        elif self.options["dimensionality"] == 2:
+            return {"current collector": pybamm.ScikitFiniteElement()}
+
+    @property
+    def default_solver(self):
+        return pybamm.CasadiAlgebraicSolver()
+
+    @property
+    def options(self):
+        return self._options
+
+    @options.setter
+    def options(self, extra_options):
+        default_options = {"dimensionality": 1}
+        extra_options = extra_options or {}
+
+        options = pybamm.FuzzyDict(default_options)
+        # any extra options overwrite the default options
+        for name, opt in extra_options.items():
+            if name in default_options:
+                options[name] = opt
+            else:
+                raise pybamm.OptionError(
+                    "Option '{}' not recognised. Best matches are {}".format(
+                        name, options.get_best_matches(name)
+                    )
+                )
+
+        if options["dimensionality"] not in [1, 2]:
+            raise pybamm.OptionError(
+                "Dimension of current collectors must be 1 or 2, not {}".format(
+                    options["dimensionality"]
+                )
+            )
+        self._options = options
+
+
+class AlternativeEffectiveResistance2D(pybamm.BaseModel):
+    """
+    A model which calculates the effective Ohmic resistance of the 2D current
+    collectors in the limit of large electrical conductivity. This model assumes
+    a uniform *current density* at the tabs and the solution is computed by first
+    solving and auxilliary problem which is the related to the resistances.
+
+    **Extends:** :class:`pybamm.BaseModel`
+    """
 
-        psi = pybamm.Variable(
-            "Current collector potential weighted sum", ["current collector"]
+    def __init__(self):
+        super().__init__()
+        self.name = "Effective resistance in current collector model (2D)"
+        self.param = pybamm.standard_parameters_lithium_ion
+
+        # Get necessary parameters
+        param = self.param
+        l_cn = param.l_cn
+        l_cp = param.l_cp
+        l_tab_p = param.l_tab_p
+        A_tab_p = l_cp * l_tab_p
+        sigma_cn_dbl_prime = param.sigma_cn_dbl_prime
+        sigma_cp_dbl_prime = param.sigma_cp_dbl_prime
+        delta = param.delta
+
+        # Set model variables -- we solve a auxilliary problem in each current collector
+        # then relate this to the potentials and resistances later
+        f_n = pybamm.Variable(
+            "Unit solution in negative current collector", domain="current collector"
         )
-        W = pybamm.Variable(
-            "Perturbation to current collector potential difference",
-            ["current collector"],
+        f_p = pybamm.Variable(
+            "Unit solution in positive current collector", domain="current collector"
         )
-        c_psi = pybamm.Variable("Lagrange multiplier for variable `psi`")
-        c_W = pybamm.Variable("Lagrange multiplier for variable `W`")
 
-        self.variables = {
-            "Current collector potential weighted sum": psi,
-            "Perturbation to current collector potential difference": W,
-            "Lagrange multiplier for variable `psi`": c_psi,
-            "Lagrange multiplier for variable `W`": c_W,
-        }
+        # Governing equations -- we impose that the average of f_p is zero
+        # by introducing a Lagrange multiplier
+        c = pybamm.Variable("Lagrange multiplier")
 
-        # Algebraic equations (enforce zero mean constraint through Lagrange multiplier)
-        # 0*LagrangeMultiplier hack otherwise gives KeyError
         self.algebraic = {
-            psi: pybamm.laplacian(psi)
-            + c_psi * pybamm.DefiniteIntegralVector(psi, vector_type="column"),
-            W: pybamm.laplacian(W)
-            - pybamm.source(1, W)
-            + c_W * pybamm.DefiniteIntegralVector(W, vector_type="column"),
-            c_psi: pybamm.Integral(psi, [var.y, var.z]) + 0 * c_psi,
-            c_W: pybamm.Integral(W, [var.y, var.z]) + 0 * c_W,
+            f_n: pybamm.laplacian(f_n) + pybamm.source(1, f_n),
+            c: pybamm.laplacian(f_p)
+            - pybamm.source(1, f_p)
+            + c * pybamm.DefiniteIntegralVector(f_p, vector_type="column"),
+            f_p: pybamm.yz_average(f_p) + 0 * c,
         }
 
         # Boundary conditons
-        psi_neg_tab_bc = l_cn
-        psi_pos_tab_bc = -l_cp
-        W_neg_tab_bc = l_y / (alpha_prime * sigma_cn_dbl_prime)
-        W_pos_tab_bc = l_y / (alpha_prime * sigma_cp_dbl_prime)
-
+        pos_tab_bc = l_cp / A_tab_p
         self.boundary_conditions = {
-            psi: {
-                "negative tab": (psi_neg_tab_bc, "Neumann"),
-                "positive tab": (psi_pos_tab_bc, "Neumann"),
-            },
-            W: {
-                "negative tab": (W_neg_tab_bc, "Neumann"),
-                "positive tab": (W_pos_tab_bc, "Neumann"),
+            f_n: {"negative tab": (0, "Dirichlet"), "positive tab": (0, "Neumann")},
+            f_p: {
+                "negative tab": (0, "Neumann"),
+                "positive tab": (pos_tab_bc, "Neumann"),
             },
         }
 
         # "Initial conditions" provides initial guess for solver
-        # TODO: better guess than zero?
         self.initial_conditions = {
-            psi: pybamm.Scalar(0),
-            W: pybamm.Scalar(0),
-            c_psi: pybamm.Scalar(0),
-            c_W: pybamm.Scalar(0),
+            f_n: pybamm.Scalar(0),
+            f_p: pybamm.Scalar(0),
+            c: pybamm.Scalar(0),
         }
 
         # Define effective current collector resistance
-        psi_neg_tab = pybamm.BoundaryValue(psi, "negative tab")
-        psi_pos_tab = pybamm.BoundaryValue(psi, "positive tab")
-        W_neg_tab = pybamm.BoundaryValue(W, "negative tab")
-        W_pos_tab = pybamm.BoundaryValue(W, "positive tab")
-
-        R_cc = (
-            (alpha_prime / l_y)
-            * (
-                sigma_cn_dbl_prime * l_cn * W_pos_tab
-                + sigma_cp_dbl_prime * l_cp * W_neg_tab
-            )
-            - (psi_pos_tab - psi_neg_tab)
-        ) / (sigma_cn_dbl_prime * l_cn + sigma_cp_dbl_prime * l_cp)
-
-        R_cc_dim = R_cc * param.potential_scale / param.I_typ
-
-        self.variables.update(
-            {
-                "Current collector potential weighted sum (negative tab)": psi_neg_tab,
-                "Current collector potential weighted sum (positive tab)": psi_pos_tab,
-                "Perturbation to c.c. potential difference (negative tab)": W_neg_tab,
-                "Perturbation to c.c. potential difference (positive tab)": W_pos_tab,
-                "Effective current collector resistance": R_cc,
-                "Effective current collector resistance [Ohm]": R_cc_dim,
-            }
+        R_cc_n = delta * pybamm.yz_average(f_n) / (l_cn * sigma_cn_dbl_prime)
+        R_cc_p = (
+            delta
+            * pybamm.BoundaryIntegral(f_p, "positive tab")
+            / (l_cp * sigma_cp_dbl_prime)
         )
+        R_cc = R_cc_n + R_cc_p
+        R_scale = param.potential_scale / param.I_typ
 
-    def get_processed_potentials(self, solution, param_values, V_av, I_av):
+        self.variables = {
+            "Unit solution in negative current collector": f_n,
+            "Unit solution in positive current collector": f_p,
+            "Effective current collector resistance": R_cc,
+            "Effective current collector resistance [Ohm]": R_cc * R_scale,
+            "Effective negative current collector resistance": R_cc_n,
+            "Effective negative current collector resistance [Ohm]": R_cc_n * R_scale,
+            "Effective positive current collector resistance": R_cc_p,
+            "Effective positive current collector resistance [Ohm]": R_cc_p * R_scale,
+        }
+
+        pybamm.citations.register("timms2020")
+
+    def post_process(self, solution, param_values, V_av, I_av):
         """
         Calculates the potentials in the current collector given
         the average voltage and current.
@@ -121,76 +353,62 @@ def get_processed_potentials(self, solution, param_values, V_av, I_av):
         representing the average cell behaviour and returns a dictionary of
         processed potentials.
         """
-        # Get required processed parameters
+        # Get evaluated parameters
         param = self.param
+        delta = param_values.evaluate(param.delta)
         l_cn = param_values.evaluate(param.l_cn)
         l_cp = param_values.evaluate(param.l_cp)
-        l_y = param_values.evaluate(param.l_y)
-        l_z = param_values.evaluate(param.l_z)
-        sigma_cn_prime = param_values.evaluate(param.sigma_cn_prime)
-        sigma_cp_prime = param_values.evaluate(param.sigma_cp_prime)
-        alpha = param_values.evaluate(param.alpha)
+        sigma_cn_dbl_prime = param_values.evaluate(param.sigma_cn_dbl_prime)
+        sigma_cp_dbl_prime = param_values.evaluate(param.sigma_cp_dbl_prime)
         pot_scale = param_values.evaluate(param.potential_scale)
         U_ref = param_values.evaluate(param.U_p_ref - param.U_n_ref)
 
-        # Process psi and W, and their (average) values at the negative tab
-        psi = solution["Current collector potential weighted sum"]
-        W = solution["Perturbation to current collector potential difference"]
-        psi_neg_tab = self.variables[
-            "Current collector potential weighted sum (negative tab)"
-        ].evaluate(y=solution.y[:, 0])[0][0]
-        W_neg_tab = self.variables[
-            "Perturbation to c.c. potential difference (negative tab)"
-        ].evaluate(y=solution.y[:, 0])[0][0]
+        # Process unit solutions
+        f_n = solution["Unit solution in negative current collector"]
+        f_p = solution["Unit solution in positive current collector"]
+
+        # Get effective resistance
+        R_cc = solution["Effective current collector resistance"]
 
         # Create callable combination of ProcessedVariable objects for potentials
-        def V_cc(t, y, z):
-            return V_av(t) - alpha * I_av(t) * W(y=y, z=z)
+        def V(t):
+            "Account for effective current collector resistance"
+            return V_av(t) - I_av(t) * R_cc(t)
 
-        def V_cc_dim(t, y, z):
-            return U_ref + V_cc(t, y, z) * pot_scale
+        def phi_s_cn(t, y, z):
+            return -(delta * I_av(t=t) / l_cn / sigma_cn_dbl_prime) * f_n(y=y, z=z)
 
-        denominator = sigma_cn_prime * l_cn + sigma_cn_prime * l_cp
+        def phi_s_cp(t, y, z):
+            return V(t) + (delta * I_av(t=t) / l_cp / sigma_cp_dbl_prime) * f_p(
+                y=y, z=z
+            )
 
-        # The method only defines psi up to an arbitrary function of time. This
-        # is fixed by ensuring phi_s_cn = 0 on the negative tab when reconstructing
-        # the potentials
-        def phi_s_cn_tab(t):
-            phi_s_cn_tab = (
-                I_av(t) * l_y * l_z * psi_neg_tab
-                - sigma_cp_prime * l_cp * (V_av(t) - alpha * I_av(t) * W_neg_tab)
-            ) / denominator
-            return phi_s_cn_tab
+        def V_cc(t, y, z):
+            return phi_s_cp(t, y, z) - phi_s_cn(t, y, z)
 
-        def phi_s_cn(t, y, z):
-            phi_s_cn = (
-                I_av(t) * l_y * l_z * psi(y=y, z=z)
-                - sigma_cp_prime * l_cp * V_cc(t, y, z)
-            ) / denominator
-            return phi_s_cn - phi_s_cn_tab(t)
+        def V_dim(t):
+            return U_ref + V(t) * pot_scale
 
         def phi_s_cn_dim(t, y, z):
             return phi_s_cn(t, y, z) * pot_scale
 
-        def phi_s_cp(t, y, z):
-            phi_s_cp = (
-                I_av(t) * l_y * l_z * psi(y=y, z=z)
-                + sigma_cn_prime * l_cn * V_cc(t, y, z)
-            ) / denominator
-            return phi_s_cp - phi_s_cn_tab(t)
-
         def phi_s_cp_dim(t, y, z):
             return U_ref + phi_s_cp(t, y, z) * pot_scale
 
-        potentials = {
+        def V_cc_dim(t, y, z):
+            return U_ref + V_cc(t, y, z) * pot_scale
+
+        processed_vars = {
             "Negative current collector potential": phi_s_cn,
             "Negative current collector potential [V]": phi_s_cn_dim,
             "Positive current collector potential": phi_s_cp,
             "Positive current collector potential [V]": phi_s_cp_dim,
-            "Local voltage": V_cc,
-            "Local voltage [V]": V_cc_dim,
+            "Local current collector potential difference": V_cc,
+            "Local current collector potential difference [V]": V_cc_dim,
+            "Terminal voltage": V,
+            "Terminal voltage [V]": V_dim,
         }
-        return potentials
+        return processed_vars
 
     @property
     def default_parameter_values(self):
diff --git a/pybamm/models/submodels/current_collector/potential_pair.py b/pybamm/models/submodels/current_collector/potential_pair.py
index f7addb7086..1eecdb80d6 100644
--- a/pybamm/models/submodels/current_collector/potential_pair.py
+++ b/pybamm/models/submodels/current_collector/potential_pair.py
@@ -17,7 +17,7 @@ class BasePotentialPair(BaseModel):
     References
     ----------
     .. [1] R Timms, SG Marquis, V Sulzer, CP Please and SJ Chapman. “Asymptotic
-           Reduction of a Lithium-ion Pouch Cell Model”. In preparation, 2020.
+           Reduction of a Lithium-ion Pouch Cell Model”. Submitted, 2020.
     .. [2] SG Marquis, R Timms, V Sulzer, CP Please and SJ Chapman. “A Suite of
            Reduced-Order Models of a Single-Layer Lithium-ion Pouch Cell”. In
            preparation, 2020.
@@ -28,6 +28,8 @@ class BasePotentialPair(BaseModel):
     def __init__(self, param):
         super().__init__(param)
 
+        pybamm.citations.register("timms2020")
+
     def get_fundamental_variables(self):
 
         phi_s_cn = pybamm.standard_variables.phi_s_cn
diff --git a/pybamm/simulation.py b/pybamm/simulation.py
index 7d7374ab52..e32421b186 100644
--- a/pybamm/simulation.py
+++ b/pybamm/simulation.py
@@ -450,10 +450,10 @@ def solve(
                 ):
                     pybamm.logger.warning(
                         "\n\n\tExperiment is infeasible: '{}' ".format(
-                            self._solution.termination,
+                            self._solution.termination
                         )
                         + "was triggered during '{}'. ".format(
-                            self.experiment.operating_conditions_strings[idx],
+                            self.experiment.operating_conditions_strings[idx]
                         )
                         + "Try reducing current, shortening the time interval, "
                         "or reducing the period.\n\n"
diff --git a/pybamm/solvers/base_solver.py b/pybamm/solvers/base_solver.py
index a8cc53eacd..ad34a98ff6 100644
--- a/pybamm/solvers/base_solver.py
+++ b/pybamm/solvers/base_solver.py
@@ -591,7 +591,7 @@ def solve(self, model, t_eval=None, external_variables=None, inputs=None):
                 model.y0 = last_state
                 if len(model.algebraic) > 0:
                     model.y0 = self.calculate_consistent_state(
-                        model, t_eval_dimensionless[end_index], ext_and_inputs,
+                        model, t_eval_dimensionless[end_index], ext_and_inputs
                     )
 
         # restore old y0
diff --git a/pybamm/solvers/processed_variable.py b/pybamm/solvers/processed_variable.py
index e36ff46701..9133a6e3dd 100644
--- a/pybamm/solvers/processed_variable.py
+++ b/pybamm/solvers/processed_variable.py
@@ -64,10 +64,38 @@ def __init__(self, base_variable, solution, known_evals=None):
         # check variable shape
         else:
             if len(solution.t) == 1:
-                raise pybamm.SolverError(
-                    "Solution time vector must have length > 1. Check whether "
-                    "simulation terminated too early."
-                )
+                # Implementing a workaround for 0D and 1D variables. Processing
+                # variables that are functions of space only needs to be implemented
+                # properly, see #1006
+                if (
+                    isinstance(self.base_eval, numbers.Number)
+                    or len(self.base_eval.shape) == 0
+                    or self.base_eval.shape[0] == 1
+                ):
+                    # Scalar value
+                    t = self.t_sol
+                    u = self.u_sol
+                    inputs = {name: inp[0] for name, inp in self.inputs.items()}
+
+                    entries = self.base_variable.evaluate(t, u, inputs=inputs)
+
+                    def fun(t):
+                        return entries
+
+                    self._interpolation_function = fun
+                    self.entries = entries
+                    self.dimensions = 0
+                else:
+                    # 1D function of space only
+                    n = self.mesh[0].npts
+                    base_shape = self.base_eval.shape[0]
+                    if base_shape in [n, n + 1]:
+                        self.initialise_1D(fixed_t=True)
+                    else:
+                        raise pybamm.SolverError(
+                            "Solution time vector must have length > 1. Check whether "
+                            "simulation terminated too early."
+                        )
             elif (
                 isinstance(self.base_eval, numbers.Number)
                 or len(self.base_eval.shape) == 0
@@ -120,7 +148,7 @@ def initialise_0D(self):
         self.entries = entries
         self.dimensions = 0
 
-    def initialise_1D(self):
+    def initialise_1D(self, fixed_t=False):
         len_space = self.base_eval.shape[0]
         entries = np.empty((len_space, len(self.t_sol)))
 
@@ -181,10 +209,21 @@ def initialise_1D(self):
 
         # set up interpolation
         # note that the order of 't' and 'space' is the reverse of what you'd expect
+        # TODO: fix processing when variable is a function of space only
+        if fixed_t:
+            # Hack for 1D space only
+            interpolant = interp.interp1d(
+                space, entries_for_interp[:, 0], kind="linear", fill_value=np.nan
+            )
 
-        self._interpolation_function = interp.interp2d(
-            self.t_sol, space, entries_for_interp, kind="linear", fill_value=np.nan
-        )
+            def interp_fun(t, z):
+                return interpolant(z)[:, np.newaxis]
+
+            self._interpolation_function = interp_fun
+        else:
+            self._interpolation_function = interp.interp2d(
+                self.t_sol, space, entries_for_interp, kind="linear", fill_value=np.nan
+            )
 
     def initialise_2D(self):
         """
diff --git a/tests/unit/test_citations.py b/tests/unit/test_citations.py
index 39ed2da20c..e7774c34b5 100644
--- a/tests/unit/test_citations.py
+++ b/tests/unit/test_citations.py
@@ -74,6 +74,25 @@ def test_sulzer_2019(self):
         pybamm.lead_acid.Full(build=False)
         self.assertIn("sulzer2019physical", citations._papers_to_cite)
 
+    def test_timms_2020(self):
+        # Test that calling relevant bits of code adds the right paper to citations
+        citations = pybamm.citations
+
+        citations._reset()
+        self.assertNotIn("timms2020", citations._papers_to_cite)
+        pybamm.current_collector.BasePotentialPair(param=None)
+        self.assertIn("timms2020", citations._papers_to_cite)
+
+        citations._reset()
+        self.assertNotIn("timms2020", citations._papers_to_cite)
+        pybamm.current_collector.EffectiveResistance()
+        self.assertIn("timms2020", citations._papers_to_cite)
+
+        citations._reset()
+        self.assertNotIn("timms2020", citations._papers_to_cite)
+        pybamm.current_collector.AlternativeEffectiveResistance2D()
+        self.assertIn("timms2020", citations._papers_to_cite)
+
     def test_scikit_fem(self):
         citations = pybamm.citations
 
diff --git a/tests/unit/test_geometry/test_geometry.py b/tests/unit/test_geometry/test_geometry.py
index eff357b31b..f60c72ed90 100644
--- a/tests/unit/test_geometry/test_geometry.py
+++ b/tests/unit/test_geometry/test_geometry.py
@@ -299,6 +299,33 @@ def test_combine_geometries_strings(self):
         )
 
 
+class TestGeometry1DCurrentCollector(unittest.TestCase):
+    def test_add_custom_geometry(self):
+        geometry = pybamm.Geometry1DCurrentCollector()
+        whole_cell = ["negative electrode", "separator", "positive electrode"]
+        x = pybamm.SpatialVariable("x", whole_cell)
+        custom_geometry = {
+            "negative electrode": {
+                "primary": {x: {"min": pybamm.Scalar(1), "max": pybamm.Scalar(2)}}
+            }
+        }
+
+        geometry.update(custom_geometry)
+        self.assertEqual(
+            geometry["negative electrode"], custom_geometry["negative electrode"]
+        )
+
+    def test_geometry_keys(self):
+        geometry = pybamm.Geometry1DCurrentCollector()
+        for prim_sec_vars in geometry.values():
+            for spatial_vars in prim_sec_vars.values():
+                all(
+                    self.assertIsInstance(spatial_var, pybamm.SpatialVariable)
+                    for spatial_var in spatial_vars.keys()
+                    if spatial_var not in ["negative", "positive"]
+                )
+
+
 class TestGeometry2DCurrentCollector(unittest.TestCase):
     def test_add_custom_geometry(self):
         geometry = pybamm.Geometry2DCurrentCollector()
diff --git a/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py b/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py
index 66a17b5a1c..9169fa7008 100644
--- a/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py
+++ b/tests/unit/test_models/test_submodels/test_current_collector/test_effective_current_collector.py
@@ -1,31 +1,50 @@
 #
-# Tests for the Effective Current Collector Resistance model
+# Tests for the Effective Current Collector Resistance models
 #
 import pybamm
 import unittest
 import numpy as np
 
 
-class TestEffectiveResistance2D(unittest.TestCase):
+class TestEffectiveResistance(unittest.TestCase):
     def test_well_posed(self):
-        model = pybamm.current_collector.EffectiveResistance2D()
+        model = pybamm.current_collector.EffectiveResistance({"dimensionality": 1})
+        model.check_well_posedness()
+
+        model = pybamm.current_collector.EffectiveResistance({"dimensionality": 2})
         model.check_well_posedness()
 
     def test_default_geometry(self):
-        model = pybamm.current_collector.EffectiveResistance2D()
+        model = pybamm.current_collector.EffectiveResistance({"dimensionality": 1})
+        self.assertIsInstance(model.default_geometry, pybamm.Geometry)
+        self.assertTrue("current collector" in model.default_geometry)
+        self.assertNotIn("negative electrode", model.default_geometry)
+
+        model = pybamm.current_collector.EffectiveResistance({"dimensionality": 2})
         self.assertIsInstance(model.default_geometry, pybamm.Geometry)
         self.assertTrue("current collector" in model.default_geometry)
         self.assertNotIn("negative electrode", model.default_geometry)
 
     def test_default_solver(self):
-        model = pybamm.current_collector.EffectiveResistance2D()
+        model = pybamm.current_collector.EffectiveResistance({"dimensionality": 1})
         self.assertIsInstance(model.default_solver, pybamm.CasadiAlgebraicSolver)
 
-    def test_get_processed_potentials(self):
-        # solve cheap SPM to test processed potentials (think of an alternative test?)
+        model = pybamm.current_collector.EffectiveResistance({"dimensionality": 2})
+        self.assertIsInstance(model.default_solver, pybamm.CasadiAlgebraicSolver)
+
+    def test_bad_option(self):
+        with self.assertRaisesRegex(pybamm.OptionError, "Dimension of"):
+            pybamm.current_collector.EffectiveResistance({"dimensionality": 10})
+
+
+class TestEffectiveResistancePostProcess(unittest.TestCase):
+    def test_get_processed_variables(self):
+        # solve cheap SPM to test post-processing (think of an alternative test?)
         models = [
-            pybamm.current_collector.EffectiveResistance2D(),
             pybamm.lithium_ion.SPM(),
+            pybamm.current_collector.EffectiveResistance({"dimensionality": 1}),
+            pybamm.current_collector.EffectiveResistance({"dimensionality": 2}),
+            pybamm.current_collector.AlternativeEffectiveResistance2D(),
         ]
         var = pybamm.standard_spatial_vars
         var_pts = {
@@ -37,7 +56,7 @@ def test_get_processed_potentials(self):
             var.y: 5,
             var.z: 5,
         }
-        param = models[1].default_parameter_values
+        param = models[0].default_parameter_values
         meshes = [None] * len(models)
         for i, model in enumerate(models):
             param.process_model(model)
@@ -46,19 +65,23 @@ def test_get_processed_potentials(self):
             meshes[i] = pybamm.Mesh(geometry, model.default_submesh_types, var_pts)
             disc = pybamm.Discretisation(meshes[i], model.default_spatial_methods)
             disc.process_model(model)
-        solutions = [None] * len(models)
         t_eval = np.linspace(0, 100, 10)
-        solutions[0] = models[0].default_solver.solve(models[0])
-        solutions[1] = models[1].default_solver.solve(models[1], t_eval)
-
+        solution_1D = models[0].default_solver.solve(models[0], t_eval)
         # Process SPM V and I
-        V = solutions[1]["Terminal voltage"]
-        I = solutions[1]["Total current density"]
+        V = solution_1D["Terminal voltage"]
+        I = solution_1D["Total current density"]
 
         # Test potential can be constructed and evaluated without raising error
-        potentials = models[0].get_processed_potentials(solutions[0], param, V, I)
-        for var, processed_var in potentials.items():
-            processed_var(0.05, 0.5, 0.5)
+        # for each current collector model
+        for model in models[1:]:
+            solution = model.default_solver.solve(model)
+            vars = model.post_process(solution, param, V, I)
+            pts = np.array([0.1, 0.5, 0.9])
+            for var, processed_var in vars.items():
+                if "Terminal voltage" in var:
+                    processed_var(t=solution_1D.t[5])
+                else:
+                    processed_var(t=solution_1D.t[5], y=pts, z=pts)
 
 
 if __name__ == "__main__":
diff --git a/tests/unit/test_solvers/test_processed_variable.py b/tests/unit/test_solvers/test_processed_variable.py
index 224fe24d22..d9e6a1a500 100644
--- a/tests/unit/test_solvers/test_processed_variable.py
+++ b/tests/unit/test_solvers/test_processed_variable.py
@@ -520,11 +520,12 @@ def test_call_failure(self):
 
     def test_solution_too_short(self):
         t = pybamm.t
-        y = pybamm.StateVector(slice(0, 1))
+        y = pybamm.StateVector(slice(0, 3))
         var = t * y
-        var.mesh = None
+        disc = tests.get_2p1d_discretisation_for_testing()
+        var.mesh = disc.mesh["current collector"]
         t_sol = np.array([1])
-        y_sol = np.array([np.linspace(0, 5)])
+        y_sol = np.linspace(0, 5)[:, np.newaxis]
         with self.assertRaisesRegex(
             pybamm.SolverError, "Solution time vector must have length > 1"
         ):