Repository: pybamm-team/PyBaMM

Issue:
Allow custom experiment steps
The logic for specifying how experiment steps work is currently in the `Simulation` class. We should move this to the `Step` classes, so that users can specify any custom behavior they want for which variable controls the step, and which variable(s) are used in the termination. This will have the added benefit of reducing some of the complexity of the simulation class.

This involves replacing any if statement that checks `op.type` with a call to a function in the step class, e.g. https://github.com/pybamm-team/PyBaMM/blob/develop/pybamm/simulation.py#L222 

Discussion:

Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17bd234ca..4f91e5aed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@
 
 ## Features
 
+- Added custom experiment steps ([#3835](https://github.com/pybamm-team/PyBaMM/pull/3835))
 - Added support for macOS arm64 (M-series) platforms. ([#3789](https://github.com/pybamm-team/PyBaMM/pull/3789))
 - Added the ability to specify a custom solver tolerance in `get_initial_stoichiometries` and related functions ([#3714](https://github.com/pybamm-team/PyBaMM/pull/3714))
 - Modified `step` function to take an array of time `t_eval` as an argument and deprecated use of `npts`. ([#3627](https://github.com/pybamm-team/PyBaMM/pull/3627))
diff --git a/benchmarks/different_model_options.py b/benchmarks/different_model_options.py
index a4cf787ad..72767e9f6 100644
--- a/benchmarks/different_model_options.py
+++ b/benchmarks/different_model_options.py
@@ -5,13 +5,13 @@ import numpy as np
 
 def compute_discretisation(model, param):
     var_pts = {
-        pybamm.standard_spatial_vars.x_n: 20,
-        pybamm.standard_spatial_vars.x_s: 20,
-        pybamm.standard_spatial_vars.x_p: 20,
-        pybamm.standard_spatial_vars.r_n: 30,
-        pybamm.standard_spatial_vars.r_p: 30,
-        pybamm.standard_spatial_vars.y: 10,
-        pybamm.standard_spatial_vars.z: 10,
+        "x_n": 20,
+        "x_s": 20,
+        "x_p": 20,
+        "r_n": 30,
+        "r_p": 30,
+        "y": 10,
+        "z": 10,
     }
     geometry = model.default_geometry
     param.process_geometry(geometry)
diff --git a/docs/source/api/experiment/experiment_steps.rst b/docs/source/api/experiment/experiment_steps.rst
index 61d800d92..ca26b02a4 100644
--- a/docs/source/api/experiment/experiment_steps.rst
+++ b/docs/source/api/experiment/experiment_steps.rst
@@ -16,7 +16,18 @@ The following functions can be used to define steps in an experiment. Note that
 These functions return the following step class, which is not intended to be used
 directly:
 
-.. autoclass:: pybamm.step._Step
+.. autoclass:: pybamm.step.BaseStep
+    :members:
+
+Custom steps
+------------
+
+Custom steps can be defined using either explicit or implicit control:
+
+.. autoclass:: pybamm.step.CustomStepExplicit
+    :members:
+
+.. autoclass:: pybamm.step.CustomStepImplicit
     :members:
 
 Step terminations
diff --git a/docs/source/examples/notebooks/models/loss_of_active_materials.ipynb b/docs/source/examples/notebooks/models/loss_of_active_materials.ipynb
index 127763ec3..e849c14f5 100644
--- a/docs/source/examples/notebooks/models/loss_of_active_materials.ipynb
+++ b/docs/source/examples/notebooks/models/loss_of_active_materials.ipynb
@@ -22,13 +22,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'cite'\u001b[0m\u001b[33m\n",
-      "\u001b[0m\u001b[33mWARNING: pybamm 23.5 does not provide the extra 'plot'\u001b[0m\u001b[33m\n",
-      "\u001b[0m\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
       "Note: you may need to restart the kernel to use updated packages.\n"
      ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "At t = 57.3387, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3387 and h = 7.05477e-15, the corrector convergence failed repeatedly or with |h| = hmin.\n",
+      "At t = 57.3387, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3387, , mxstep steps taken before reaching tout.\n"
+     ]
     }
    ],
    "source": [
@@ -46,7 +51,6 @@
     "param = pybamm.ParameterValues(\"Ai2020\")\n",
     "param.update({\"Negative electrode LAM constant proportional term [s-1]\": 1e-4 / 3600})\n",
     "param.update({\"Positive electrode LAM constant proportional term [s-1]\": 1e-4 / 3600})\n",
-    "total_cycles = 2\n",
     "experiment = pybamm.Experiment(\n",
     "    [\n",
     "        \"Discharge at 1C until 3 V\",\n",
@@ -54,13 +58,11 @@
     "        \"Charge at 1C until 4.2 V\",\n",
     "        \"Hold at 4.199 V for 600 seconds\",\n",
     "    ]\n",
-    "    * total_cycles\n",
     ")\n",
     "sim = pybamm.Simulation(\n",
     "    model,\n",
     "    experiment=experiment,\n",
     "    parameter_values=param,\n",
-    "    solver=pybamm.CasadiSolver(\"fast with events\"),\n",
     ")\n",
     "solution = sim.solve(calc_esoh=False)"
    ]
@@ -80,12 +82,12 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3558ac2f7db145baadec9a28e236483e",
+       "model_id": "d3d8dcb00eb7421a83a4655bfd8e1245",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "interactive(children=(FloatSlider(value=0.0, description='t', max=4.5113500706445695, step=0.04511350070644569…"
+       "interactive(children=(FloatSlider(value=0.0, description='t', max=2.329196798170269, step=0.02329196798170269)…"
       ]
      },
      "metadata": {},
@@ -94,7 +96,7 @@
     {
      "data": {
       "text/plain": [
-       "<pybamm.plotting.quick_plot.QuickPlot at 0x7f91cc5d2d00>"
+       "<pybamm.plotting.quick_plot.QuickPlot at 0x169320050>"
       ]
      },
      "execution_count": 2,
@@ -129,15 +131,33 @@
    "execution_count": 3,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "At t = 57.3387, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3387 and h = 7.05477e-15, the corrector convergence failed repeatedly or with |h| = hmin.\n",
+      "At t = 57.3387, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3387, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3307, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3307, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3307, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.3307, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.2504, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.2504, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.2504, , mxstep steps taken before reaching tout.\n",
+      "At t = 57.2504, , mxstep steps taken before reaching tout.\n"
+     ]
+    },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9ff0e45a0c8c47b2b8d21da91b6110c1",
+       "model_id": "6e6d0630770b475893301455ac4910c7",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "interactive(children=(FloatSlider(value=0.0, description='t', max=4.5113500706445695, step=0.04511350070644569…"
+       "interactive(children=(FloatSlider(value=0.0, description='t', max=2.329196798170269, step=0.02329196798170269)…"
       ]
      },
      "metadata": {},
@@ -146,7 +166,7 @@
     {
      "data": {
       "text/plain": [
-       "<pybamm.plotting.quick_plot.QuickPlot at 0x7f9179084910>"
+       "<pybamm.plotting.quick_plot.QuickPlot at 0x175c86c10>"
       ]
      },
      "execution_count": 3,
@@ -166,7 +186,6 @@
     "        model,\n",
     "        experiment=experiment,\n",
     "        parameter_values=param,\n",
-    "        solver=pybamm.CasadiSolver(\"fast with events\"),\n",
     "    )\n",
     "    solution = sim.solve(calc_esoh=False)\n",
     "    solutions.append(solution)\n",
@@ -204,12 +223,12 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "53f5eacbb94b4ae29acee57db4bf7785",
+       "model_id": "979c0f154595488da4fab0bd7cd66565",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "interactive(children=(FloatSlider(value=0.0, description='t', max=3.5075529064499813, step=0.03507552906449981…"
+       "interactive(children=(FloatSlider(value=0.0, description='t', max=1.8531299069255607, step=0.01853129906925560…"
       ]
      },
      "metadata": {},
@@ -218,7 +237,7 @@
     {
      "data": {
       "text/plain": [
-       "<pybamm.plotting.quick_plot.QuickPlot at 0x7f91cc77d9a0>"
+       "<pybamm.plotting.quick_plot.QuickPlot at 0x2846e3b90>"
       ]
      },
      "execution_count": 4,
@@ -234,21 +253,7 @@
     "    }\n",
     ")\n",
     "param = pybamm.ParameterValues(\"Chen2020\")\n",
-    "param.update(\n",
-    "    {\n",
-    "        \"Negative electrode reaction-driven LAM factor [m3.mol-1]\": 1e-3,\n",
-    "    }\n",
-    ")\n",
-    "total_cycles = 2\n",
-    "experiment = pybamm.Experiment(\n",
-    "    [\n",
-    "        \"Discharge at 1C until 3 V\",\n",
-    "        \"Rest for 600 seconds\",\n",
-    "        \"Charge at 1C until 4.2 V\",\n",
-    "        \"Hold at 4.199 V for 600 seconds\",\n",
-    "    ]\n",
-    "    * total_cycles\n",
-    ")\n",
+    "param.update({\"Negative electrode reaction-driven LAM factor [m3.mol-1]\": 1e-3})\n",
     "sim = pybamm.Simulation(\n",
     "    model,\n",
     "    experiment=experiment,\n",
@@ -293,12 +298,12 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "15acf6373f874463ba95de522d12fc89",
+       "model_id": "42f77d86732043a795b8c3264fd755bc",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "interactive(children=(FloatSlider(value=0.0, description='t', max=3.4962610293431426, step=0.03496261029343142…"
+       "interactive(children=(FloatSlider(value=0.0, description='t', max=1.8506642114311478, step=0.01850664211431147…"
       ]
      },
      "metadata": {},
@@ -307,7 +312,7 @@
     {
      "data": {
       "text/plain": [
-       "<pybamm.plotting.quick_plot.QuickPlot at 0x7f9170283dc0>"
+       "<pybamm.plotting.quick_plot.QuickPlot at 0x2852402d0>"
       ]
      },
      "execution_count": 5,
@@ -333,16 +338,6 @@
     "    },\n",
     "    check_already_exists=False,\n",
     ")\n",
-    "total_cycles = 2\n",
-    "experiment = pybamm.Experiment(\n",
-    "    [\n",
-    "        \"Discharge at 1C until 3 V\",\n",
-    "        \"Rest for 600 seconds\",\n",
-    "        \"Charge at 1C until 4.2 V\",\n",
-    "        \"Hold at 4.199 V for 600 seconds\",\n",
-    "    ]\n",
-    "    * total_cycles\n",
-    ")\n",
     "sim = pybamm.Simulation(\n",
     "    model,\n",
     "    experiment=experiment,\n",
@@ -395,6 +390,13 @@
    "source": [
     "pybamm.print_citations()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/source/examples/notebooks/simulations_and_experiments/custom-experiments.ipynb b/docs/source/examples/notebooks/simulations_and_experiments/custom-experiments.ipynb
index 4dfa8c8c7..b77ceec3c 100644
--- a/docs/source/examples/notebooks/simulations_and_experiments/custom-experiments.ipynb
+++ b/docs/source/examples/notebooks/simulations_and_experiments/custom-experiments.ipynb
@@ -25,15 +25,6 @@
     "import pybamm"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Custom steps\n",
-    "\n",
-    "This feature is in development"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -52,7 +43,7 @@
     {
      "data": {
       "text/plain": [
-       "<pybamm.solvers.solution.Solution at 0x11fcd1e10>"
+       "<pybamm.solvers.solution.Solution at 0x16b7c6310>"
       ]
      },
      "execution_count": 2,
@@ -115,7 +106,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.lines.Line2D at 0x16e37f9d0>"
+       "<matplotlib.lines.Line2D at 0x175d20150>"
       ]
      },
      "execution_count": 3,
@@ -124,7 +115,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x400 with 3 Axes>"
       ]
