fuzzy-based-spaf.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fuzzy Based Shunt Power Active Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Plan Of Attack**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Understanding Role of Fuzzy in SPAF Setup**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- _Used as DC-Link Capacitor Voltage Algorithm_\n",
    "- _Capacitor Voltage, `Vc` is taken as `14v`, ( [refer ijsert page6](http://www.ijesrt.com/issues%20pdf%20file/Archive-2018/June-2018/64.pdf) )_\n",
    "- _A voltage is measured after the shunt and before Fuzzy, `Vm`_\n",
    "- _Resistor of `0.1 Ohm` is taken due to impedence_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Crafting Fuzzy Sets**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**_Input Set_**\n",
    "\n",
    "There are two sets: _Set1, Set2_\n",
    "\n",
    "*Set1* : Set of errors (`E`) are collected between `Vc` and `Vm` at a specific point of time `t`, given by:\n",
    "\n",
    "```bash\n",
    "                                   E = Vc - Vm\n",
    "```\n",
    "\n",
    "*Set2* : Set of errors described by (`dE`):\n",
    "\n",
    "```bash\n",
    "                                dE = E(t) - E(t-1)\n",
    "                                \n",
    "                                        or\n",
    "                                        \n",
    "                                dE = E - d(E)/dt\n",
    "\n",
    "```\n",
    "\n",
    "**_Output Set_**\n",
    "\n",
    "The output set is a crisp value (percentage) of the current produced with effective magnitude: `Ic`. The range of `Ic` can be easily calculated from `Vc` assuming the shunt has a resistance of `0.1 Ohm` (caused by impedance).\n",
    "\n",
    "Since the `E` range is from 7 to 14, `Vc` is 14V, `Ic` can be calculated by:\n",
    "\n",
    "```bash\n",
    "                                Ic = x ∈ {(Vc-Vm) / R}\n",
    "```\n",
    "\n",
    "**Fuzzy Set Ranges**\n",
    "\n",
    "_E Range_:\n",
    "\n",
    "The experimentally permitted range is : `E = {7 to 14}`\n",
    "\n",
    "_dE Range_:\n",
    "\n",
    "The expereimentally feasible range is : `dE = {-0.4 to 0.5}`\n",
    "\n",
    "_Ic Range_:\n",
    "\n",
    "The range acquired by calculation from above : `Ic = {0 to 70}`\n",
    "\n",
    "> All ranges are being refered from [ijsert-page3](http://www.ijesrt.com/issues%20pdf%20file/Archive-2018/June-2018/64.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Chosing Fuzzy Inference System**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using _SKFuzzy `control.ControlSystem`_ which defaults to _Mamdani Inference System_ with defuzzification using _centroid_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Coding**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- _Defining universe_\n",
    "- _Initializing Antecedents, Consequents fuzzy variables_\n",
    "- _Populate the universe with membership functions_\n",
    "- _Rule Writing_\n",
    "- _Control System + Simulation (Mamdani Inference System)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### main"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import skfuzzy as fuzz\n",
    "from skfuzzy import control as ctrl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#E = np.linspace(7,14)\n",
    "#dE = np.linspace(-0.4,0.4)\n",
    "\n",
    "Vc = 14\n",
    "R = 0.1\n",
    "\n",
    "# inputs\n",
    "E = ctrl.Antecedent(np.arange(7,14), 'Error')\n",
    "dE = ctrl.Antecedent(np.linspace(-0.4, 0.5), 'Rate of Error')\n",
    "print(dE)\n",
    "\n",
    "# output\n",
    "\n",
    "Ic_minimum = (Vc - 14) / 0.1      # when capacitor is not charged initially\n",
    "Ic_maximum = (Vc - 7) / 0.1       # when capacitor is full charged\n",
    "Ic = ctrl.Consequent(np.arange(Ic_minimum, Ic_maximum), 'Current Output', defuzzify_method='centroid')\n",
    "\n",
    "# membership functions\n",
    "memberships = ['NL','NM','NS','EZ','PS','PM','PL']\n",
    "\n",
    "# for E\n",
    "E.automf(names=memberships)\n",
    "\n",
    "# for dE\n",
    "dE.automf(names = memberships)\n",
    "\n",
    "# for Ic\n",
    "Ic.automf(names=memberships)\n",
    "Ic['NL'] = fuzz.trapmf(Ic.universe, [0,0,5,10])\n",
    "Ic['PL'] = fuzz.trapmf(Ic.universe, [60,65,70,70]) # refer ijsert\n",
    "\n",
    "# view membership graphs\n",
    "E.view()\n",
    "dE.view()\n",
    "Ic.view()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### rule writing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we have a pair of `Antecedents` and one `Consequent` of 7 memberships each, We will have to write a proper 7 rules connecting `Antecedent` to `Consequent` properly.\n",
    "\n",
    "Rules have been provided in a tabular form in the [scholarly article](https://moscow.ggws.net/2159/5f5f49fbfb670fca04480df52ac3ce71/mekri2006.pdf#navpanes=0&view=FitH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rule0 = ctrl.Rule(antecedent=( (dE['NL'] & E['NL']) |\n",
    "                               (dE['NL'] & E['NM']) |\n",
    "                               (dE['NL'] & E['NS']) |\n",
    "                               (dE['NL'] & E['EZ']) |\n",
    "                               (dE['NM'] & E['NL']) |\n",
    "                               (dE['NM'] & E['NM']) |\n",
    "                               (dE['NM'] & E['NS']) |\n",
    "                               (dE['NS'] & E['NL']) |\n",
    "                               (dE['NS'] & E['NM']) |\n",
    "                               (dE['EZ'] & E['NL']) \n",
    "                             ), consequent=Ic['NL'])\n",
    "\n",
    "rule1 = ctrl.Rule(antecedent=( (dE['NL'] & E['PS']) |\n",
    "                               (dE['NM'] & E['EZ']) |\n",
    "                               (dE['NS'] & E['NS']) |\n",
    "                               (dE['EZ'] & E['NM']) |\n",
    "                               (dE['PS'] & E['NL']) \n",
    "                             ), consequent=Ic['NM'])\n",
    "\n",
    "rule2 = ctrl.Rule(antecedent=( (dE['NL'] & E['PM']) |\n",
    "                               (dE['NM'] & E['PS']) |\n",
    "                               (dE['NS'] & E['EZ']) |\n",
    "                               (dE['EZ'] & E['NS']) |\n",
    "                               (dE['PS'] & E['NM']) |\n",
    "                               (dE['PM'] & E['NL']) \n",
    "                             ), consequent=Ic['NS'])\n",
    "\n",
    "rule3 = ctrl.Rule(antecedent=( (dE['NL'] & E['PL']) |\n",
    "                               (dE['NM'] & E['PM']) |\n",
    "                               (dE['NS'] & E['PS']) |\n",
    "                               (dE['EZ'] & E['EZ']) |\n",
    "                               (dE['PS'] & E['NS']) |\n",
    "                               (dE['PM'] & E['NM']) |\n",
    "                               (dE['PL'] & E['NL']) \n",
    "                             ), consequent=Ic['EZ'])\n",
    "\n",
    "rule4 = ctrl.Rule(antecedent=( (dE['PL'] & E['NM']) |\n",
    "                               (dE['PM'] & E['NS']) |\n",
    "                               (dE['PS'] & E['EZ']) |\n",
    "                               (dE['EZ'] & E['PS']) |\n",
    "                               (dE['NS'] & E['PM']) |\n",
    "                               (dE['NM'] & E['PL']) \n",
    "                             ), consequent=Ic['PS'])                                                          \n",
    "\n",
    "rule5 = ctrl.Rule(antecedent=( (dE['PL'] & E['NS']) |\n",
    "                               (dE['PM'] & E['EZ']) |\n",
    "                               (dE['PS'] & E['PS']) |\n",
    "                               (dE['EZ'] & E['PM']) |\n",
    "                               (dE['NS'] & E['PL']) \n",
    "                             ), consequent=Ic['PM'])\n",
    "\n",
    "rule6 = ctrl.Rule(antecedent=( (dE['PL'] & E['PL']) |\n",
    "                               (dE['PL'] & E['PM']) |\n",
    "                               (dE['PL'] & E['PS']) |\n",
    "                               (dE['PL'] & E['EZ']) |\n",
    "                               (dE['PM'] & E['PL']) |\n",
    "                               (dE['PM'] & E['PM']) |\n",
    "                               (dE['PM'] & E['PS']) |\n",
    "                               (dE['PS'] & E['PL']) |\n",
    "                               (dE['PS'] & E['PM']) |\n",
    "                               (dE['EZ'] & E['PL']) \n",
    "                             ), consequent=Ic['NL'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### view rules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "views = [rule0,rule1,rule2,rule3,rule4,rule5,rule6]\n",
    "\n",
    "for i in views:\n",
    "    i.view()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### control system + simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ic_control_system = ctrl.ControlSystem([rule0,rule1,rule2,rule3,rule4,rule5,rule6])\n",
    "\n",
    "Ic_output_simulation = ctrl.ControlSystemSimulation(Ic_control_system)\n",
    "\n",
    "Ic_output_simulation.inputs({'Error': 12, 'Rate of Error': -0.1}) #11.4, -0.1\n",
    "Ic_output_simulation.compute()\n",
    "\n",
    "print(Ic_output_simulation.output['Current Output'])\n",
    "Ic.view(sim=Ic_output_simulation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **References**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- mdpi-res.com/electronics\n",
    "- ijesrt scholarly article\n",
    "- moscow.ggws.net"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "63fd5069d213b44bf678585dea6b12cceca9941eaf7f819626cde1f2670de90d"
  },
  "kernelspec": {
   "display_name": "Python 3.9.5 64-bit",
   "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.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}