battery_data_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d6a6cabf",
   "metadata": {},
   "outputs": [],
   "source": [
    "####################Implementing the Kalman Filter Method####################################\n",
    "import pybamm\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "pybamm.set_logging_level('INFO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fa731d7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverses the order of a list\n",
    "# input: any list\n",
    "# returns: the reversed-order list\n",
    "def flipList(inputList):\n",
    "    flippedList = list()\n",
    "    for i in range(len(inputList)):\n",
    "        flippedList.append(inputList[len(inputList) - i - 1])\n",
    "    return flippedList\n",
    "\n",
    "\n",
    "# Combines two lists to form a np.array\n",
    "# inputs: two lists of x and y values\n",
    "# returns: the np.array of the x and y values\n",
    "def createArray(listX, listY):\n",
    "    newList = list()\n",
    "    for i in range(len(listX)):\n",
    "        newList.append([listX[i], listY[i]])\n",
    "    return np.array(newList)\n",
    "\n",
    "\n",
    "# Creates a list of the modeled nth order polynomial fit values\n",
    "# input: order n of the polynomial fit, list of experimental x values, list of experimental y values\n",
    "# returns: a list of the modeled y-values using the polynomial fit\n",
    "def getPolyFitValues(order, xList, yList):\n",
    "    coefficients = np.polyfit(xList, yList, order)\n",
    "    modeledValues = list()\n",
    "    for x in xList:\n",
    "        yVal = 0\n",
    "        i = 0\n",
    "        while order - i >= 0:\n",
    "            yVal += coefficients[i] * x ** (order - i)\n",
    "            i += 1\n",
    "        modeledValues.append(yVal)\n",
    "    return modeledValues\n",
    "\n",
    "\n",
    "# Finds the chi-square value for experimental and modeled values\n",
    "# inputs: list of experimental x-values, list of experimental y-values, list of modeled y-values\n",
    "# returns: the chi-squared value\n",
    "def getChiSquaredValue(experimentalValues, modeledValues):\n",
    "    # Calculate the chi-squared value\n",
    "    totalChiSquared = 0\n",
    "    for i in range(len(experimentalValues)):\n",
    "        expectedValue = modeledValues[i]\n",
    "        observedValue = experimentalValues[i]\n",
    "        if expectedValue != 0:\n",
    "            totalChiSquared += abs(((observedValue - expectedValue)**2) / expectedValue)\n",
    "        elif abs(observedValue - expectedValue) <= 0.000001:\n",
    "            totalChiSquared += 0\n",
    "        else:\n",
    "            totalChiSquared += (observedValue + expectedValue)**2\n",
    "    return totalChiSquared\n",
    "\n",
    "\n",
    "# Finds the optimal order n of a polynomial fit using minimum chi-square analysis\n",
    "# inputs: a list of experimental x values (OCV measurements) and list of experimental y values (normalized SoC)\n",
    "# returns: a list object of [order n, chi-squared value of the nth order fit], where n is the optimal order fit\n",
    "def findOptimalOrderFit(xValues, yValues):\n",
    "    # Only checks order n=1:8 to minimize compute time\n",
    "    n = 1\n",
    "    chiSquaredResults = list()\n",
    "    while n <= 8:\n",
    "        currentChiSquared = getChiSquaredValue(yValues, getPolyFitValues(n, xValues, yValues))\n",
    "        chiSquaredResults.append([n, currentChiSquared])\n",
    "        n += 1\n",
    "    # find the minimum order n\n",
    "    minIndex = 0\n",
    "    minChiSquared = 1000000000.0\n",
    "    for i in range(len(chiSquaredResults)):\n",
    "        if chiSquaredResults[i][1] < minChiSquared:\n",
    "            minChiSquared = chiSquaredResults[i][1]\n",
    "            minIndex = i\n",
    "    # the returned object is of the form [order n, chi-squared value]\n",
    "    return chiSquaredResults[minIndex]\n",
    "\n",
    "\n",
    "# Prints the optimal order n, chi-squared value of the fit, and coefficients of the polynomial fit\n",
    "# inputs: the chiSquaredResults output of findOptimalOrderFit(), a list of experimental x values (OCV measurements),\n",
    "#         and list of experimental y values (normalized SoC)\n",
    "# returns: none\n",
    "def printFittingResults(chiSquaredResults, xValues, yValues):\n",
    "    # prints the optimal order n\n",
    "    print(\"Optimal Order Fit:\", chiSquaredResults[0])\n",
    "    # prints the chi-squared value of the fit\n",
    "    print(\"Chi-Squared Value:\", chiSquaredResults[1])\n",
    "    # prints the coefficients of the optimal fit\n",
    "    print(\"Coefficients:\")\n",
    "    coefficientList = np.polyfit(xValues, yValues, chiSquaredResults[0])\n",
    "    order = chiSquaredResults[0]\n",
    "    for i in range(len(coefficientList)):\n",
    "        print(\"\\tx^\" + str(order - i) +\":\", coefficientList[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9d2fbdeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BatteryPolynomialFit:\n",
    "    \n",
    "    def __init__(self, battery_model, parameter_values):\n",
    "        self.model = battery_model\n",
    "        self.parameter_values = parameter_values\n",
    "        self.Vmax = self.parameter_values['Upper voltage cut-off [V]']\n",
    "        self.Vmin = self.parameter_values['Lower voltage cut-off [V]']\n",
    "        self._voltage_reading_final = None\n",
    "        self._normalized_SoC = None\n",
    "        self._modeled_values = None\n",
    "        self._coefficients_list = None\n",
    "        self._main_solution = None\n",
    "        self._last_solution = None\n",
    "    \n",
    "        self.calculate_coefficients()\n",
    "    \n",
    "    def calculate_coefficients(self):\n",
    "        experiment = pybamm.Experiment([(\n",
    "            f\"Charge at 1C until {self.Vmax}V\",\n",
    "            f\"Discharge at 1C until {self.Vmin}V\",\n",
    "            f\"Charge at 1C until {self.Vmin + ((self.Vmax - self.Vmin) / 2)}V\"\n",
    "#             f'Discharge at C/20 until {self.Vmin} V',\n",
    "#             'Rest for 4 hours',\n",
    "#             f'Charge at 0.2 C until {self.Vmax} V',\n",
    "#             f'Discharge at C/20 until {self.Vmin} V',\n",
    "#             f'Charge at 0.2 C until {self.Vmin + ((self.Vmax - self.Vmin) / 2)} V'\n",
    "        )])\n",
    "\n",
    "        simulation = pybamm.Simulation(\n",
    "            model=self.model, \n",
    "            experiment=experiment, \n",
    "            parameter_values=self.parameter_values\n",
    "        )\n",
    "        self._main_solution = simulation.solve()\n",
    "        sol = self._main_solution\n",
    "        \n",
    "        # Set last solution to the last step in the experiment\n",
    "        self._last_solution = self._main_solution.cycles[0].steps[2]\n",
    "        \n",
    "        # Get the discharge step\n",
    "        discharge_step = sol.cycles[0].steps[1]\n",
    "        \n",
    "        # Get the values of discharge capacity and OCV for the discharge step \n",
    "        measurements_adjusted = discharge_step['Discharge capacity [A.h]'].entries\n",
    "        voltage_reading_final = flipList(discharge_step['Measured open circuit voltage [V]'].entries)\n",
    "\n",
    "        num_measurements = len(measurements_adjusted)\n",
    "        increment = 100.0/num_measurements\n",
    "        normalized_SoC = list()\n",
    "        tempI = 0\n",
    "        while tempI < num_measurements:\n",
    "            normalized_SoC.append(tempI*increment)\n",
    "            tempI += 1\n",
    "\n",
    "\n",
    "        # Finds the optimal order n of a polynomial fit of the data using minimum chi-square analysis\n",
    "        optimal_fit_values = findOptimalOrderFit(voltage_reading_final, normalized_SoC)\n",
    "        optimal_order = optimal_fit_values[0]\n",
    "\n",
    "        # Creates a list of modeled SoC values using the optimal polynomial fit, used for plotting\n",
    "        modeled_values = getPolyFitValues(optimal_order, voltage_reading_final, normalized_SoC)\n",
    "        \n",
    "        print(\"\\nFITTING RESULTS\")\n",
    "        print(\"---------------\")\n",
    "        printFittingResults(optimal_fit_values, voltage_reading_final, normalized_SoC)\n",
    "        \n",
    "        # Calculate the coefficient list\n",
    "        coefficients_list = np.polyfit(voltage_reading_final, normalized_SoC, optimal_fit_values[0])\n",
    "        \n",
    "        self._coefficients_list = coefficients_list\n",
    "        self._modeled_values = modeled_values\n",
    "        self._normalized_SoC = normalized_SoC\n",
    "        self._voltage_reading_final = voltage_reading_final\n",
    "        \n",
    "    \n",
    "    def plot_polynomial_fit(self):\n",
    "        plt.plot(self.voltage_reading_final, self.normalized_SoC, label='Experimental Data')\n",
    "        # Plots the modeled values using the polynomial fit for SoC vs OCV\n",
    "        plt.plot(self.voltage_reading_final, self.modeled_values, label='Polynomial Fit')\n",
    "        plt.legend(loc='best')\n",
    "        plt.ylabel('State of Charge (%)')\n",
    "        plt.xlabel('Cell Voltage (V)')\n",
    "        plt.title(\"Battery State of Charge (SoC) vs\\nOpen Circuit Voltage (OCV)\", fontweight='bold')\n",
    "        plt.grid(True)\n",
    "        # Adjust spacing of subplots\n",
    "        plt.subplots_adjust(wspace=0.35)\n",
    "        plt.show()\n",
    "        \n",
    "    @property\n",
    "    def last_solution(self):\n",
    "        return self._last_solution\n",
    "    \n",
    "    @property\n",
    "    def coefficients_list(self):\n",
    "        return self._coefficients_list\n",
    "    \n",
    "    @property\n",
    "    def modeled_values(self):\n",
    "        return self._modeled_values\n",
    "    \n",
    "    @property\n",
    "    def normalized_SoC(self):\n",
    "        return self._normalized_SoC\n",
    "    \n",
    "    @property\n",
    "    def voltage_reading_final(self):\n",
    "        return self._voltage_reading_final"
   ]
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}