@@ -136,12 +127,7 @@
    "source": [
     "# Plot\n",
     "plot = pybamm.QuickPlot(\n",
-    "    sim.solution,\n",
-    "    [\n",
-    "        \"Current [A]\",\n",
-    "        \"Voltage [V]\",\n",
-    "        \"Anode potential [V]\",\n",
-    "    ],\n",
+    "    sim.solution, [\"Current [A]\", \"Voltage [V]\", \"Anode potential [V]\"]\n",
     ")\n",
     "plot.plot(0)\n",
     "\n",
@@ -178,10 +164,268 @@
     "    print(f\"Step {i}: {step.termination}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Custom steps\n",
+    "\n",
+    "Custom steps can be defined using either explicit or implicit control. In explicit control, the user specifies the current explicitly as a function of other variables in the model. "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def custom_step_power(variables):\n",
+    "    target_power = 4\n",
+    "    voltage = variables[\"Voltage [V]\"]\n",
+    "    return target_power / voltage\n",
+    "\n",
+    "\n",
+    "# Run for 10 minutes and plot\n",
+    "step = pybamm.step.CustomStepExplicit(custom_step_power, duration=600)\n",
+    "sol = pybamm.Simulation(\n",
+    "    model, experiment=step, parameter_values=parameter_values\n",
+    ").solve()\n",
+    "pybamm.QuickPlot(sol, [\"Current [A]\", \"Voltage [V]\", \"Power [W]\"]).plot(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For custom steps to work with voltage-based termination, we have to specify whether the step is a charge or discharge step. This is done by setting the `direction` attribute of the step to either \"charge\" or \"discharge\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "step = pybamm.step.CustomStepExplicit(\n",
+    "    custom_step_power, termination=\"2.5V\", direction=\"discharge\"\n",
+    ")\n",
+    "sol = pybamm.Simulation(\n",
+    "    model, experiment=step, parameter_values=parameter_values\n",
+    ").solve()\n",
+    "pybamm.QuickPlot(sol, [\"Current [A]\", \"Voltage [V]\", \"Power [W]\"]).plot(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Be careful not to create an expression that depends on the current itself, as this will lead to a circular dependency. For example, in some models, the voltage is an explicit function of the current, so the user should not create a step that depends on the voltage. An expression that works for one model may not work for another."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also specify a custom step using implicit control. This comes with \"algebraic\" or \"differential\" control. In algebraic control (the default), the user specifies the equation that must be satisfied at all times, and the model adjusts the current to satisfy this equation. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def constant_voltage(variables):\n",
+    "    return variables[\"Voltage [V]\"] - 3.8\n",
+    "\n",
+    "\n",
+    "step = pybamm.step.CustomStepImplicit(constant_voltage, duration=600)\n",
+    "sol = pybamm.Simulation(\n",
+    "    model, experiment=step, parameter_values=parameter_values\n",
+    ").solve()\n",
+    "pybamm.QuickPlot(sol, [\"Current [A]\", \"Voltage [V]\"]).plot(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In differential control, the user specifies the derivative of the current."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def custom_voltage(variables):\n",
+    "    return 100 * (variables[\"Voltage [V]\"] - 3.8)\n",
+    "\n",
+    "\n",
+    "step = pybamm.step.CustomStepImplicit(\n",
+    "    custom_voltage, duration=600, period=10, control=\"differential\"\n",
+    ")\n",
+    "sol = pybamm.Simulation(model, experiment=step).solve()\n",
+    "pybamm.QuickPlot(sol, [\"Current [A]\", \"Voltage [V]\"]).plot(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Combining custom steps and termination\n",
+    "\n",
+    "We now show a full example combining custom steps and termination to charge a battery until the anode potential reaches 0.02V, then ride the 0.02V plateau until the voltage reaches the cut-off voltage, then finish charging with constant voltage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Create a function for the anode potential cut-off at 0.02V\n",
+    "def anode_potential_cutoff(variables):\n",
+    "    return variables[\"Anode potential [V]\"] - 0.02\n",
+    "\n",
+    "\n",
+    "# We can reuse the same function to create both the termination event and the step\n",
+    "anode_potential_step = pybamm.step.CustomStepImplicit(\n",
+    "    anode_potential_cutoff, direction=\"charge\", termination=\"4.2V\"\n",
+    ")\n",
+    "anode_potential_termination = pybamm.step.CustomTermination(\n",
+    "    name=\"Anode potential cut-off [V]\", event_function=anode_potential_cutoff\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# Charge with constant current, then constant anode potential, then constant voltage\n",
+    "def run_experiment(c_rate):\n",
+    "    # Create the experiment\n",
+    "    experiment = pybamm.Experiment(\n",
+    "        [\n",
+    "            (\n",
+    "                # include the 4.2V termination event in case the anode potential cut-off is not reached\n",
+    "                pybamm.step.c_rate(\n",
+    "                    -c_rate, termination=[anode_potential_termination, \"4.2V\"]\n",
+    "                ),\n",
+    "                anode_potential_step,\n",
+    "                \"Hold at 4.2V until C/50\",\n",
+    "            )\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    sim = pybamm.Simulation(\n",
+    "        model, parameter_values=parameter_values, experiment=experiment\n",
+    "    )\n",
+    "\n",
+    "    # for a charge we start as SOC 0\n",
+    "    sim.solve(initial_soc=0)\n",
+    "\n",
+    "    # Plot\n",
+    "    pybamm.QuickPlot(\n",
+    "        sim.solution, [\"Current [A]\", \"Voltage [V]\", \"Anode potential [V]\"]\n",
+    "    ).plot(0)\n",
+    "\n",
+    "\n",
+    "run_experiment(c_rate=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we never hit the anode potential cut-off, that step is skipped and we go straight to constant voltage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x400 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "run_experiment(c_rate=0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "The relevant papers for this notebook are:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -191,10 +435,11 @@
       "[2] Chang-Hui Chen, Ferran Brosa Planella, Kieran O'Regan, Dominika Gastol, W. Dhammika Widanage, and Emma Kendrick. Development of Experimental Techniques for Parameterization of Multi-scale Lithium-ion Battery Models. Journal of The Electrochemical Society, 167(8):080534, 2020. doi:10.1149/1945-7111/ab9050.\n",
       "[3] Marc Doyle, Thomas F. Fuller, and John Newman. Modeling of galvanostatic charge and discharge of the lithium/polymer/insertion cell. Journal of the Electrochemical society, 140(6):1526–1533, 1993. doi:10.1149/1.2221597.\n",
       "[4] Charles R. Harris, K. Jarrod Millman, Stéfan J. van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, and others. Array programming with NumPy. Nature, 585(7825):357–362, 2020. doi:10.1038/s41586-020-2649-2.\n",
-      "[5] Peyman Mohtat, Suhak Lee, Jason B Siegel, and Anna G Stefanopoulou. Towards better estimability of electrode-specific state of health: decoding the cell expansion. Journal of Power Sources, 427:101–111, 2019.\n",
-      "[6] Valentin Sulzer, Scott G. Marquis, Robert Timms, Martin Robinson, and S. Jon Chapman. Python Battery Mathematical Modelling (PyBaMM). Journal of Open Research Software, 9(1):14, 2021. doi:10.5334/jors.309.\n",
-      "[7] Pauli Virtanen, Ralf Gommers, Travis E. Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, and others. SciPy 1.0: fundamental algorithms for scientific computing in Python. Nature Methods, 17(3):261–272, 2020. doi:10.1038/s41592-019-0686-2.\n",
-      "[8] Andrew Weng, Jason B Siegel, and Anna Stefanopoulou. Differential voltage analysis for battery manufacturing process control. arXiv preprint arXiv:2303.07088, 2023.\n",
+      "[5] Scott G. Marquis, Valentin Sulzer, Robert Timms, Colin P. Please, and S. Jon Chapman. An asymptotic derivation of a single particle model with electrolyte. Journal of The Electrochemical Society, 166(15):A3693–A3706, 2019. doi:10.1149/2.0341915jes.\n",
+      "[6] Peyman Mohtat, Suhak Lee, Jason B Siegel, and Anna G Stefanopoulou. Towards better estimability of electrode-specific state of health: decoding the cell expansion. Journal of Power Sources, 427:101–111, 2019.\n",
+      "[7] Valentin Sulzer, Scott G. Marquis, Robert Timms, Martin Robinson, and S. Jon Chapman. Python Battery Mathematical Modelling (PyBaMM). Journal of Open Research Software, 9(1):14, 2021. doi:10.5334/jors.309.\n",
+      "[8] Pauli Virtanen, Ralf Gommers, Travis E. Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, and others. SciPy 1.0: fundamental algorithms for scientific computing in Python. Nature Methods, 17(3):261–272, 2020. doi:10.1038/s41592-019-0686-2.\n",
+      "[9] Andrew Weng, Jason B Siegel, and Anna Stefanopoulou. Differential voltage analysis for battery manufacturing process control. arXiv preprint arXiv:2303.07088, 2023.\n",
       "\n"
      ]
     }
@@ -227,7 +472,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.11.8"
   }
  },
  "nbformat": 4,
