backup/node analysis_8-19-2017.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# NODE ANALYSIS PROGRAM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "```\n",
    "Python code to generate nodal equations from a circuit net list\n",
    "by Tony\n",
    "Date: April 17, 2017\n",
    "Name: network.ipynb\n",
    "Synopsis: This program will read in a spice type file and compute the node equations.\n",
    "\n",
    "Description:\n",
    "\n",
    "Requires: Python version 3 or higher\n",
    "Author: Tony Cirineo\n",
    "Revision History\n",
    "7/1/2015: Ver 1 - coding started, derived from network.c code\n",
    "8/18/2017\n",
    "change approach, now implementing a modified nodal analysis\n",
    "\n",
    "Todo\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "import os\n",
    "#import re as re\n",
    "#import sympy as sympy\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "# import matplotlib.pyplot as plt\n",
    "#init_printing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# initialize some variables\n",
    "SHORT = 1E-12\n",
    "OPEN = 1E+12\n",
    "num_passives = 0    # number of passive elements\n",
    "num_v_ind = 0    # number of independent voltage sources\n",
    "num_opamps = 0   # Number of op amps\n",
    "num_i_ind = 0    # number of independent current sources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### open file and preprocess it\n",
    "- remove blank lines and comments\n",
    "- converts all lower case to upper\n",
    "- removes extra spaces between entries\n",
    "- count number of entries on each line, make sure the count is correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "fn = 'TEST2'\n",
    "fd1 = open(fn+'.NET','r')\n",
    "content = fd1.readlines()\n",
    "content = [x.strip() for x in content]  #remove leading and trailing white space\n",
    "# remove empty lines\n",
    "while '' in content:\n",
    "    content.pop(content.index(''))\n",
    "\n",
    "# remove comment lines, these start with a asterisk *\n",
    "content = [n for n in content if not n.startswith('*')]\n",
    "# converts all lower case to upper\n",
    "content = [x.upper() for x in content]\n",
    "# removes extra spaces between entries\n",
    "content = [' '.join(x.split()) for x in content]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "branch_cnt = len(content)\n",
    "# chech number of entries on each line\n",
    "for i in range(branch_cnt):\n",
    "    x = content[i][0]\n",
    "    tk_cnt = len(content[i].split())\n",
    "\n",
    "    if (x == 'R') or (x == 'L') or (x == 'C'):\n",
    "        if tk_cnt != 4:\n",
    "            print(\"branch {:d} not formatted correctly, {:s}\".format(i,content[i]))\n",
    "            print(\"1had {:d} items and should only be 4\".format(tk_cnt))\n",
    "        num_passives += 1\n",
    "    elif x == 'V':\n",
    "        if (tk_cnt != 6) and (tk_cnt != 7):\n",
    "            print(\"branch {:d} not formatted correctly, {:s}\".format(i,content[i]))\n",
    "            print(\"2had {:d} items and should only be 6 or 7\".format(tk_cnt))\n",
    "        num_v_ind += 1\n",
    "    elif x == 'I':\n",
    "        if (tk_cnt != 6) and (tk_cnt != 7):\n",
    "            print(\"branch {:d} not formatted correctly, {:s}\".format(i,content[i]))\n",
    "            print(\"2had {:d} items and should only be 6 or 7\".format(tk_cnt))\n",
    "        num_i_ind += 1\n",
    "    elif x == 'O':\n",
    "        if (tk_cnt != 6) and (tk_cnt != 7):\n",
    "            print(\"branch {:d} not formatted correctly, {:s}\".format(i,content[i]))\n",
    "            print(\"2had {:d} items and should only be 6 or 7\".format(tk_cnt))\n",
    "        num_opamps += 1\n",
    "    elif (x == 'E') or (x == 'F') or (x == 'G') or (x == 'H'):\n",
    "        if (tk_cnt != 6):\n",
    "            print(\"branch {:d} not formatted correctly, {}\".format(i,content[i]))\n",
    "            print(\"3had {:d} items and should only be 6\".format(tk_cnt))\n",
    "    else:\n",
    "        print(\"unknown element type in branch {:d}, {}\".format(i,content[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### PARSER\n",
    "- puts branch elements into structure\n",
    "- counts number of nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# try puting the branch structre in a pandas data frame\n",
    "count = []\n",
    "element = []      # type of element\n",
    "p_node = []       # positive node\n",
    "n_node = []       # neg node\n",
    "cp_node = []      # controlling pos node of branch\n",
    "cn_node = []      # controlling neg node of branch\n",
    "source_type = []  # 1 = AC, 2 = DC source, 3 for multi-terminal\n",
    "value = []        # value of element or voltage\n",
    "phase = []        # AC phase\n",
    "source_imp = []   # source impedance\n",
    "\n",
    "df = pd.DataFrame(index=count, columns=['element','p node','n node','cp node','cn node',\n",
    "    'source type','value','phase','source imp'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### Functions to load branch elements into data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# loads AC and DC voltage and current sources into branch structure\n",
    "def indep_source(br_nu):\n",
    "    tk = content[br_nu].split()\n",
    "    df.loc[br_nu,'element'] = tk[0]\n",
    "    df.loc[br_nu,'p node'] = int(tk[1])\n",
    "    df.loc[br_nu,'n node'] = int(tk[2])\n",
    "    df.loc[br_nu,'source type'] = tk[3]\n",
    "    if tk[3] == 'AC':\n",
    "        df.loc[br_nu,'value'] = float(tk[4])\n",
    "        df.loc[br_nu,'phase'] = float(tk[5])\n",
    "        df.loc[br_nu,'source imp'] = float(tk[6])\n",
    "    if tk[3] == 'DC':\n",
    "        df.loc[br_nu,'value'] = float(tk[4])\n",
    "        df.loc[br_nu,'source imp'] = float(tk[6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# loads passive elements into branch structure\n",
    "def pass_element(br_nu):\n",
    "    tk = content[br_nu].split()\n",
    "    df.loc[br_nu,'element'] = tk[0]\n",
    "    df.loc[br_nu,'p node'] = int(tk[1])\n",
    "    df.loc[br_nu,'n node'] = int(tk[2])\n",
    "    df.loc[br_nu,'value'] = float(tk[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "'''\n",
    "loads multi-terminal sub-networks\n",
    "into branch structure\n",
    "Types:\n",
    "E - VCVS\n",
    "G - VCCS\n",
    "F - CCCS\n",
    "H - CCVS\n",
    "not implemented yet:\n",
    "K - Coupled inductors\n",
    "'''\n",
    "def sub_network(br_nu):\n",
    "    tk = content[br_nu].split()\n",
    "    df.loc[br_nu,'element'] = tk[0]\n",
    "    df.loc[br_nu,'p node'] = int(tk[1])\n",
    "    df.loc[br_nu,'n node'] = int(tk[2])\n",
    "    df.loc[br_nu,'cp node'] = int(tk[3])\n",
    "    df.loc[br_nu,'cn node'] = int(tk[4])\n",
    "    df.loc[br_nu,'value'] = float(tk[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# scan df and get largest node number\n",
    "def count_nodes():\n",
    "    # need to ckeck that nodes are consecutive\n",
    "    # fill array with node numbers\n",
    "    p = np.zeros(branch_cnt+1)\n",
    "    for i in range(branch_cnt-1):\n",
    "        p[df['p node'][i]] = df['p node'][i]\n",
    "        p[df['n node'][i]] = df['n node'][i]\n",
    "\n",
    "    # find the largest node number\n",
    "    if df['n node'].max() > df['p node'].max():\n",
    "        largest = df['n node'].max()\n",
    "    else:\n",
    "        largest =  df['p node'].max()\n",
    "\n",
    "        largest = int(largest)\n",
    "    # check for unfilled elements, skip node 0\n",
    "    for i in range(1,largest):\n",
    "        if p[i] == 0:\n",
    "            print(\"nodes not in continuous order\");\n",
    "\n",
    "    return largest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# load branches into data frame\n",
    "for i in range(branch_cnt):\n",
    "    x = content[i][0]\n",
    "\n",
    "    if (x == 'R') or (x == 'L') or (x == 'C'):\n",
    "        pass_element(i)\n",
    "    elif (x == 'V') or (x == 'I'):\n",
    "        indep_source(i)\n",
    "    elif (x == 'E') or (x == 'F') or (x == 'G') or (x == 'H'):\n",
    "        sub_network(i)\n",
    "    else:\n",
    "        print(\"unknown element type in branch {:d}, {}\".format(i,content[i]))\n",
    "\n",
    "# count number of nodes\n",
    "num_nodes = count_nodes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of branches: 16\n",
      "number of nodes: 10\n",
      "number of passive components: 15\n",
      "number of independent voltage sources: 1\n",
      "number of op amps: 0\n",
      "number of independent current sources: 0\n"
     ]
    }
   ],
   "source": [
    "# print a report\n",
    "print('number of branches: {:d}'.format(branch_cnt))\n",
    "print('number of nodes: {:d}'.format(num_nodes))\n",
    "print('number of passive components: {:d}'.format(num_passives))\n",
    "print('number of independent voltage sources: {:d}'.format(num_v_ind))\n",
    "print('number of op amps: {:d}'.format(num_opamps))\n",
    "print('number of independent current sources: {:d}'.format(num_i_ind))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# store the data frame as a pickle file\n",
    "df.to_pickle(fn+'.pkl')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# can also save numpy arrays to a file\n",
    ">>> x = np.arange(10)\n",
    ">>> np.save(outfile, x)\n",
    ">>> outfile.seek(0) # Only needed here to simulate closing & reopening file\n",
    ">>> np.load(outfile)\n",
    "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "\n",
    ">>> np.savez(outfile, x, y)\n",
    ">>> outfile.seek(0) # Only needed here to simulate closing & reopening file\n",
    ">>> npzfile = np.load(outfile)\n",
    ">>> npzfile.files\n",
    "['arr_1', 'arr_0']\n",
    ">>> npzfile['arr_0']\n",
    "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# initialize some variables\n",
    "j_omega = 1j   #for debugging\n",
    "G = np.zeros((num_nodes,num_nodes), dtype=complex)\n",
    "V = np.zeros(num_nodes, dtype=complex)\n",
    "I = np.zeros(num_nodes, dtype=complex)\n",
    "\n",
    "if (num_v_ind+num_opamps) != 0:\n",
    "    B = np.zeros((num_nodes,num_v_ind+num_opamps), dtype=complex)\n",
    "    C = np.zeros((num_v_ind+num_opamps,num_nodes), dtype=complex)\n",
    "    D = np.zeros((num_v_ind+num_opamps,num_v_ind+num_opamps), dtype=complex)\n",
    "    E = np.zeros(num_v_ind+num_opamps, dtype=complex)\n",
    "    J = np.zeros(num_v_ind+num_opamps, dtype=complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "'''\n",
    "G matrix\n",
    "the G matrix is nxn and is determined by the interconnections between the passive circuit elements (RLC's)\n",
    "The G matrix is an nxn matrix formed in two steps\n",
    "1) Each element in the diagonal matrix is equal to the sum of the conductance (one over the resistance) of each element connected to the corresponding node.  So the first diagonal element is the sum of conductances connected to node 1, the second diagonal element is the sum of conductances connected to node 2, and so on.\n",
    "2) The off diagonal elements are the negative conductance of the element connected to the pair of corresponding node.  Therefore a resistor between nodes 1 and 2 goes into the G matrix at location (1,2) and locations (2,1).\n",
    "'''\n",
    "for i in range(branch_cnt):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    # process all the passive elements, save conductance to temp value\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'R':\n",
    "        g = 1/df.loc[i,'value']\n",
    "    if x == 'L':\n",
    "        g = 1/(j_omega/df.loc[i,'value'])\n",
    "    if x == 'C':\n",
    "        g = df.loc[i,'value']*j_omega\n",
    "\n",
    "    if (x == 'R') or (x == 'L') or (x == 'C'):\n",
    "        # If neither side of the element is connected to ground\n",
    "        # then subtract it from appropriate location in matrix.\n",
    "        if (n1 != 0) and (n2 != 0):\n",
    "            G[n1-1,n2-1] += -g\n",
    "            G[n2-1,n1-1] += -g\n",
    "\n",
    "        # If node 1 is connected to graound, add element to diagonal\n",
    "        # of matrix.\n",
    "        if n1 != 0:\n",
    "            G[n1-1,n1-1] += g\n",
    "\n",
    "        # Ditto for node 2.\n",
    "        if n2 != 0:\n",
    "            G[n2-1,n2-1] += g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# try making G matrix symbolic\n",
    "from sympy import *\n",
    "init_printing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "G = zeros(num_nodes,num_nodes)  #make a symbolic matrix initalized with zeros\n",
    "s = Symbol('s')\n",
    "\n",
    "# need to make all the passive elements sympy variables with sympify()\n",
    "for i in range(branch_cnt):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    # process all the passive elements, save conductance to temp value\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'R':\n",
    "        g = 1/sympify(df.loc[i,'element'])\n",
    "    if x == 'L':\n",
    "        g = 1/(s/sympify(df.loc[i,'element']))\n",
    "    if x == 'C':\n",
    "        g = sympify(df.loc[i,'element'])*s\n",
    "\n",
    "    if (x == 'R') or (x == 'L') or (x == 'C'):\n",
    "        # If neither side of the element is connected to ground\n",
    "        # then subtract it from appropriate location in matrix.\n",
    "        if (n1 != 0) and (n2 != 0):\n",
    "            G[n1-1,n2-1] += -g\n",
    "            G[n2-1,n1-1] += -g\n",
    "\n",
    "        # If node 1 is connected to graound, add element to diagonal\n",
    "        # of matrix.\n",
    "        if n1 != 0:\n",
    "            G[n1-1,n1-1] += g\n",
    "\n",
    "        # Ditto for node 2.\n",
    "        if n2 != 0:\n",
    "            G[n2-1,n2-1] += g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}C_{1} s + \\frac{1}{R_{2}} & - \\frac{1}{R_{2}} & 0 & 0 & 0 & 0 & 0 & 0 & 0 & - C_{1} s\\\\- \\frac{1}{R_{2}} & \\frac{L_{1}}{s} + \\frac{1}{R_{3}} + \\frac{1}{R_{2}} & 0 & 0 & - \\frac{1}{R_{3}} & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & \\frac{1}{R_{4}} + \\frac{1}{R_{1}} & - \\frac{1}{R_{4}} & 0 & 0 & 0 & 0 & 0 & - \\frac{1}{R_{1}}\\\\0 & 0 & - \\frac{1}{R_{4}} & C_{3} s + \\frac{L_{2}}{s} + \\frac{1}{R_{4}} & - \\frac{L_{2}}{s} & - C_{3} s & 0 & 0 & 0 & 0\\\\0 & - \\frac{1}{R_{3}} & 0 & - \\frac{L_{2}}{s} & C_{2} s + \\frac{L_{2}}{s} + \\frac{1}{R_{5}} + \\frac{1}{R_{3}} & 0 & - \\frac{1}{R_{5}} & 0 & 0 & 0\\\\0 & 0 & 0 & - C_{3} s & 0 & C_{3} s + C_{4} s & 0 & - C_{4} s & 0 & 0\\\\0 & 0 & 0 & 0 & - \\frac{1}{R_{5}} & 0 & \\frac{L_{3}}{s} + \\frac{L_{4}}{s} + \\frac{1}{R_{5}} & 0 & - \\frac{L_{4}}{s} & 0\\\\0 & 0 & 0 & 0 & 0 & - C_{4} s & 0 & C_{4} s + \\frac{1}{R_{6}} & - \\frac{1}{R_{6}} & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & - \\frac{L_{4}}{s} & - \\frac{1}{R_{6}} & C_{5} s + \\frac{L_{4}}{s} + \\frac{1}{R_{6}} & 0\\\\- C_{1} s & 0 & - \\frac{1}{R_{1}} & 0 & 0 & 0 & 0 & 0 & 0 & C_{1} s + \\frac{1}{R_{1}}\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 104,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# define some symbolic matrices\n",
    "I = zeros(num_nodes,1)\n",
    "\n",
    "# need to make all the passive elements sympy variables with sympify()\n",
    "for j in range(branch_cnt):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    # process all the passive elements, save conductance to temp value\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'I':\n",
    "        if n1 == j:\n",
    "            I[j] = -sympify(df.loc[i,'element'])\n",
    "        if n2 == j:\n",
    "            I[j] = sympify(df.loc[i,'element'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# define some symbolic matrices\n",
    "V = zeros(num_nodes,1)\n",
    "for i in range(num_nodes):\n",
    "    V[i] = sympify('v{:d}'.format(i+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "if (num_v_ind+num_opamps) != 0:\n",
    "    B = zeros(num_nodes,num_v_ind+num_opamps)\n",
    "    C = zeros(num_v_ind+num_opamps,num_nodes)\n",
    "    D = zeros(num_v_ind+num_opamps,num_v_ind+num_opamps)\n",
    "    E = zeros(num_v_ind+num_opamps)\n",
    "    J = zeros(num_v_ind+num_opamps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "'''\n",
    "B Matrix\n",
    "Rules for making the B matrix\n",
    "The B matrix is an nxm matrix with only 0, 1 and -1 elements.  Each location in the matrix corresponds to a particular voltage source (first dimension) or a node (second dimension).  If the positive terminal of the ith voltage source is connected to node k, then the element (i,k) in the B matrix is a 1.  If the negative terminal of the ith voltage source is connected to node k, then the element (i,k) in the B matrix is a -1.  Otherwise, elements of the B matrix are zero.\n",
    "'''\n",
    "B = zeros(num_nodes,num_v_ind+num_opamps)\n",
    "# First handle the case of the independent voltage sources.\n",
    "sn = 0   # count source number\n",
    "for i in range(branch_cnt):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    # process all the independent voltage sources\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'V':\n",
    "        if num_v_ind+num_opamps > 1:\n",
    "            B[sn,n1] = 1\n",
    "            B[sn,n2] = -1\n",
    "            sn += 1   #increment source count\n",
    "        else:\n",
    "            B[n1] = 1\n",
    "            B[n2] = -1\n",
    "    # Op amps not implemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "num_passives = 0    # number of passive elements\n",
    "num_v_ind = 0    # number of independent voltage sources\n",
    "num_opamps = 0   # Number of op amps\n",
    "num_i_ind = 0    # number of independent current sources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## old code below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### Build the NAM\n",
    "- load up network matrix and vectors\n",
    "- load V & I vectors with vi_vector()\n",
    "- load branch admittances with load_admit_list()\n",
    "- build NAM and Y with build_nam()\n",
    "\n",
    "top level calls are from dc_analysis() and dc_output(), need to generalized the AC and DC case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "branch_cnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# initialize voltage and current source vectors\n",
    "# this function only does DC now, AC is a bit different, see C code\n",
    "V = np.zeros(branch_cnt, dtype=complex)\n",
    "I = np.zeros(branch_cnt, dtype=complex)\n",
    "\n",
    "# calculates voltage and current vectors for node equations\n",
    "def vi_vector():\n",
    "    for i in range(branch_cnt):\n",
    "        if df.loc[i,'element'] == 'V':\n",
    "            if df.loc[i,'source type'] == 'DC':\n",
    "                V[i] = df.loc[i,'value']\n",
    "            else:\n",
    "                V[i] = 0\n",
    "        if df.loc[i,'element'] == 'I':\n",
    "            if df.loc[i,'source type'] == 'DC':\n",
    "                I[i] = -df.loc[i,'value']\n",
    "            else:\n",
    "                I[i] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# initalize admmitance list, need to generalize for AC case\n",
    "Y = np.zeros(branch_cnt, dtype=complex)\n",
    "SHORT = 1E-10\n",
    "OPEN = 1E+10\n",
    "# formulates admittances list\n",
    "def load_admit_list():\n",
    "    #load R L & C branch values into Y and JY admittence lists\n",
    "    for i in range(branch_cnt):\n",
    "        x = df.loc[i,'element']\n",
    "        if x == 'R':\n",
    "            Y[i] = 1/df.loc[i,'value']\n",
    "        elif x == 'L':\n",
    "            Y[i] = OPEN   #for AC JY[i] = 1/(df.loc[i,'value']*omega*1J)\n",
    "        elif x == 'C':\n",
    "            Y[i] = SHORT  # df.loc[i,'value']*omega*1J;\n",
    "        elif (x == 'V') or (x == 'I'): #put in source impedance\n",
    "            Y[i] = 1/df.loc[i,'source imp']\n",
    "            # take care of AC sources\n",
    "            if df.loc[i,'type'] == 'AC':\n",
    "                if x == 'V':  Y[i] = SHORT;\n",
    "                if x == 'I':  Y[i] = OPEN;\n",
    "            else:\n",
    "                Y[i] = 1/df.loc[i,'source_imp']\n",
    "        else:\n",
    "            print('Problem loading R L & C\\'s into admittance list')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "V[0] = 1\n",
    "Y[0]*V[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "'''\n",
    "assembles NAM directly from circuit description\n",
    "NAM - Re part of nodal admittance matrix\n",
    "DV - Re part of the driving vector\n",
    "Y - RE branch admittence list\n",
    "UE - branch voltage source list\n",
    "IE - branch current source list\n",
    "'''\n",
    "# initialize arrays\n",
    "DV = np.zeros(branch_cnt, dtype=complex)\n",
    "NAM = np.zeros((branch_cnt,branch_cnt), dtype=complex)\n",
    "\n",
    "def build_nam():\n",
    "    # build NAM and driving vector\n",
    "    for k in range(branch_cnt):\n",
    "        # skip past multi-terminal networks\n",
    "        if df.loc[k,'source type'] == 3:  #need to check on source type\n",
    "            continue\n",
    "\n",
    "        p = df.loc[k,'p node']\n",
    "        q = df.loc[k,'n node']\n",
    "        # calculate NAM, can numpy do this math?\n",
    "        if p > 0:\n",
    "            NAM[p,p] = NAM[p,p] + Y[k]\n",
    "        if q > 0:\n",
    "            NAM[q,q] = NAM[q,q] + Y[k]\n",
    "        if p > 0 and q > 0:\n",
    "            NAM[p,q] = NAM[p,q] - Y[k]\n",
    "            NAM[q,p] = NAM[q,p] - Y[k]\n",
    "\n",
    "        # calculation of driving vector\n",
    "        current = Y[k] * V[k] - I[k]\n",
    "        if p > 0:\n",
    "            DV[p] = DV[p] + current\n",
    "        if q > 0:\n",
    "            DV[q] = DV[q] - current\n",
    "\n",
    "    # add sub-networks to NAM\n",
    "    super_impos()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "'''\n",
    "performs superposition of multi-terminal\n",
    "elements into the admittence matrix\n",
    "\n",
    "YM - multi-terminal matrix\n",
    "lm = terminal/node association list\n",
    "\n",
    "format of elements of multi-terminal matrixes\n",
    "-------------------------------------------\n",
    "| sign | g3 | g2 | g1 | p4 | p3 | p2 | p1 |\n",
    "-------------------------------------------\n",
    "\n",
    "sign - set to 1 if negative\n",
    "g1-3 - additional parameters\n",
    "p1-4 - gain factors\n",
    "'''\n",
    "def super_impos():\n",
    "    print('not supported at this time')\n",
    "\n",
    "'''\n",
    "    /* if no sub-networks return */\n",
    "    if(num_multi == 0)\n",
    "        return;\n",
    "\n",
    "    /* search thru network structure to find multi-terminal elements */\n",
    "    for(k = 1,snc = 0;k <= num_branches;k++){\n",
    "        if(branch[k-1].type  != 3)\n",
    "            continue;\n",
    "\n",
    "        /* build temporary multi-terminal matrixes */\n",
    "        switch(branch[k-1].element[0]){\n",
    "            case 'E': /* VCVS */\n",
    "                ptr = mt_vcvs;\n",
    "                break;\n",
    "            case 'G': /* VCCS */\n",
    "                ptr = mt_vccs;\n",
    "                break;\n",
    "            case 'F': /* CCCS */\n",
    "                ptr = mt_cccs;\n",
    "                break;\n",
    "            case 'H': /* CCVS */\n",
    "                ptr = mt_ccvs;\n",
    "                break;\n",
    "            default:\n",
    "                printf(\"\\r\\nunknown element type in branch %d\\r\\n\",k);\n",
    "                puts(\"failed in super_impos\");\n",
    "                exit(7);\n",
    "        }\n",
    "\n",
    "        /* 1st element is size of square matrix */\n",
    "        num_term = sub_net[snc].num_terminals = *ptr++;\n",
    "\n",
    "        /* allocate space for node terminal association list and temp matrix */\n",
    "        sub_net[snc].lm = ivector(1,num_term);\n",
    "        sub_net[snc].mt = dmatrix(1,num_term,1,num_term);\n",
    "\n",
    "        /* load multi-terminal matrix with network values */\n",
    "        build_mt(sub_net[snc].mt,num_term,ptr,k);\n",
    "\n",
    "        /* build node/terminal association list  */\n",
    "        sub_net[snc].lm[1] = branch[k-1].cp_node;\n",
    "        sub_net[snc].lm[2] = branch[k-1].cn_node;\n",
    "        sub_net[snc].lm[3] = branch[k-1].n_node;\n",
    "        sub_net[snc].lm[4] = branch[k-1].p_node;\n",
    "        for(i = 5;i <= num_term;i++)\n",
    "            sub_net[snc].lm[i] = -1;\n",
    "\n",
    "        /* expand NAM and driving vector */\n",
    "        for(i = 1;i <= num_term;i++){\n",
    "            if(sub_net[snc].lm[i] < 0){\n",
    "                /* isolated additional nodes */\n",
    "                num_nodes += 1;     /* bump node count */\n",
    "                expand_nam_dv();    /* grow NAM & DV */\n",
    "                sub_net[snc].lm[i] = num_nodes;\n",
    "                p = sub_net[snc].lm[i];\n",
    "                /* zero added row and column */\n",
    "                for(j = 1;j <= num_nodes;j++)\n",
    "                    NAM[p][j] = 0.0;\n",
    "                for(j = 1;j <= num_nodes;j++)\n",
    "                    NAM[j][p] = 0.0;\n",
    "                DV[p] = 0.0;\n",
    "            }\n",
    "        }\n",
    "\n",
    "        /* super position of multi-terminal admittence matrix */\n",
    "        for(i = 1;i <= num_term;i++){\n",
    "            p = sub_net[snc].lm[i];\n",
    "            if(p > 0){\n",
    "                for(j = 1;j <= num_term;j++){\n",
    "                    q = sub_net[snc].lm[j];\n",
    "                    if(q > 0)\n",
    "                        NAM[p][q] = NAM[p][q] + sub_net[snc].mt[i][j];\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "\n",
    "        snc++;  /* bump index for sub-network struct */\n",
    "    }\n",
    "}\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "vi_vector()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "load_admit_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "build_nam()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "df.loc[1,'n node']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "'''\n",
    "DC ANALYSIS\n",
    "SOLVED BY THE NODAL ADMITTANCE METHOD\n",
    "Y - branch admittance list\n",
    "I - independent current source\n",
    "E - independent voltage source\n",
    "NAM = nodal admittance matrix\n",
    "DV - driving vector\n",
    "'''\n",
    "\n",
    "# load up network matrix and vectors\n",
    "vi_vector()        # load V & I vectors\n",
    "load_admit_list()  # load branch admittances\n",
    "build_nam()        # build NAM and Y\n",
    "\n",
    "    /* calculate branch voltages and currents */\n",
    "    for(i = 1;i <= num_branches;i++){\n",
    "        p = branch[i-1].p_node;\n",
    "        q = branch[i-1].n_node;\n",
    "\n",
    "        if(p > 0 && q == 0){\n",
    "            BV[i] = NV[p] - V[i];\n",
    "            BI[i] = Y[i] * BV[i];\n",
    "        }\n",
    "\n",
    "        if(q > 0 && p == 0){\n",
    "            BV[i] =  - (NV[q] + V[i]);\n",
    "            BI[i] = Y[i] * BV[i];\n",
    "        }\n",
    "\n",
    "        if(p > 0 && q > 0){\n",
    "            BV[i] = NV[p] - NV[q] - V[i];\n",
    "            BI[i] = Y[i] * BV[i];\n",
    "        }\n",
    "    }\n",
    "    /* determine terminal currents of sub-networks */\n",
    "    terminal_currents();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (Anaconda)",
   "language": "python",
   "name": "anaconda3"
  },
  "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}