using_drive_cycle.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "d4fac3e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Dict, Union\n",
    "\n",
    "import simpy\n",
    "import pandas as pd\n",
    "import pybamm\n",
    "\n",
    "pybamm.set_logging_level(\"INFO\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "7e1be567",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PybammBattery:\n",
    "\n",
    "    def __init__(self, env, capacity, soc=0):\n",
    "        \"\"\"\n",
    "        'Nominal cell capacity [A.h]' is set twice the capacity provided, so that we can easily calculate the excess power.\n",
    "        Otherwise the excess energy cannot be calculated since the battery won't charge pass the capacity.\n",
    "        \"\"\"\n",
    "        self.env = env\n",
    "        self.capacity = capacity\n",
    "        self.soc = soc\n",
    "        self.excess_power = 0\n",
    "        \n",
    "        self.step_solution = None\n",
    "        self.step_solver = pybamm.CasadiSolver()\n",
    "        \n",
    "        # load model\n",
    "        self.model = pybamm.lithium_ion.SPMe()\n",
    "        \n",
    "        # create geometry\n",
    "        geometry = self.model.default_geometry\n",
    "        \n",
    "        # load parameter values and process model and geometry\n",
    "        param = self.model.default_parameter_values\n",
    "        param['Current function [A]'] = '[input]'\n",
    "        param.process_model(self.model)\n",
    "        param.process_geometry(geometry)\n",
    "        \n",
    "        # cerate mesh\n",
    "        mesh = pybamm.Mesh(geometry, self.model.default_submesh_types, self.model.default_var_pts)\n",
    "        \n",
    "        # discretise model\n",
    "        disc = pybamm.Discretisation(mesh, self.model.default_spatial_methods)\n",
    "        disc.process_model(self.model)\n",
    "        \n",
    "        # save input_parameters\n",
    "        Vmin = param['Lower voltage cut-off [V]']\n",
    "        Vmax = param['Upper voltage cut-off [V]']\n",
    "        Cn = param.evaluate(self.model.param.C_n_init)\n",
    "        Cp = param.evaluate(self.model.param.C_p_init)\n",
    "        self.input_parameters = {\"V_min\": Vmin, \"V_max\": Vmax, \"C_n\": Cn, \"C_p\": Cp}\n",
    "\n",
    "    def update(self, current):\n",
    "        if current == 0:\n",
    "            return 0;\n",
    "        \n",
    "        dt = 60\n",
    "        self.input_parameters['Current function [A]'] = current\n",
    "        self.step_solution = self.step_solver.step(self.step_solution, self.model, dt=dt, npts=2, inputs=self.input_parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "5e430ded",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate(env: simpy.Environment, battery: PybammBattery, power_delta_list: List[float], records: List[Dict]):\n",
    "    \n",
    "    for power_delta in power_delta_list:\n",
    "        yield env.timeout(1)\n",
    "        battery.update(power_delta)\n",
    "        records.append({\n",
    "            \"power_delta\": power_delta,\n",
    "            \"excess_power\": battery.excess_power,\n",
    "            \"soc\": battery.soc,\n",
    "            \"capacity [A.h]\": battery.capacity\n",
    "        })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "cefccf9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-06 16:16:08,359 - [INFO] base_battery_model.build_model(834): Start building Single Particle Model with electrolyte\n",
      "2022-04-06 16:16:08,443 - [INFO] base_battery_model.build_model(854): Finish building Single Particle Model with electrolyte\n",
      "2022-04-06 16:16:08,471 - [INFO] parameter_values.process_model(415): Start setting parameters for Single Particle Model with electrolyte\n",
      "2022-04-06 16:16:08,587 - [INFO] parameter_values.process_model(518): Finish setting parameters for Single Particle Model with electrolyte\n",
      "2022-04-06 16:16:08,589 - [INFO] discretisation.process_model(137): Start discretising Single Particle Model with electrolyte\n",
      "2022-04-06 16:16:08,849 - [INFO] discretisation.process_model(254): Finish discretising Single Particle Model with electrolyte\n",
      "2022-04-06 16:16:08,851 - [INFO] base_solver.set_up(111): Start solver set-up\n",
      "2022-04-06 16:16:08,890 - [INFO] base_solver.set_up(678): Finish solver set-up\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   power_delta  excess_power  soc  capacity [A.h]\n",
      "0            5             0    0               5\n",
      "1           -3             0    0               5\n",
      "2            2             0    0               5\n",
      "3            3             0    0               5\n",
      "4            4             0    0               5\n",
      "5           -2             0    0               5\n"
     ]
    }
   ],
   "source": [
    "# For now let's assume the simple case of one step every second where we first (dis)charge and then implicitly read.\n",
    "# Later we can extend this to a more asynchronous charge/discharge/read pattern with different processes if we want\n",
    "power_delta_list = [5, -3, 2, 3, 4, -2]\n",
    "records = []  # log of some infos for later analysis\n",
    "\n",
    "env = simpy.Environment()\n",
    "battery = PybammBattery(env, capacity=5)\n",
    "env.process(simulate(env, battery, power_delta_list, records))\n",
    "env.run()\n",
    "\n",
    "result = pd.DataFrame(records)\n",
    "with open(\"result.csv\", \"w\") as f:\n",
    "    f.write(result.to_csv())\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "a3dc5022",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0442505104809096"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "battery.model.default_parameter_values.evaluate(battery.model.param.C_p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "7759ac80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.105"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "battery.model.default_parameter_values['Lower voltage cut-off [V]']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "1876cd6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.1"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "battery.model.default_parameter_values['Upper voltage cut-off [V]']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "e509f158",
   "metadata": {},
   "outputs": [],
   "source": [
    "battery.step_solution.summary_variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "dfc5f529",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "battery.step_solution.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d09f7c85",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}