diff --git a/pybamm/experiment/experiment.py b/pybamm/experiment/experiment.py
index a2a40981f..24b0b6e9b 100644
--- a/pybamm/experiment/experiment.py
+++ b/pybamm/experiment/experiment.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 import pybamm
-from .step._steps_util import (
+from .step.base_step import (
     _convert_time_to_seconds,
     _convert_temperature_to_kelvin,
 )
@@ -10,8 +10,8 @@ class Experiment:
     """
     Base class for experimental conditions under which to run the model. In general, a
     list of operating conditions should be passed in. Each operating condition should
-    be either a `pybamm.step._Step` class, created using one of the methods
-    `pybamm.step.current`, `pybamm.step.c_rate`, `pybamm.step.voltage`
+    be either a `pybamm.step.BaseStep` class, which can be created using one of the
+    methods `pybamm.step.current`, `pybamm.step.c_rate`, `pybamm.step.voltage`
     , `pybamm.step.power`, `pybamm.step.resistance`, or
     `pybamm.step.string`, or a string, in which case the string is passed to
     `pybamm.step.string`.
@@ -52,45 +52,38 @@ class Experiment:
             termination,
         )
 
-        operating_conditions_cycles = []
+        cycles = []
         for cycle in operating_conditions:
             if not isinstance(cycle, tuple):
                 cycle = (cycle,)
-            operating_conditions_cycles.append(cycle)
+            cycles.append(cycle)
 
-        self.operating_conditions_cycles = operating_conditions_cycles
-        self.cycle_lengths = [len(cycle) for cycle in operating_conditions_cycles]
+        self.cycles = cycles
+        self.cycle_lengths = [len(cycle) for cycle in cycles]
 
-        self.operating_conditions_steps_unprocessed = self._set_next_start_time(
-            [cond for cycle in operating_conditions_cycles for cond in cycle]
-        )
+        steps_unprocessed = [cond for cycle in cycles for cond in cycle]
 
-        # Convert strings to pybamm.step._Step objects
+        # Convert strings to pybamm.step.BaseStep objects
         # We only do this once per unique step, to avoid unnecessary conversions
         # Assign experiment period and temperature if not specified in step
         self.period = _convert_time_to_seconds(period)
         self.temperature = _convert_temperature_to_kelvin(temperature)
 
         processed_steps = self.process_steps(
-            self.operating_conditions_steps_unprocessed, self.period, self.temperature
+            steps_unprocessed, self.period, self.temperature
         )
 
-        self.operating_conditions_steps = [
-            processed_steps[repr(step)]
-            for step in self.operating_conditions_steps_unprocessed
-        ]
+        self.steps = [processed_steps[repr(step)] for step in steps_unprocessed]
+        self.steps = self._set_next_start_time(self.steps)
 
         # Save the processed unique steps and the processed operating conditions
         # for every step
         self.unique_steps = set(processed_steps.values())
 
         # Allocate experiment global variables
-        self.initial_start_time = self.operating_conditions_steps[0].start_time
+        self.initial_start_time = self.steps[0].start_time
 
-        if (
-            self.operating_conditions_steps[0].end_time is not None
-            and self.initial_start_time is None
-        ):
+        if self.steps[0].end_time is not None and self.initial_start_time is None:
             raise ValueError(
                 "When using experiments with `start_time`, the first step must have a "
                 "`start_time`."
@@ -107,8 +100,10 @@ class Experiment:
                 continue
             elif isinstance(step, str):
                 processed_step = pybamm.step.string(step)
-            elif isinstance(step, pybamm.step._Step):
-                processed_step = step
+            elif isinstance(step, pybamm.step.BaseStep):
+                # Copy the step to avoid modifying the original with the period and
+                # temperature and any other changes
+                processed_step = step.copy()
             else:
                 raise TypeError("Operating conditions must be a Step object or string.")
 
@@ -118,10 +113,11 @@ class Experiment:
                 processed_step.temperature = temp
 
             processed_steps[repr(step)] = processed_step
+
         return processed_steps
 
     def __str__(self):
-        return str(self.operating_conditions_cycles)
+        return str(self.cycles)
 
     def copy(self):
         return Experiment(*self.args)
@@ -196,7 +192,7 @@ class Experiment:
             A list of cycles in which the tag appears
         """
         cycles = []
-        for i, cycle in enumerate(self.operating_conditions_cycles):
+        for i, cycle in enumerate(self.cycles):
             for step in cycle:
                 if tag in step.tags:
                     cycles.append(i)
@@ -205,26 +201,18 @@ class Experiment:
         return cycles
 
     @staticmethod
-    def _set_next_start_time(operating_conditions):
-        if all(isinstance(i, str) for i in operating_conditions):
-            return operating_conditions
-
+    def _set_next_start_time(steps):
         end_time = None
         next_start_time = None
 
-        for op in reversed(operating_conditions):
-            if isinstance(op, str):
-                op = pybamm.step.string(op)
-            if not isinstance(op, pybamm.step._Step):
-                raise TypeError(
-                    "Operating conditions should be strings or _Step objects"
-                )
-
-            op.next_start_time = next_start_time
-            op.end_time = end_time
+        # Loop over the steps in reverse order, setting the end time of each step to the
+        # start time of the next step
+        for step in reversed(steps):
+            step.next_start_time = next_start_time
+            step.end_time = end_time
 
-            next_start_time = op.start_time
+            next_start_time = step.start_time
             if next_start_time:
                 end_time = next_start_time
 
-        return operating_conditions
+        return steps
diff --git a/pybamm/experiment/step/__init__.py b/pybamm/experiment/step/__init__.py
index e3b9ff8bd..17ab7c49f 100644
--- a/pybamm/experiment/step/__init__.py
+++ b/pybamm/experiment/step/__init__.py
@@ -1,3 +1,3 @@
 from .steps import *
-from .steps import _Step
+from .base_step import BaseStep, BaseStepExplicit, BaseStepImplicit
 from .step_termination import *
diff --git a/pybamm/experiment/step/_steps_util.py b/pybamm/experiment/step/base_step.py
similarity index 57%
rename from pybamm/experiment/step/_steps_util.py
rename to pybamm/experiment/step/base_step.py
index 26f9fe815..626094ba5 100644
--- a/pybamm/experiment/step/_steps_util.py
+++ b/pybamm/experiment/step/base_step.py
@@ -5,6 +5,7 @@ import pybamm
 import numpy as np
 from datetime import datetime
 from .step_termination import _read_termination
+import numbers
 
 _examples = """
 
@@ -25,17 +26,15 @@ _examples = """
     """
 
 
-class _Step:
+class BaseStep:
     """
     Class representing one step in an experiment.
     All experiment steps are functions that return an instance of this class.
-    This class is not intended to be used directly.
+    This class is not intended to be used directly, but can be subtyped to create a
+    custom experiment step.
 
     Parameters
     ----------
-    typ : str
-        The type of step, can be "current", "voltage", "c_rate", "power",
-        or "resistance".
     value : float
         The value of the step, corresponding to the type of step. Can be a number, a
         2-tuple (for cccv_ode), or a 2-column array (for drive cycles)
@@ -52,15 +51,16 @@ class _Step:
         the value should be a valid temperature string, e.g. "25 oC".
     tags : str or list, optional
         A string or list of strings indicating the tags associated with the step.
-    datetime : str or datetime, optional
-        A string or list of strings indicating the tags associated with the step.
+    start_time : str or datetime, optional
+        The start time of the step.
     description : str, optional
         A description of the step.
+    direction : str, optional
+        The direction of the step, e.g. "Charge" or "Discharge" or "Rest".
     """
 
     def __init__(
         self,
-        typ,
         value,
         duration=None,
         termination=None,
@@ -69,14 +69,29 @@ class _Step:
         tags=None,
         start_time=None,
         description=None,
+        direction=None,
     ):
-        self.type = typ
+        # Check if drive cycle
+        self.is_drive_cycle = isinstance(value, np.ndarray)
+        if self.is_drive_cycle:
+            if value.ndim != 2 or value.shape[1] != 2:
+                raise ValueError(
+                    "Drive cycle must be a 2-column array with time in the first column"
+                    " and current/C-rate/power/voltage/resistance in the second"
+                )
+            # Check that drive cycle starts at t=0
+            t = value[:, 0]
+            if t[0] != 0:
+                raise ValueError("Drive cycle must start at t=0")
+
+        # Set duration
+        if duration is None:
+            duration = self.default_duration(value)
+        self.duration = _convert_time_to_seconds(duration)
 
         # Record all the args for repr and hash
-        self.repr_args = f"{typ}, {value}"
-        self.hash_args = f"{typ}, {value}"
-        if duration:
-            self.repr_args += f", duration={duration}"
+        self.repr_args = f"{value}, duration={duration}"
+        self.hash_args = f"{value}"
         if termination:
             self.repr_args += f", termination={termination}"
             self.hash_args += f", termination={termination}"
@@ -91,38 +106,27 @@ class _Step:
             self.repr_args += f", start_time={start_time}"
         if description:
             self.repr_args += f", description={description}"
+        if direction:
+            self.repr_args += f", direction={direction}"
+            self.hash_args += f", direction={direction}"
 
-        # Check if drive cycle
-        self.is_drive_cycle = isinstance(value, np.ndarray)
+        # If drive cycle, repeat the drive cycle until the end of the experiment,
+        # and create an interpolant
         if self.is_drive_cycle:
-            if value.ndim != 2 or value.shape[1] != 2:
-                raise ValueError(
-                    "Drive cycle must be a 2-column array with time in the first column"
-                    " and current/C-rate/power/voltage/resistance in the second"
-                )
-            if duration is not None:
-                t_max = _convert_time_to_seconds(duration)
-                self.duration = _convert_time_to_seconds(duration)
-                if t_max > value[-1, 0]:
-                    # duration longer than drive cycle values so loop
-                    nloop = np.ceil(t_max / value[-1, 0]).astype(int)
-                    tstep = np.diff(value[:, 0])[0]
-                    t = []
-                    y = []
-                    for i in range(nloop):
-                        t.append(value[:, 0] + ((value[-1, 0] + tstep) * i))
-                        y.append(value[:, 1])
-                    t = np.asarray(t).flatten()
-                    y = np.asarray(y).flatten()
-                else:
-                    t, y = value[:, 0], value[:, 1]
+            t_max = self.duration
+            if t_max > value[-1, 0]:
+                # duration longer than drive cycle values so loop
+                nloop = np.ceil(t_max / value[-1, 0]).astype(int)
+                tstep = np.diff(value[:, 0])[0]
+                t = []
+                y = []
+                for i in range(nloop):
+                    t.append(value[:, 0] + ((value[-1, 0] + tstep) * i))
+                    y.append(value[:, 1])
+                t = np.asarray(t).flatten()
+                y = np.asarray(y).flatten()
             else:
                 t, y = value[:, 0], value[:, 1]
-                self.duration = t.max()
-
-            # Check that drive cycle starts at t=0
-            if t[0] > 0:
-                raise ValueError("Drive cycle must start at t=0")
 
             self.value = pybamm.Interpolant(
                 t,
@@ -133,7 +137,6 @@ class _Step:
             self.period = np.diff(t).min()
         else:
             self.value = value
-            self.duration = _convert_time_to_seconds(duration)
             self.period = _convert_time_to_seconds(period)
 
         self.description = description
@@ -164,6 +167,29 @@ class _Step:
         self.next_start_time = None
         self.end_time = None
 
+        self.direction = direction
+
+    def copy(self):
+        """
+        Return a copy of the step.
+
+        Returns
+        -------
+        :class:`pybamm.Step`
+            A copy of the step.
+        """
+        return self.__class__(
+            self.value,
+            duration=self.duration,
+            termination=self.termination,
+            period=self.period,
+            temperature=self.temperature,
+            tags=self.tags,
+            start_time=self.start_time,
+            description=self.description,
+            direction=self.direction,
+        )
+
     def __str__(self):
         if self.description is not None:
             return self.description
@@ -171,7 +197,7 @@ class _Step:
             return repr(self)
 
     def __repr__(self):
-        return f"_Step({self.repr_args})"
+        return f"Step({self.repr_args})"
 
     def basic_repr(self):
         """
@@ -179,7 +205,7 @@ class _Step:
         and temperature, which are the variables involved in processing the model. Also
         used for hashing.
         """
-        return f"_Step({self.hash_args})"
+        return f"Step({self.hash_args})"
 
     def to_dict(self):
         """
@@ -191,7 +217,7 @@ class _Step:
             A dictionary containing the step information.
         """
         return {
-            "type": self.type,
+            "type": self.__class__.__name__,
             "value": self.value,
             "duration": self.duration,
             "termination": self.termination,
@@ -203,14 +229,108 @@ class _Step:
         }
 
     def __eq__(self, other):
-        return isinstance(other, _Step) and self.hash_args == other.hash_args
+        return isinstance(other, BaseStep) and self.hash_args == other.hash_args
 
     def __hash__(self):
         return hash(self.basic_repr())
 
-    @property
-    def unit(self):
-        return _type_to_units[self.type]
+    def default_duration(self, value):
+        """
+        Default duration for the step is one day (24 hours) or the duration of the
+        drive cycle
+        """
+        if isinstance(value, np.ndarray):
+            t = value[:, 0]
+            return t[-1]
+        else:
+            return 24 * 3600  # 24 hours in seconds
+
+    def process_model(self, model, parameter_values):
+        new_model = model.new_copy()
+        new_parameter_values = parameter_values.copy()
+        new_model, new_parameter_values = self.set_up(new_model, new_parameter_values)
+        self.update_model_events(new_model)
+
+        # Update temperature
+        if self.temperature is not None:
+            new_parameter_values["Ambient temperature [K]"] = self.temperature
+
+        # Parameterise the model
+        parameterised_model = new_parameter_values.process_model(
+            new_model, inplace=False
+        )
+
+        return parameterised_model
+
+    def update_model_events(self, new_model):
+        for term in self.termination:
+            event = term.get_event(new_model.variables, self)
+            if event is not None:
+                new_model.events.append(event)
+
+        # Keep the min and max voltages as safeguards but add some tolerances
+        # so that they are not triggered before the voltage limits in the
+        # experiment
+        for i, event in enumerate(new_model.events):
+            if event.name in ["Minimum voltage [V]", "Maximum voltage [V]"]:
+                new_model.events[i] = pybamm.Event(
+                    event.name, event.expression + 1, event.event_type
+                )
+
+
+class BaseStepExplicit(BaseStep):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def current_value(self, variables):
+        raise NotImplementedError
+
+    def set_up(self, new_model, new_parameter_values):
+        new_parameter_values["Current function [A]"] = self.current_value(
+            new_model.variables
+        )
+        return new_model, new_parameter_values
+
+
+class BaseStepImplicit(BaseStep):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def get_parameter_values(self, variables):
+        return {}
+
+    def get_submodel(self, model):
+        raise NotImplementedError
+
+    def set_up(self, new_model, new_parameter_values):
+        # Create a new model where the current density is now a variable
+        # To do so, we replace all instances of the current density in the
+        # model with a current density variable, which is obtained from the
+        # FunctionControl submodel
+        # check which kind of external circuit model we need (differential
+        # or algebraic)
+        # Build the new submodel and update the model with it
+        submodel = self.get_submodel(new_model)
+        variables = new_model.variables
+        submodel.variables = submodel.get_fundamental_variables()
+        variables.update(submodel.variables)
+        submodel.variables.update(submodel.get_coupled_variables(variables))
+        variables.update(submodel.variables)
+        submodel.set_rhs(variables)
+        submodel.set_algebraic(variables)
+        submodel.set_initial_conditions(variables)
+        new_model.rhs.update(submodel.rhs)
+        new_model.algebraic.update(submodel.algebraic)
+        new_model.initial_conditions.update(submodel.initial_conditions)
+
+        # Set the "current function" to be the variable defined in the submodel
+        new_parameter_values["Current function [A]"] = submodel.variables["Current [A]"]
+        # Update any other parameters as necessary
+        new_parameter_values.update(
+            self.get_parameter_values(variables), check_already_exists=False
+        )
+
+        return new_model, new_parameter_values
 
 
 _type_to_units = {
@@ -224,7 +344,7 @@ _type_to_units = {
 def _convert_time_to_seconds(time_and_units):
     """Convert a time in seconds, minutes or hours to a time in seconds"""
     # If the time is a number, assume it is in seconds
-    if isinstance(time_and_units, (int, float)) or time_and_units is None:
+    if isinstance(time_and_units, numbers.Number) or time_and_units is None:
         return time_and_units
 
     # Split number and units
diff --git a/pybamm/experiment/step/step_termination.py b/pybamm/experiment/step/step_termination.py
index 082711a30..d4ffbe1aa 100644
--- a/pybamm/experiment/step/step_termination.py
+++ b/pybamm/experiment/step/step_termination.py
@@ -1,5 +1,4 @@
 import pybamm
-import numpy as np
 
 
 class BaseTermination:
@@ -18,7 +17,7 @@ class BaseTermination:
     def __init__(self, value):
         self.value = value
 
-    def get_event(self, variables, step_value):
+    def get_event(self, variables, step):
         """
         Return a :class:`pybamm.Event` object corresponding to the termination event
 
@@ -27,8 +26,8 @@ class BaseTermination:
         variables : dict
             Dictionary of model variables, to be used for selecting the variable(s) that
             determine the event
-        step_value : float or :class:`pybamm.Symbol`
-            Value of the step for which this is a termination event, to be used in some
+        step : :class:`pybamm.step.BaseStep`
+            Step for which this is a termination event, to be used in some
             cases to determine the sign of the event.
         """
         raise NotImplementedError
@@ -47,7 +46,7 @@ class CrateTermination(BaseTermination):
     (e.g. "C/10") is provided
     """
 
-    def get_event(self, variables, step_value):
+    def get_event(self, variables, step):
         """
         See :meth:`BaseTermination.get_event`
         """
@@ -64,7 +63,7 @@ class CurrentTermination(BaseTermination):
     (e.g. "1A") is provided
     """
 
-    def get_event(self, variables, step_value):
+    def get_event(self, variables, step):
         """
         See :meth:`BaseTermination.get_event`
         """
@@ -81,7 +80,7 @@ class VoltageTermination(BaseTermination):
     (e.g. "4.2V") is provided
     """
 
-    def get_event(self, variables, step_value):
+    def get_event(self, variables, step):
         """
         See :meth:`BaseTermination.get_event`
         """
@@ -90,24 +89,22 @@ class VoltageTermination(BaseTermination):
         # figure out whether the voltage event is greater than the starting
         # voltage (charge) or less (discharge) and set the sign of the
         # event accordingly
-        if isinstance(step_value, pybamm.Symbol):
-            inpt = {"start time": 0}
-            init_curr = step_value.evaluate(t=0, inputs=inpt).flatten()[0]
-        else:
-            init_curr = step_value
-        sign = np.sign(init_curr)
-        if sign > 0:
-            name = "Discharge"
-        else:
-            name = "Charge"
-        if sign != 0:
-            # Event should be positive at initial conditions for both
-            # charge and discharge
-            event = pybamm.Event(
-                f"{name} voltage cut-off [V] [experiment]",
-                sign * (variables["Battery voltage [V]"] - self.value),
-            )
-            return event
+        direction = step.direction.capitalize()
+        if direction == "Charge":
+            sign = -1
+        elif direction == "Discharge":
+            sign = 1
+        elif direction == "Rest":
+            # No event for rest steps
+            return None
+
+        # Event should be positive at initial conditions for both
+        # charge and discharge
+        event = pybamm.Event(
+            f"{direction} voltage cut-off [V] [experiment]",
+            sign * (variables["Battery voltage [V]"] - self.value),
+        )
+        return event
 
 
 class CustomTermination(BaseTermination):
@@ -143,7 +140,7 @@ class CustomTermination(BaseTermination):
         self.name = name
         self.event_function = event_function
 
-    def get_event(self, variables, step_value):
+    def get_event(self, variables, step):
         """
         See :meth:`BaseTermination.get_event`
         """
diff --git a/pybamm/experiment/step/steps.py b/pybamm/experiment/step/steps.py
index 2f2e9e31a..66b3ff564 100644
--- a/pybamm/experiment/step/steps.py
+++ b/pybamm/experiment/step/steps.py
@@ -1,7 +1,14 @@
 #
 # Public functions to create steps for use in an experiment.
 #
-from ._steps_util import _Step, _convert_electric, _examples
+import numpy as np
+import pybamm
+from .base_step import (
+    BaseStepExplicit,
+    BaseStepImplicit,
+    _convert_electric,
+    _examples,
+)
 
 
 def string(string, **kwargs):
@@ -20,12 +27,11 @@ def string(string, **kwargs):
         "3 minutes" or "1 hour". The stopping conditions should be
         a circuit state, e.g. "1 A", "C/50" or "3 V".
     **kwargs
-        Any other keyword arguments are passed to the :class:`pybamm.step._Step`
-        class.
+        Any other keyword arguments are passed to the step class
 
     Returns
     -------
-    :class:`pybamm.step._Step`
+    :class:`pybamm.step.BaseStep`
         A step parsed from the string.
     """
     if not isinstance(string, str):
@@ -74,7 +80,7 @@ def string(string, **kwargs):
 
     # read remaining instruction
     if string.startswith("Rest"):
-        typ = "current"
+        step_class = Current
         value = 0
     elif string.startswith("Run"):
         raise ValueError(
@@ -102,8 +108,16 @@ def string(string, **kwargs):
         # Make current positive for discharge and negative for charge
         value *= sign
 
-    return _Step(
-        typ,
+        # Use the appropriate step class
+        step_class = {
+            "current": Current,
+            "voltage": Voltage,
+            "power": Power,
+            "C-rate": CRate,
+            "resistance": Resistance,
+        }[typ]
+
+    return step_class(
         value,
         duration=duration,
         termination=termination,
@@ -112,109 +126,132 @@ def string(string, **kwargs):
     )
 
 
-def current(value, **kwargs):
+class Current(BaseStepExplicit):
     """
-    Create a current-controlled step.
+    Current-controlled step, see :class:`pybamm.step.BaseStep` for arguments.
     Current is positive for discharge and negative for charge.
+    """
 
-    Parameters
-    ----------
-    value : float
-        The current value in A. It can be a number or a 2-column array (for drive cycles).
-    **kwargs
-        Any other keyword arguments are passed to the :class:`pybamm.step._Step`
-        class.
+    def __init__(self, value, **kwargs):
+        kwargs["direction"] = value_based_charge_or_discharge(value)
+        super().__init__(value, **kwargs)
 
-    Returns
-    -------
-    :class:`pybamm.step._Step`
-        A current-controlled step.
+    def current_value(self, variables):
+        return self.value
+
+
+def current(value, **kwargs):
+    """
+    Current-controlled step, see :class:`pybamm.step.Current`.
     """
-    return _Step("current", value, **kwargs)
+    return Current(value, **kwargs)
 
 
-def c_rate(value, **kwargs):
+class CRate(BaseStepExplicit):
     """
-    Create a C-rate controlled step.
+    C-rate-controlled step, see :class:`pybamm.step.BaseStep` for arguments.
     C-rate is positive for discharge and negative for charge.
+    """
 
-    Parameters
-    ----------
-    value : float
-        The C-rate value. It can be a number or a 2-column array (for drive cycles).
-    **kwargs
-        Any other keyword arguments are passed to the :class:`pybamm.step._Step`
-        class.
+    def __init__(self, value, **kwargs):
+        kwargs["direction"] = value_based_charge_or_discharge(value)
+        super().__init__(value, **kwargs)
 
-    Returns
-    -------
-    :class:`pybamm.step._Step`
-        A C-rate controlled step.
+    def current_value(self, variables):
+        return self.value * pybamm.Parameter("Nominal cell capacity [A.h]")
+
+
+def c_rate(value, **kwargs):
     """
-    return _Step("C-rate", value, **kwargs)
+    C-rate-controlled step, see :class:`pybamm.step.CRate`.
+    """
+    return CRate(value, **kwargs)
 
 
-def voltage(value, **kwargs):
+class Voltage(BaseStepImplicit):
     """
-    Create a voltage-controlled step.
+    Voltage-controlled step, see :class:`pybamm.step.BaseStep` for arguments.
     Voltage should always be positive.
+    """
 
-    Parameters
-    ----------
-    value : float
-        The voltage value in V. It can be a number or a 2-column array (for drive cycles).
-    **kwargs
-        Any other keyword arguments are passed to the :class:`pybamm.step._Step`
-        class.
+    def get_parameter_values(self, variables):
+        return {"Voltage function [V]": self.value}
 
-    Returns
-    -------
-    :class:`pybamm.step._Step`
-        A voltage-controlled step.
+    def get_submodel(self, model):
+        return pybamm.external_circuit.VoltageFunctionControl(
+            model.param, model.options
+        )
+
+
+def voltage(*args, **kwargs):
     """
-    return _Step("voltage", value, **kwargs)
+    Voltage-controlled step, see :class:`pybamm.step.Voltage`.
+    """
+    return Voltage(*args, **kwargs)
 
 
-def power(value, **kwargs):
+class Power(BaseStepImplicit):
     """
-    Create a power-controlled step.
+    Power-controlled step.
     Power is positive for discharge and negative for charge.
 
     Parameters
     ----------
     value : float
-        The power value in W. It can be a number or a 2-column array (for drive cycles).
+        The value of the power function [W].
     **kwargs
-        Any other keyword arguments are passed to the :class:`pybamm.step._Step`
-        class.
+        Any other keyword arguments are passed to the step class
+    """
 
-    Returns
-    -------
-    :class:`pybamm.step._Step`
-        A power-controlled step.
+    def __init__(self, value, **kwargs):
+        kwargs["direction"] = value_based_charge_or_discharge(value)
+        super().__init__(value, **kwargs)
+
+    def get_parameter_values(self, variables):
+        return {"Power function [W]": self.value}
+
+    def get_submodel(self, model):
+        return pybamm.external_circuit.PowerFunctionControl(model.param, model.options)
+
+
+def power(value, **kwargs):
     """
-    return _Step("power", value, **kwargs)
+    Power-controlled step, see :class:`pybamm.step.Power`.
+    """
+    return Power(value, **kwargs)
 
 
-def resistance(value, **kwargs):
+class Resistance(BaseStepImplicit):
     """
-    Create a resistance-controlled step.
+    Resistance-controlled step.
     Resistance is positive for discharge and negative for charge.
 
     Parameters
     ----------
     value : float
-        The resistance value in Ohm. It can be a number or a 2-column array (for drive cycles).
+        The value of the power function [W].
     **kwargs
-        Any other keyword arguments are passed to the :class:`pybamm.step._Step`
-        class.
+        Any other keyword arguments are passed to the step class
+    """
 
-    Returns
-    -------
-    :class:`pybamm.step._Step`
-        A resistance-controlled step.
+    def __init__(self, value, **kwargs):
+        kwargs["direction"] = value_based_charge_or_discharge(value)
+        super().__init__(value, **kwargs)
+
+    def get_parameter_values(self, variables):
+        return {"Resistance function [Ohm]": self.value}
+
+    def get_submodel(self, model):
+        return pybamm.external_circuit.ResistanceFunctionControl(
+            model.param, model.options
+        )
+
+
+def resistance(value, **kwargs):
     """
-    return _Step("resistance", value, **kwargs)
+    Resistance-controlled step, see :class:`pybamm.step.Resistance`.
+    """
+    return Resistance(value, **kwargs)
 
 
 def rest(duration=None, **kwargs):
@@ -222,4 +259,182 @@ def rest(duration=None, **kwargs):
     Create a rest step, equivalent to a constant current step with value 0
     (see :meth:`pybamm.step.current`).
     """
-    return current(0, duration=duration, **kwargs)
+    return Current(0, duration=duration, **kwargs)
+
+
+class CustomStepExplicit(BaseStepExplicit):
+    """
+    Custom step class where the current value is explicitly given as a function of
+    other variables. When using this class, the user must be careful not to create
+    an expression that depends on the current itself, as this will lead to a
+    circular dependency. For example, in some models, the voltage is an explicit
+    function of the current, so the user should not create a step that depends on
+    the voltage. An expression that works for one model may not work for another.
+
+    Parameters
+    ----------
+    current_value_function : callable
+        A function that takes in a dictionary of variables and returns the current
+        value.
+    duration : float, optional
+        The duration of the step in seconds.
+    termination : str or list, optional
+        A string or list of strings indicating the condition(s) that will terminate the
+        step. If a list, the step will terminate when any of the conditions are met.
+    period : float or string, optional
+        The period of the step. If a float, the value is in seconds. If a string, the
+        value should be a valid time string, e.g. "1 hour".
+    temperature : float or string, optional
+        The temperature of the step. If a float, the value is in Kelvin. If a string,
+        the value should be a valid temperature string, e.g. "25 oC".
+    tags : str or list, optional
+        A string or list of strings indicating the tags associated with the step.
+    start_time : str or datetime, optional
+        The start time of the step.
+    description : str, optional
+        A description of the step.
+    direction : str, optional
+        The direction of the step, e.g. "Charge" or "Discharge" or "Rest".
+
+    Examples
+    --------
+    Control the current to always be equal to a target power divided by voltage
+    (this is one way to implement a power control step):
+
+    >>> def current_function(variables):
+    ...     P = 4
+    ...     V = variables["Voltage [V]"]
+    ...     return P / V
+
+    Create the step with a 2.5 V termination condition:
+
+    >>> step = pybamm.step.CustomStepExplicit(current_function, termination="2.5V")
+    """
+
+    def __init__(self, current_value_function, **kwargs):
+        super().__init__(None, **kwargs)
+        self.current_value_function = current_value_function
+        self.kwargs = kwargs
+
+    def current_value(self, variables):
+        return self.current_value_function(variables)
+
+    def copy(self):
+        return CustomStepExplicit(self.current_value_function, **self.kwargs)
+
+
+class CustomStepImplicit(BaseStepImplicit):
+    """
+    Custom step, see :class:`pybamm.step.BaseStep` for arguments.
+
+    Parameters
+    ----------
+    current_rhs_function : callable
+        A function that takes in a dictionary of variables and returns the equation
+        controlling the current.
+
+    control : str, optional
+        Whether the control is algebraic or differential. Default is algebraic, in
+        which case the equation is
+
+        .. math::
+            0 = f(\\text{{variables}})
+
+        where :math:`f` is the current_rhs_function.
+
+        If control is "differential", the equation is
+
+        .. math::
+            \\frac{dI}{dt} = f(\\text{{variables}})
+
+    duration : float, optional
+        The duration of the step in seconds.
+    termination : str or list, optional
+        A string or list of strings indicating the condition(s) that will terminate the
+        step. If a list, the step will terminate when any of the conditions are met.
+    period : float or string, optional
+        The period of the step. If a float, the value is in seconds. If a string, the
+        value should be a valid time string, e.g. "1 hour".
+    temperature : float or string, optional
+        The temperature of the step. If a float, the value is in Kelvin. If a string,
+        the value should be a valid temperature string, e.g. "25 oC".
+    tags : str or list, optional
+        A string or list of strings indicating the tags associated with the step.
+    start_time : str or datetime, optional
+        The start time of the step.
+    description : str, optional
+        A description of the step.
+    direction : str, optional
+        The direction of the step, e.g. "Charge" or "Discharge" or "Rest".
+
+    Examples
+    --------
+    Control the current so that the voltage is constant (without using the built-in
+    voltage control):
+
+    >>> def voltage_control(variables):
+    ...     V = variables["Voltage [V]"]
+    ...     return V - 4.2
+
+    Create the step with a duration of 1h. In this case we don't need to specify that
+    the control is algebraic, as this is the default.
+
+    >>> step = pybamm.step.CustomStepImplicit(voltage_control, duration=3600)
+
+    Alternatively, control the current by a differential equation to achieve a
+    target power:
+
+    >>> def power_control(variables):
+    ...     V = variables["Voltage [V]"]
+    ...     # Large time constant to avoid large overshoot. The user should be careful
+    ...     # to choose a time constant that is appropriate for the model being used,
+    ...     # as well as choosing the appropriate sign for the time constant.
+    ...     K_V = 100
+    ...     return K_V * (V - 4.2)
+
+    Create the step with a 2.5 V termination condition. Now we need to specify that
+    the control is differential.
+
+    >>> step = pybamm.step.CustomStepImplicit(
+    ...     power_control, termination="2.5V", control="differential"
+    ... )
+    """
+
+    def __init__(self, current_rhs_function, control="algebraic", **kwargs):
+        super().__init__(None, **kwargs)
+        self.current_rhs_function = current_rhs_function
+        if control not in ["algebraic", "differential"]:
+            raise ValueError("control must be either 'algebraic' or 'differential'")
+        self.control = control
+        self.kwargs = kwargs
+
+    def get_submodel(self, model):
+        return pybamm.external_circuit.FunctionControl(
+            model.param, self.current_rhs_function, model.options, control=self.control
+        )
+
+    def copy(self):
+        return CustomStepImplicit(
+            self.current_rhs_function, self.control, **self.kwargs
+        )
+
+
+def value_based_charge_or_discharge(step_value):
+    """
+    Determine whether the step is a charge or discharge step based on the value of the
+    step
+    """
+    if isinstance(step_value, np.ndarray):
+        init_curr = step_value[0, 1]
+    elif isinstance(step_value, pybamm.Symbol):
+        inpt = {"start time": 0}
+        init_curr = step_value.evaluate(t=0, inputs=inpt).flatten()[0]
+    else:
+        init_curr = step_value
+    sign = np.sign(init_curr)
+    if sign == 0:
+        return "Rest"
+    elif sign > 0:
+        return "Discharge"
+    else:
+        return "Charge"
diff --git a/pybamm/models/full_battery_models/base_battery_model.py b/pybamm/models/full_battery_models/base_battery_model.py
index 4fcae6a1d..7a29ad64c 100644
--- a/pybamm/models/full_battery_models/base_battery_model.py
+++ b/pybamm/models/full_battery_models/base_battery_model.py
@@ -1135,7 +1135,7 @@ class BaseBatteryModel(pybamm.BaseModel):
             )
         elif self.options["operating mode"] == "differential power":
             model = pybamm.external_circuit.PowerFunctionControl(
-                self.param, self.options, "differential without max"
+                self.param, self.options, "differential"
             )
         elif self.options["operating mode"] == "explicit power":
             model = pybamm.external_circuit.ExplicitPowerControl(
@@ -1147,7 +1147,7 @@ class BaseBatteryModel(pybamm.BaseModel):
             )
         elif self.options["operating mode"] == "differential resistance":
             model = pybamm.external_circuit.ResistanceFunctionControl(
-                self.param, self.options, "differential without max"
+                self.param, self.options, "differential"
             )
         elif self.options["operating mode"] == "explicit resistance":
             model = pybamm.external_circuit.ExplicitResistanceControl(
diff --git a/pybamm/models/full_battery_models/equivalent_circuit/thevenin.py b/pybamm/models/full_battery_models/equivalent_circuit/thevenin.py
index 14f3381f2..9aaf747a4 100644
--- a/pybamm/models/full_battery_models/equivalent_circuit/thevenin.py
+++ b/pybamm/models/full_battery_models/equivalent_circuit/thevenin.py
@@ -120,7 +120,7 @@ class Thevenin(pybamm.BaseModel):
             )
         elif self.options["operating mode"] == "differential power":
             model = pybamm.external_circuit.PowerFunctionControl(
-                self.param, self.options, "differential without max"
+                self.param, self.options, "differential"
             )
         elif self.options["operating mode"] == "resistance":
             model = pybamm.external_circuit.ResistanceFunctionControl(
@@ -128,7 +128,7 @@ class Thevenin(pybamm.BaseModel):
             )
         elif self.options["operating mode"] == "differential resistance":
             model = pybamm.external_circuit.ResistanceFunctionControl(
-                self.param, self.options, "differential without max"
+                self.param, self.options, "differential"
             )
         elif self.options["operating mode"] == "CCCV":
             model = pybamm.external_circuit.CCCVFunctionControl(
@@ -139,7 +139,7 @@ class Thevenin(pybamm.BaseModel):
                 self.param,
                 self.options["operating mode"],
                 self.options,
-                control="differential without max",
+                control="differential",
             )
         self.submodels["external circuit"] = model
 
diff --git a/pybamm/models/submodels/external_circuit/explicit_control_external_circuit.py b/pybamm/models/submodels/external_circuit/explicit_control_external_circuit.py
index e9bf18155..5c72da2db 100644
--- a/pybamm/models/submodels/external_circuit/explicit_control_external_circuit.py
+++ b/pybamm/models/submodels/external_circuit/explicit_control_external_circuit.py
@@ -8,9 +8,6 @@ from .base_external_circuit import BaseModel
 class ExplicitCurrentControl(BaseModel):
     """External circuit with current control."""
 
-    def __init__(self, param, options):
-        super().__init__(param, options)
-
     def get_fundamental_variables(self):
         # Current is given as a function of time
         i_cell = self.param.current_density_with_time
@@ -32,9 +29,6 @@ class ExplicitCurrentControl(BaseModel):
 class ExplicitPowerControl(BaseModel):
     """External circuit with current set explicitly to hit target power."""
 
-    def __init__(self, param, options):
-        super().__init__(param, options)
-
     def get_coupled_variables(self, variables):
         param = self.param
 
@@ -58,9 +52,6 @@ class ExplicitPowerControl(BaseModel):
 class ExplicitResistanceControl(BaseModel):
     """External circuit with current set explicitly to hit target resistance."""
 
-    def __init__(self, param, options):
-        super().__init__(param, options)
-
     def get_coupled_variables(self, variables):
         param = self.param
 
diff --git a/pybamm/models/submodels/external_circuit/function_control_external_circuit.py b/pybamm/models/submodels/external_circuit/function_control_external_circuit.py
index 2e64e84c9..c49c1f8c7 100644
--- a/pybamm/models/submodels/external_circuit/function_control_external_circuit.py
+++ b/pybamm/models/submodels/external_circuit/function_control_external_circuit.py
@@ -32,7 +32,7 @@ class FunctionControl(BaseModel):
         param = self.param
         # Current is a variable
         i_var = pybamm.Variable("Current variable [A]", scale=param.Q)
-        if self.control in ["algebraic", "differential without max"]:
+        if self.control in ["algebraic", "differential"]:
             I = i_var
         elif self.control == "differential with max":
             i_input = pybamm.FunctionParameter(
@@ -118,7 +118,7 @@ class PowerFunctionControl(FunctionControl):
 class ResistanceFunctionControl(FunctionControl):
     """External circuit with resistance control."""
 
-    def __init__(self, param, options, control):
+    def __init__(self, param, options, control="algebraic"):
         super().__init__(param, self.constant_resistance, options, control=control)
 
     def constant_resistance(self, variables):
diff --git a/pybamm/simulation.py b/pybamm/simulation.py
index 3dfdac94b..24e1db30c 100644
--- a/pybamm/simulation.py
+++ b/pybamm/simulation.py
@@ -103,7 +103,7 @@ class Simulation:
                         }
                     )
         else:
-            if isinstance(experiment, (str, pybamm.step._Step)):
+            if isinstance(experiment, (str, pybamm.step.BaseStep)):
                 experiment = pybamm.Experiment([experiment])
             elif isinstance(experiment, list):
                 experiment = pybamm.Experiment(experiment)
@@ -131,8 +131,8 @@ class Simulation:
         self._model_with_set_params = None
         self._built_model = None
         self._built_initial_soc = None
-        self.op_conds_to_built_models = None
-        self.op_conds_to_built_solvers = None
+        self.steps_to_built_models = None
+        self.steps_to_built_solvers = None
         self._mesh = None
         self._disc = None
         self._solution = None
@@ -178,150 +178,42 @@ class Simulation:
 
     def set_up_and_parameterise_experiment(self):
         """
-        Set up a simulation to run with an experiment. This creates a dictionary of
-        inputs (current/voltage/power, running time, stopping condition) for each
-        operating condition in the experiment. The model will then be solved by
-        integrating the model successively with each group of inputs, one group at a
-        time.
-        This needs to be done here and not in the Experiment class because the nominal
-        cell capacity (from the parameters) is used to convert C-rate to current.
-        """
-        # Update experiment using capacity
-        capacity = self._parameter_values["Nominal cell capacity [A.h]"]
-        for op_conds in self.experiment.operating_conditions_steps:
-            if op_conds.type == "C-rate":
-                op_conds.type = "current"
-                op_conds.value = op_conds.value * capacity
-
-            # Add time to the experiment times
-            dt = op_conds.duration
-            if dt is None:
-                if op_conds.type == "current":
-                    # Current control: max simulation time: 3h / C-rate
-                    Crate = op_conds.value / capacity
-                    dt = 3 / abs(Crate) * 3600  # seconds
-                else:
-                    # max simulation time: 1 day
-                    dt = 24 * 3600  # seconds
-                op_conds.duration = dt
-
-        # Set up model for experiment
-        self.set_up_and_parameterise_model_for_experiment()
-
-    def set_up_and_parameterise_model_for_experiment(self):
-        """
-        Set up self._model to be able to run the experiment (new version).
-        In this version, a new model is created for each step.
+        Create and parameterise the models for each step in the experiment.
 
         This increases set-up time since several models to be processed, but
         reduces simulation time since the model formulation is efficient.
         """
+        parameter_values = self._parameter_values.copy()
+        # Set the initial temperature to be the temperature of the first step
+        # We can set this globally for all steps since any subsequent steps will either
+        # start at the temperature at the end of the previous step (if non-isothermal
+        # model), or will use the "Ambient temperature" input (if isothermal model).
+        # In either case, the initial temperature is not used for any steps except
+        # the first.
+        init_temp = self.experiment.steps[0].temperature
+        if init_temp is not None:
+            parameter_values["Initial temperature [K]"] = init_temp
+
+        # Process each step
         self.experiment_unique_steps_to_model = {}
-        for op_number, op in enumerate(self.experiment.unique_steps):
-            new_model = self._model.new_copy()
-            new_parameter_values = self._parameter_values.copy()
-
-            if op.type != "current":
-                # Voltage or power control
-                # Create a new model where the current density is now a variable
-                # To do so, we replace all instances of the current density in the
-                # model with a current density variable, which is obtained from the
-                # FunctionControl submodel
-                # check which kind of external circuit model we need (differential
-                # or algebraic)
-                if op.type == "voltage":
-                    submodel_class = pybamm.external_circuit.VoltageFunctionControl
-                elif op.type == "power":
-                    submodel_class = pybamm.external_circuit.PowerFunctionControl
-
-                # Build the new submodel and update the model with it
-                submodel = submodel_class(new_model.param, new_model.options)
-                variables = new_model.variables
-                submodel.variables = submodel.get_fundamental_variables()
-                variables.update(submodel.variables)
-                submodel.variables.update(submodel.get_coupled_variables(variables))
-                variables.update(submodel.variables)
-                submodel.set_rhs(variables)
-                submodel.set_algebraic(variables)
-                submodel.set_initial_conditions(variables)
-                new_model.rhs.update(submodel.rhs)
-                new_model.algebraic.update(submodel.algebraic)
-                new_model.initial_conditions.update(submodel.initial_conditions)
-
-                # Set the "current function" to be the variable defined in the submodel
-                new_parameter_values["Current function [A]"] = submodel.variables[
-                    "Current [A]"
-                ]
-            self.update_new_model_events(new_model, op)
-            # Update parameter values
-            self._original_temperature = new_parameter_values["Ambient temperature [K]"]
-            experiment_parameter_values = self.get_experiment_parameter_values(
-                op, op_number
-            )
-            new_parameter_values.update(
-                experiment_parameter_values, check_already_exists=False
-            )
-            parameterised_model = new_parameter_values.process_model(
-                new_model, inplace=False
+        for step in self.experiment.unique_steps:
+            parameterised_model = step.process_model(self._model, parameter_values)
+            self.experiment_unique_steps_to_model[step.basic_repr()] = (
+                parameterised_model
             )
-            self.experiment_unique_steps_to_model[op.basic_repr()] = parameterised_model
 
         # Set up rest model if experiment has start times
         if self.experiment.initial_start_time:
-            new_model = self._model.new_copy()
-            # Update parameter values
-            new_parameter_values = self._parameter_values.copy()
-            self._original_temperature = new_parameter_values["Ambient temperature [K]"]
-            new_parameter_values.update(
-                {"Current function [A]": 0, "Ambient temperature [K]": "[input]"},
-                check_already_exists=False,
-            )
-            parameterised_model = new_parameter_values.process_model(
-                new_model, inplace=False
-            )
+            # duration doesn't matter, we just need the model
+            rest_step = pybamm.step.rest(duration=1)
+            # Change ambient temperature to be an input, which will be changed at
+            # solve time
+            parameter_values["Ambient temperature [K]"] = "[input]"
+            parameterised_model = rest_step.process_model(self._model, parameter_values)
             self.experiment_unique_steps_to_model["Rest for padding"] = (
                 parameterised_model
             )
 
-    def update_new_model_events(self, new_model, op):
-        for term in op.termination:
-            event = term.get_event(new_model.variables, op.value)
-            if event is not None:
-                new_model.events.append(event)
-
-        # Keep the min and max voltages as safeguards but add some tolerances
-        # so that they are not triggered before the voltage limits in the
-        # experiment
-        for i, event in enumerate(new_model.events):
-            if event.name in ["Minimum voltage [V]", "Maximum voltage [V]"]:
-                new_model.events[i] = pybamm.Event(
-                    event.name, event.expression + 1, event.event_type
-                )
-
-    def get_experiment_parameter_values(self, op, op_number):
-        experiment_parameter_values = {
-            f"{op.type.capitalize()} function {op.unit}": op.value
-        }
-
-        if op.temperature is not None:
-            ambient_temperature = op.temperature
-            experiment_parameter_values.update(
-                {"Ambient temperature [K]": ambient_temperature}
-            )
-
-            # If at the first operation, then the intial temperature
-            # should be the ambient temperature.
-            if op_number == 0:
-                experiment_parameter_values.update(
-                    {"Initial temperature [K]": ambient_temperature}
-                )
-        else:
-            experiment_parameter_values.update(
-                {"Ambient temperature [K]": self._original_temperature}
-            )
-
-        return experiment_parameter_values
-
     def set_parameters(self):
         """
         A method to set the parameters in the model and the associated geometry.
@@ -341,8 +233,8 @@ class Simulation:
             # reset
             self._model_with_set_params = None
             self._built_model = None
-            self.op_conds_to_built_models = None
-            self.op_conds_to_built_solvers = None
+            self.steps_to_built_models = None
+            self.steps_to_built_solvers = None
 
         options = self.model.options
         param = self._model.param
@@ -412,7 +304,7 @@ class Simulation:
         if initial_soc is not None:
             self.set_initial_soc(initial_soc)
 
-        if self.op_conds_to_built_models:
+        if self.steps_to_built_models:
             return
         else:
             self.set_up_and_parameterise_experiment()
@@ -424,10 +316,10 @@ class Simulation:
             self._mesh = pybamm.Mesh(self._geometry, self._submesh_types, self._var_pts)
             self._disc = pybamm.Discretisation(self._mesh, self._spatial_methods)
             # Process all the different models
-            self.op_conds_to_built_models = {}
-            self.op_conds_to_built_solvers = {}
+            self.steps_to_built_models = {}
+            self.steps_to_built_solvers = {}
             for (
-                op_cond,
+                step,
                 model_with_set_params,
             ) in self.experiment_unique_steps_to_model.items():
                 # It's ok to modify the model with set parameters in place as it's
@@ -436,8 +328,8 @@ class Simulation:
                     model_with_set_params, inplace=True, check_model=check_model
                 )
                 solver = self._solver.copy()
-                self.op_conds_to_built_solvers[op_cond] = solver
-                self.op_conds_to_built_models[op_cond] = built_model
+                self.steps_to_built_solvers[step] = solver
+                self.steps_to_built_models[step] = built_model
 
     def solve(
         self,
@@ -660,10 +552,10 @@ class Simulation:
             # Add initial padding rest if current time is earlier than first start time
             # This could be the case when using a starting solution
             if starting_solution is not None:
-                op_conds = self.experiment.operating_conditions_steps[0]
-                if op_conds.start_time is not None:
+                step = self.experiment.steps[0]
+                if step.start_time is not None:
                     rest_time = (
-                        op_conds.start_time
+                        step.start_time
                         - (
                             initial_start_time
                             + timedelta(seconds=float(current_solution.t[-1]))
@@ -676,7 +568,8 @@ class Simulation:
                         kwargs["inputs"] = {
                             **user_inputs,
                             "Ambient temperature [K]": (
-                                op_conds.temperature or self._original_temperature
+                                step.temperature
+                                or self._parameter_values["Ambient temperature [K]"]
                             ),
                             "start time": current_solution.t[-1],
                         }
@@ -745,23 +638,15 @@ class Simulation:
                 for step_num in range(1, cycle_length + 1):
                     # Use 1-indexing for printing cycle number as it is more
                     # human-intuitive
-                    op_conds = self.experiment.operating_conditions_steps[idx]
-
-                    # Hacky patch to allow correct processing of end_time and next_starting time
-                    # For efficiency purposes, op_conds treats identical steps as the same object
-                    # regardless of the initial time. Should be refactored as part of #3176
-                    op_conds_unproc = (
-                        self.experiment.operating_conditions_steps_unprocessed[idx]
-                    )
-
+                    step = self.experiment.steps[idx]
                     start_time = current_solution.t[-1]
 
                     # If step has an end time, dt must take that into account
-                    if getattr(op_conds_unproc, "end_time", None):
+                    if step.end_time is not None:
                         dt = min(
-                            op_conds.duration,
+                            step.duration,
                             (
-                                op_conds_unproc.end_time
+                                step.end_time
                                 - (
                                     initial_start_time
                                     + timedelta(seconds=float(start_time))
@@ -769,13 +654,13 @@ class Simulation:
                             ).total_seconds(),
                         )
                     else:
-                        dt = op_conds.duration
-                    op_conds_str = str(op_conds)
-                    model = self.op_conds_to_built_models[op_conds.basic_repr()]
-                    solver = self.op_conds_to_built_solvers[op_conds.basic_repr()]
+                        dt = step.duration
+                    step_str = str(step)
+                    model = self.steps_to_built_models[step.basic_repr()]
+                    solver = self.steps_to_built_solvers[step.basic_repr()]
 
                     logs["step number"] = (step_num, cycle_length)
-                    logs["step operating conditions"] = op_conds_str
+                    logs["step operating conditions"] = step_str
                     callbacks.on_step_start(logs)
 
                     kwargs["inputs"] = {
@@ -783,7 +668,7 @@ class Simulation:
                         "start time": start_time,
                     }
                     # Make sure we take at least 2 timesteps
-                    npts = max(int(round(dt / op_conds.period)) + 1, 2)
+                    npts = max(int(round(dt / step.period)) + 1, 2)
                     try:
                         step_solution = solver.step(
                             current_solution,
@@ -814,9 +699,9 @@ class Simulation:
                     step_termination = step_solution.termination
 
                     # Add a padding rest step if necessary
-                    if getattr(op_conds_unproc, "next_start_time", None) is not None:
+                    if step.next_start_time is not None:
                         rest_time = (
-                            op_conds_unproc.next_start_time
+                            step.next_start_time
                             - (
                                 initial_start_time
                                 + timedelta(seconds=float(step_solution.t[-1]))
@@ -830,7 +715,8 @@ class Simulation:
                             kwargs["inputs"] = {
                                 **user_inputs,
                                 "Ambient temperature [K]": (
-                                    op_conds.temperature or self._original_temperature
+                                    step.temperature
+                                    or self._parameter_values["Ambient temperature [K]"]
                                 ),
                                 "start time": step_solution.t[-1],
                             }
@@ -883,7 +769,7 @@ class Simulation:
                     if all(isinstance(step, pybamm.EmptySolution) for step in steps):
                         if len(steps) == 1:
                             raise pybamm.SolverError(
-                                f"Step '{op_conds_str}' is infeasible "
+                                f"Step '{step_str}' is infeasible "
                                 "due to exceeded bounds at initial conditions. "
                                 "If this step is part of a longer cycle, "
                                 "round brackets should be used to indicate this, "
@@ -894,9 +780,7 @@ class Simulation:
                                 "])"
                             )
                         else:
-                            this_cycle = self.experiment.operating_conditions_cycles[
-                                cycle_num - 1
-                            ]
+                            this_cycle = self.experiment.cycles[cycle_num - 1]
                             raise pybamm.SolverError(
                                 f"All steps in the cycle {this_cycle} are infeasible "
                                 "due to exceeded bounds at initial conditions."
@@ -959,8 +843,8 @@ class Simulation:
         return self.solution
 
     def run_padding_rest(self, kwargs, rest_time, step_solution):
-        model = self.op_conds_to_built_models["Rest for padding"]
-        solver = self.op_conds_to_built_solvers["Rest for padding"]
+        model = self.steps_to_built_models["Rest for padding"]
+        solver = self.steps_to_built_solvers["Rest for padding"]
 
         # Make sure we take at least 2 timesteps. The period is hardcoded to 10
         # minutes,the user can always override it by adding a rest step
@@ -1169,8 +1053,8 @@ class Simulation:
         ):
             self._solver.integrator_specs = {}
 
-        if self.op_conds_to_built_solvers is not None:
-            for solver in self.op_conds_to_built_solvers.values():
+        if self.steps_to_built_solvers is not None:
+            for solver in self.steps_to_built_solvers.values():
                 if (
                     isinstance(solver, pybamm.CasadiSolver)
                     and solver.integrator_specs != {}


Test patch:
diff --git a/tests/unit/test_batch_study.py b/tests/unit/test_batch_study.py
index 347191441..ab7370a19 100644
--- a/tests/unit/test_batch_study.py
+++ b/tests/unit/test_batch_study.py
@@ -64,10 +64,9 @@ class TestBatchStudy(TestCase):
             solvers_list = [solver.name for solver in bs_false.solvers.values()]
             self.assertIn(output_solver, solvers_list)
 
-            output_experiment = bs_false.sims[num].experiment.operating_conditions_steps
+            output_experiment = bs_false.sims[num].experiment.steps
             experiments_list = [
-                experiment.operating_conditions_steps
-                for experiment in bs_false.experiments.values()
+                experiment.steps for experiment in bs_false.experiments.values()
             ]
             self.assertIn(output_experiment, experiments_list)
 
@@ -84,10 +83,9 @@ class TestBatchStudy(TestCase):
             solvers_list = [solver.name for solver in bs_true.solvers.values()]
             self.assertIn(output_solver, solvers_list)
 
-            output_experiment = bs_true.sims[num].experiment.operating_conditions_steps
+            output_experiment = bs_true.sims[num].experiment.steps
             experiments_list = [
-                experiment.operating_conditions_steps
-                for experiment in bs_true.experiments.values()
+                experiment.steps for experiment in bs_true.experiments.values()
             ]
             self.assertIn(output_experiment, experiments_list)
 
diff --git a/tests/unit/test_experiments/test_experiment.py b/tests/unit/test_experiments/test_experiment.py
index 151b9658c..93713a76d 100644
--- a/tests/unit/test_experiments/test_experiment.py
+++ b/tests/unit/test_experiments/test_experiment.py
@@ -17,11 +17,11 @@ class TestExperiment(TestCase):
             ]
         )
         self.assertEqual(
-            [step.to_dict() for step in experiment.operating_conditions_steps],
+            [step.to_dict() for step in experiment.steps],
             [
                 {
                     "value": 0.05,
-                    "type": "C-rate",
+                    "type": "CRate",
                     "duration": 1800.0,
                     "period": 60.0,
                     "temperature": None,
@@ -32,7 +32,7 @@ class TestExperiment(TestCase):
                 },
                 {
                     "value": -0.2,
-                    "type": "C-rate",
+                    "type": "CRate",
                     "duration": 2700.0,
                     "period": 60.0,
                     "temperature": None,
@@ -43,7 +43,7 @@ class TestExperiment(TestCase):
                 },
                 {
                     "value": 0.05,
-                    "type": "C-rate",
+                    "type": "CRate",
                     "duration": 1800.0,
                     "period": 60.0,
                     "temperature": None,
@@ -54,7 +54,7 @@ class TestExperiment(TestCase):
                 },
                 {
                     "value": -0.2,
-                    "type": "C-rate",
+                    "type": "CRate",
                     "duration": 2700.0,
                     "period": 60.0,
                     "temperature": None,
@@ -92,11 +92,11 @@ class TestExperiment(TestCase):
 
     def test_bad_strings(self):
         with self.assertRaisesRegex(
-            TypeError, "Operating conditions should be strings or _Step objects"
+            TypeError, "Operating conditions must be a Step object or string."
         ):
             pybamm.Experiment([1, 2, 3])
         with self.assertRaisesRegex(
-            TypeError, "Operating conditions should be strings or _Step objects"
+            TypeError, "Operating conditions must be a Step object or string."
         ):
             pybamm.Experiment([(1, 2, 3)])
 
@@ -186,22 +186,22 @@ class TestExperiment(TestCase):
             )
 
     def test_set_next_start_time(self):
-        raw_op = [
-            pybamm.step._Step(
-                "current", 1, duration=3600, start_time=datetime(2023, 1, 1, 8, 0)
+        raw_steps = [
+            pybamm.step.Current(
+                1, duration=3600, start_time=datetime(2023, 1, 1, 8, 0)
             ),
-            pybamm.step._Step("voltage", 2.5, duration=3600, start_time=None),
-            pybamm.step._Step(
-                "current", 1, duration=3600, start_time=datetime(2023, 1, 1, 12, 0)
+            pybamm.step.Voltage(2.5, duration=3600, start_time=None),
+            pybamm.step.Current(
+                1, duration=3600, start_time=datetime(2023, 1, 1, 12, 0)
             ),
-            pybamm.step._Step("current", 1, duration=3600, start_time=None),
-            pybamm.step._Step("voltage", 2.5, duration=3600, start_time=None),
-            pybamm.step._Step(
-                "current", 1, duration=3600, start_time=datetime(2023, 1, 1, 15, 0)
+            pybamm.step.Current(1, duration=3600, start_time=None),
+            pybamm.step.Voltage(2.5, duration=3600, start_time=None),
+            pybamm.step.Current(
+                1, duration=3600, start_time=datetime(2023, 1, 1, 15, 0)
             ),
         ]
-        experiment = pybamm.Experiment(raw_op)
-        processed_op = experiment._set_next_start_time(raw_op)
+        experiment = pybamm.Experiment(raw_steps)
+        processed_steps = experiment._set_next_start_time(raw_steps)
 
         expected_next = [
             None,
@@ -222,10 +222,10 @@ class TestExperiment(TestCase):
         ]
 
         # Test method directly
-        for next, end, op in zip(expected_next, expected_end, processed_op):
+        for next, end, steps in zip(expected_next, expected_end, processed_steps):
             # useful form for debugging
-            self.assertEqual(op.next_start_time, next)
-            self.assertEqual(op.end_time, end)
+            self.assertEqual(steps.next_start_time, next)
+            self.assertEqual(steps.end_time, end)
 
         # TODO: once #3176 is completed, the test should pass for
         # operating_conditions_steps (or equivalent) as well
diff --git a/tests/unit/test_experiments/test_experiment_steps.py b/tests/unit/test_experiments/test_experiment_steps.py
index 7fc21bc14..9d1abcc13 100644
--- a/tests/unit/test_experiments/test_experiment_steps.py
+++ b/tests/unit/test_experiments/test_experiment_steps.py
@@ -5,13 +5,11 @@ import pybamm
 import unittest
 import numpy as np
 from datetime import datetime
-from pybamm.experiment.step import _Step
 
 
 class TestExperimentSteps(unittest.TestCase):
     def test_step(self):
-        step = pybamm.step._Step("current", 1, duration=3600)
-        self.assertEqual(step.type, "current")
+        step = pybamm.step.current(1, duration=3600)
         self.assertEqual(step.value, 1)
         self.assertEqual(step.duration, 3600)
         self.assertEqual(step.termination, [])
@@ -22,8 +20,7 @@ class TestExperimentSteps(unittest.TestCase):
         self.assertEqual(step.end_time, None)
         self.assertEqual(step.next_start_time, None)
 
-        step = pybamm.step._Step(
-            "voltage",
+        step = pybamm.step.voltage(
             1,
             duration="1h",
             termination="2.5V",
@@ -32,7 +29,6 @@ class TestExperimentSteps(unittest.TestCase):
             tags="test",
             start_time=datetime(2020, 1, 1, 0, 0, 0),
         )
-        self.assertEqual(step.type, "voltage")
         self.assertEqual(step.value, 1)
         self.assertEqual(step.duration, 3600)
         self.assertEqual(step.termination, [pybamm.step.VoltageTermination(2.5)])
@@ -41,42 +37,36 @@ class TestExperimentSteps(unittest.TestCase):
         self.assertEqual(step.tags, ["test"])
         self.assertEqual(step.start_time, datetime(2020, 1, 1, 0, 0, 0))
 
-        step = pybamm.step._Step("current", 1, temperature="298K")
+        step = pybamm.step.current(1, temperature="298K")
         self.assertEqual(step.temperature, 298)
 
         with self.assertRaisesRegex(ValueError, "temperature units"):
-            step = pybamm.step._Step("current", 1, temperature="298T")
+            step = pybamm.step.current(1, temperature="298T")
 
     def test_specific_steps(self):
         current = pybamm.step.current(1)
-        self.assertIsInstance(current, pybamm.step._Step)
-        self.assertEqual(current.type, "current")
+        self.assertIsInstance(current, pybamm.step.Current)
         self.assertEqual(current.value, 1)
         self.assertEqual(str(current), repr(current))
 
         c_rate = pybamm.step.c_rate(1)
-        self.assertIsInstance(c_rate, pybamm.step._Step)
-        self.assertEqual(c_rate.type, "C-rate")
+        self.assertIsInstance(c_rate, pybamm.step.CRate)
         self.assertEqual(c_rate.value, 1)
 
         voltage = pybamm.step.voltage(1)
-        self.assertIsInstance(voltage, pybamm.step._Step)
-        self.assertEqual(voltage.type, "voltage")
+        self.assertIsInstance(voltage, pybamm.step.Voltage)
         self.assertEqual(voltage.value, 1)
 
         rest = pybamm.step.rest()
-        self.assertIsInstance(rest, pybamm.step._Step)
-        self.assertEqual(rest.type, "current")
+        self.assertIsInstance(rest, pybamm.step.Current)
         self.assertEqual(rest.value, 0)
 
         power = pybamm.step.power(1)
-        self.assertIsInstance(power, pybamm.step._Step)
-        self.assertEqual(power.type, "power")
+        self.assertIsInstance(power, pybamm.step.Power)
         self.assertEqual(power.value, 1)
 
         resistance = pybamm.step.resistance(1)
-        self.assertIsInstance(resistance, pybamm.step._Step)
-        self.assertEqual(resistance.type, "resistance")
+        self.assertIsInstance(resistance, pybamm.step.Resistance)
         self.assertEqual(resistance.value, 1)
 
     def test_step_string(self):
@@ -98,80 +88,80 @@ class TestExperimentSteps(unittest.TestCase):
 
         expected_result = [
             {
-                "type": "C-rate",
+                "type": "CRate",
                 "value": 1.0,
                 "duration": 1800.0,
                 "termination": [],
             },
             {
-                "type": "C-rate",
+                "type": "CRate",
                 "value": 0.05,
                 "duration": 3600.0,
                 "termination": [],
                 "period": 120,
             },
             {
-                "type": "C-rate",
+                "type": "CRate",
                 "value": -0.5,
                 "duration": 2700.0,
                 "termination": [],
             },
             {
                 "value": 1.0,
-                "type": "current",
+                "type": "Current",
                 "duration": 1800.0,
                 "termination": [],
             },
             {
                 "value": -0.2,
-                "type": "current",
+                "type": "Current",
                 "duration": 2700.0,
                 "termination": [],
             },
             {
                 "value": 1.0,
-                "type": "power",
+                "type": "Power",
                 "duration": 1800.0,
                 "termination": [],
             },
             {
                 "value": -0.2,
-                "type": "power",
+                "type": "Power",
                 "duration": 2700.0,
                 "termination": [],
             },
             {
                 "value": 0,
-                "type": "current",
+                "type": "Current",
                 "duration": 600.0,
                 "termination": [],
             },
             {
                 "value": 1,
-                "type": "voltage",
+                "type": "Voltage",
                 "duration": 20.0,
                 "termination": [],
             },
             {
-                "type": "C-rate",
+                "type": "CRate",
                 "value": -1,
-                "duration": None,
+                "duration": 86400,
                 "termination": [pybamm.step.VoltageTermination(4.1)],
             },
             {
                 "value": 4.1,
-                "type": "voltage",
-                "duration": None,
+                "type": "Voltage",
+                "duration": 86400,
                 "termination": [pybamm.step.CurrentTermination(0.05)],
             },
             {
                 "value": 3,
-                "type": "voltage",
-                "duration": None,
+                "type": "Voltage",
+                "duration": 86400,
                 "termination": [pybamm.step.CrateTermination(0.02)],
             },
             {
-                "type": "C-rate",
+                "type": "CRate",
                 "value": 1 / 3,
                 "duration": 7200.0,
                 "termination": [pybamm.step.VoltageTermination(2.5)],
@@ -199,7 +189,6 @@ class TestExperimentSteps(unittest.TestCase):
         # Create steps
         drive_cycle_step = pybamm.step.current(drive_cycle, temperature="-5oC")
         # Check drive cycle operating conditions
-        self.assertEqual(drive_cycle_step.type, "current")
         self.assertEqual(drive_cycle_step.duration, 9)
         self.assertEqual(drive_cycle_step.period, 1)
         self.assertEqual(drive_cycle_step.temperature, 273.15 - 5)
@@ -218,7 +207,6 @@ class TestExperimentSteps(unittest.TestCase):
             drive_cycle, duration=20, temperature="-5oC"
         )
         # Check drive cycle operating conditions
-        self.assertEqual(drive_cycle_step.type, "current")
         self.assertEqual(drive_cycle_step.duration, 20)
         self.assertEqual(drive_cycle_step.period, 1)
         self.assertEqual(drive_cycle_step.temperature, 273.15 - 5)
@@ -229,7 +217,6 @@ class TestExperimentSteps(unittest.TestCase):
             drive_cycle, duration=5, temperature="-5oC"
         )
         # Check drive cycle operating conditions
-        self.assertEqual(drive_cycle_step.type, "current")
         self.assertEqual(drive_cycle_step.duration, 5)
         self.assertEqual(drive_cycle_step.period, 1)
         self.assertEqual(drive_cycle_step.temperature, 273.15 - 5)
@@ -256,14 +243,14 @@ class TestExperimentSteps(unittest.TestCase):
 
     def test_start_times(self):
         # Test start_times
-        step = pybamm.step._Step(
-            "current", 1, duration=3600, start_time=datetime(2020, 1, 1, 0, 0, 0)
+        step = pybamm.step.current(
+            1, duration=3600, start_time=datetime(2020, 1, 1, 0, 0, 0)
         )
         self.assertEqual(step.start_time, datetime(2020, 1, 1, 0, 0, 0))
 
         # Test bad start_times
         with self.assertRaisesRegex(TypeError, "`start_time` should be"):
-            pybamm.step._Step("current", 1, duration=3600, start_time="bad start_time")
+            pybamm.step.current(1, duration=3600, start_time="bad start_time")
 
     def test_custom_termination(self):
         def neg_stoich_cutoff(variables):
@@ -282,7 +269,39 @@ class TestExperimentSteps(unittest.TestCase):
         t = np.array([[1, 1], [2, 2], [3, 3]])
 
         with self.assertRaisesRegex(ValueError, "Drive cycle must start at t=0"):
-            _Step("current", t)
+            pybamm.step.current(t)
+
+    def test_base_custom_steps(self):
+        with self.assertRaises(NotImplementedError):
+            pybamm.step.BaseStepExplicit(None).current_value(None)
+        with self.assertRaises(NotImplementedError):
+            pybamm.step.BaseStepImplicit(None).get_submodel(None)
+
+    def test_custom_steps(self):
+        def custom_step_constant(variables):
+            return 1
+
+        custom_constant = pybamm.step.CustomStepExplicit(custom_step_constant)
+
+        self.assertEqual(custom_constant.current_value_function({}), 1)
+
+        def custom_step_voltage(variables):
+            return variables["Voltage [V]"] - 4.1
+
+        custom_step_alg = pybamm.step.CustomStepImplicit(custom_step_voltage)
+
+        self.assertEqual(custom_step_alg.control, "algebraic")
+        self.assertAlmostEqual(
+            custom_step_alg.current_rhs_function({"Voltage [V]": 4.2}), 0.1
+        )
+
+        custom_step_diff = pybamm.step.CustomStepImplicit(
+            custom_step_voltage, control="differential"
+        )
+        self.assertEqual(custom_step_diff.control, "differential")
+
+        with self.assertRaisesRegex(ValueError, "control must be"):
+            pybamm.step.CustomStepImplicit(custom_step_voltage, control="bla")
 
 
 if __name__ == "__main__":
diff --git a/tests/unit/test_experiments/test_simulation_with_experiment.py b/tests/unit/test_experiments/test_simulation_with_experiment.py
index c48b464b1..16829bfae 100644
--- a/tests/unit/test_experiments/test_simulation_with_experiment.py
+++ b/tests/unit/test_experiments/test_simulation_with_experiment.py
@@ -23,27 +23,14 @@ class TestSimulationExperiment(TestCase):
         model = pybamm.lithium_ion.SPM()
         sim = pybamm.Simulation(model, experiment=experiment)
         sim.build_for_experiment()
-        C = model.default_parameter_values["Nominal cell capacity [A.h]"]
 
         self.assertEqual(sim.experiment.args, experiment.args)
-        op_conds = sim.experiment.operating_conditions_steps
-        self.assertEqual(op_conds[0].value, C / 20)
-        self.assertEqual(op_conds[1].value, -1)
-        self.assertEqual(op_conds[2].value, 4.1)
-        self.assertEqual(op_conds[3].value, 2)
-
-        Crate = 1 / C
-        self.assertEqual(
-            [op.duration for op in op_conds],
-            [3600, 3 / Crate * 3600, 24 * 3600, 24 * 3600],
-        )
+        steps = sim.experiment.steps
 
         model_I = sim.experiment_unique_steps_to_model[
-            op_conds[1].basic_repr()
+            steps[1].basic_repr()
         ]  # CC charge
-        model_V = sim.experiment_unique_steps_to_model[
-            op_conds[2].basic_repr()
-        ]  # CV hold
+        model_V = sim.experiment_unique_steps_to_model[steps[2].basic_repr()]  # CV hold
         self.assertIn(
             "Current cut-off [A] [experiment]",
             [event.name for event in model_V.events],
@@ -62,9 +49,9 @@ class TestSimulationExperiment(TestCase):
 
         sim = pybamm.Simulation(model, experiment="Discharge at C/20 for 1 hour")
         sim.build_for_experiment()
-        self.assertEqual(len(sim.experiment.operating_conditions_steps), 1)
+        self.assertEqual(len(sim.experiment.steps), 1)
         self.assertEqual(
-            sim.experiment.operating_conditions_steps[0].description,
+            sim.experiment.steps[0].description,
             "Discharge at C/20 for 1 hour",
         )
         sim = pybamm.Simulation(
@@ -72,7 +59,7 @@ class TestSimulationExperiment(TestCase):
             experiment=["Discharge at C/20 for 1 hour", pybamm.step.rest(60)],
         )
         sim.build_for_experiment()
-        self.assertEqual(len(sim.experiment.operating_conditions_steps), 2)
+        self.assertEqual(len(sim.experiment.steps), 2)
 
     def test_run_experiment(self):
         s = pybamm.step.string
@@ -82,7 +69,8 @@ class TestSimulationExperiment(TestCase):
                     s("Discharge at C/20 for 1 hour", temperature="30.5oC"),
                     s("Charge at 1 A until 4.1 V", temperature="24oC"),
                     s("Hold at 4.1 V until C/2", temperature="24oC"),
-                    "Discharge at 2 W for 1 hour",
+                    "Discharge at 2 W for 10 minutes",
+                    "Discharge at 4 Ohm for 10 minutes",
                 )
             ],
             temperature="-14oC",
@@ -103,6 +91,9 @@ class TestSimulationExperiment(TestCase):
         np.testing.assert_array_almost_equal(
             sol.cycles[0].steps[3]["Power [W]"].data, 2, decimal=5
         )
+        np.testing.assert_array_almost_equal(
+            sol.cycles[0].steps[4]["Resistance [Ohm]"].data, 4, decimal=5
+        )
 
         np.testing.assert_array_equal(
             sol.cycles[0].steps[0]["Ambient temperature [C]"].data[0], 30.5
@@ -220,7 +211,7 @@ class TestSimulationExperiment(TestCase):
         sim = pybamm.Simulation(model, experiment=experiment)
         sim.build_for_experiment()
         self.assertEqual(
-            sorted([repr(step) for step in experiment.operating_conditions_steps]),
+            sorted([step.basic_repr() for step in experiment.steps]),
             sorted(list(sim.experiment_unique_steps_to_model.keys())),
         )
 
@@ -776,13 +767,47 @@ class TestSimulationExperiment(TestCase):
         sim.solve(calc_esoh=False)
 
         # Check that there are 4 steps
-        self.assertEqual(len(experiment.operating_conditions_steps), 4)
+        self.assertEqual(len(experiment.steps), 4)
 
         # Check that there are only 2 unique steps
         self.assertEqual(len(sim.experiment.unique_steps), 2)
 
         # Check that there are only 3 built models (unique steps + padding rest)
-        self.assertEqual(len(sim.op_conds_to_built_models), 3)
+        self.assertEqual(len(sim.steps_to_built_models), 3)
+
+    def test_experiment_custom_steps(self):
+        model = pybamm.lithium_ion.SPM()
+
+        # Explicit control
+        def custom_step_constant(variables):
+            return 1
+
+        custom_constant = pybamm.step.CustomStepExplicit(
+            custom_step_constant, duration=1, period=0.1
+        )
+
+        experiment = pybamm.Experiment([custom_constant])
+        sim = pybamm.Simulation(model, experiment=experiment)
+        sol = sim.solve()
+        np.testing.assert_array_equal(sol["Current [A]"].data, 1)
+
+        # Implicit control (algebraic)
+        def custom_step_voltage(variables):
+            return 100 * (variables["Voltage [V]"] - 4.2)
+
+        for control in ["differential"]:
+            with self.subTest(control=control):
+                custom_step_alg = pybamm.step.CustomStepImplicit(
+                    custom_step_voltage, control=control, duration=100, period=10
+                )
+
+                experiment = pybamm.Experiment([custom_step_alg])
+                sim = pybamm.Simulation(model, experiment=experiment)
+                sol = sim.solve()
+                # sol.plot()
+                np.testing.assert_array_almost_equal(
+                    sol["Voltage [V]"].data[2:], 4.2, decimal=3
+                )
 
     def test_experiment_custom_termination(self):
         def neg_stoich_cutoff(variables):