backup/node analysis_9-30-2017a.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Symbolic modified nodal analysis\n",
    "Last update: 9/30/2017"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**Abstract:** This notebook will read in a spice like circuit netlist file and compute the network equations in symbolic form. These equations can then be copied to a different notebook where the node voltages can be solved using sympy or numpy.\n",
    "\n",
    "**Description:** This node analysis code started as a translation from some C code to generate a nodal admittance matrix that I had written in 1988.  The original C code worked well and calculated numeric solutions.  I then started writing some C code to generate the matrices with symbolic values and then intended to use LISP to symbolically solve the equations.  I didn’t get too far with this effort.  The LISP code would generate huge symbolic strings with no simplification.  The output was a big pile of trash that was not in the least bit useful or decipherable.\n",
    "\n",
    "In 2014, I started to use python for my little coding projects and engineering calculations.  There are some nice python libraries for numeric and symbolic calculations (such as numpy and sympy), so I decided to try writing a python script to generate the node equations based on the old C code I had written many years before.  Part way into this project I discovered that there is a new nodal analysis technique being taught today in engineering school called the modified nodal analysis (1,2).  The modified nodal analysis provides an algorithmic method for generating systems of independent equations for linear circuit analysis.  Some of my younger colleagues at work were taught this method, but I never heard of it until a short time ago.  These days, I never really analyze a circuit by hand, unless it’s so simple that you can almost do it by inspection.  Most problems that an electrical engineer encounters on the job are complex enough that they use computers to analyze the circuits.  LTspice is the version of spice that I use, since it’s free and does a good job converging when analyzing switching circuits.\n",
    "\n",
    "The code follows Erik Cheever's Analysis of  Resistive Circuits [page](http://www.swarthmore.edu/NatSci/echeeve1/Ref/mna/MNA1.html) to generate modified nodal equations. I somewhat followed his matlab file for resistors, capacitors, opamps and independent sources.  The preprocessor and parser code was converted from my old C code.  The use of pandas for a data frame is new and sympy is used to do the math.\n",
    "\n",
    "After doing some verification testing with inductors and capacitors, it seems that inductors are not being treated correctly.  According to some research, the inductor stamp affects the B,C and D arrays.  Erik Cheever's code puts inductors into the G matrix as 1/s/L.  LTspice results are different than the python code.  Capacitors seem to work OK.\n",
    "\n",
    "Reference:\n",
    "1. The modified nodal approach to network analysis, Chung-Wen Ho, A. Ruehli, P. Brennan, IEEE Transactions on Circuits and Systems ( Volume: 22, Issue: 6, Jun 1975 )\n",
    "2. https://en.wikipedia.org/wiki/Modified_nodal_analysis\n",
    "3. ECE 570 Session 3, Computer Aided Engineering for Integrated Circuits, http://www2.engr.arizona.edu/~ece570/session3.pdf\n",
    "\n",
    "Some notes from reference 1:\n",
    "Capacitances and inductances are considered only in the time domain and their contributions, shown in Table I, are obtained by applying finite differencing methods to their branch relations.\n",
    "\n",
    "links: http://www.solved-problems.com/circuits/electrical-circuits-problems/716/supernode-dependent-voltage-source/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "```\n",
    "Date started: April 17, 2017\n",
    "file name: node analysis.ipynb\n",
    "Requires: Python version 3 or higher and a jupyter notebook\n",
    "Author: Tony\n",
    "\n",
    "Revision History\n",
    "7/1/2015: Ver 1 - coding started, derived from network.c code\n",
    "8/18/2017\n",
    "changed approach, now implementing a modified nodal analysis\n",
    "8/19/2017\n",
    "Wrote some code to generate symbolic matrices, works ok,\n",
    "so heading down the sympy path. Basic debugging finished,\n",
    "but still need to verify some circuits using Ls and Cs.\n",
    "8/30/2017\n",
    "Started to add code for op amps\n",
    "9/1/2017\n",
    "Code added to process op amps\n",
    "9/3/2017\n",
    "Added code to remove spice directives.\n",
    "Fixed orientation of current sources in I matrix.\n",
    "N2 is the arrow end of the current source.\n",
    "9/5/2017\n",
    "After doing some verification testing with inductors and capacitors,\n",
    "it seems that inductors are not being treated correctly.  According\n",
    "to some research, inductor stamp affects the B,C and D arrays.  Erik\n",
    "Cheever's code puts inductors into the G matrix as 1/s/L.  LTspice \n",
    "results are different than the python code.  Capacitors seem to work OK.\n",
    "Plan is to add controlled sources, then get inductors working.\n",
    "9/6/2017\n",
    "opamp_test_circuit_426 is not working.  Results not the same as LTspice\n",
    "Chebyshev_LPF_1dB_4pole: cut off frequency not correct, other features look OK\n",
    "still need to debug opamps and inductors\n",
    "Adding: VCCS = G type branch element: G needs to be modified\n",
    "CCVS = H type branch element: B, C and D need to be modified\n",
    "9/10/2017\n",
    "researching formulation of B matrix\n",
    "what about a network with only 1 current source?  The B, C and D matrix would be 0 by 0.\n",
    "Think about changing the name of the G matrix to Yr, to keep same as Ho's IEEE paper.\n",
    "\n",
    "CCVS = H type branch element: B, C and D need to be modified\n",
    "CCCS = F type branch element: B, C and D need to be modified\n",
    "VCCS = G type branch element: G needs to be modified\n",
    "VCVS = E type branch element: B and C need to be modified\n",
    "\n",
    "For CCCS = F type branch element, for this type of element, need to add a zero volt voltage source to the net list through which the current flows.\n",
    "For CCVS = H type branch element, need to add a zero volt voltage source to the net list through which the current flows.  The dependent voltage source is already included in the net list as H type.\n",
    "\n",
    "9/12/2017\n",
    "still working on the B matrix\n",
    "9/18/2017\n",
    "still debugging B matrix, looks like we don't need find_vname() or df2.  This is because a zero volt voltage source is add to the net list in spice.\n",
    "need to add cccs type to the list of i_unk.\n",
    "Filled out some B matrices by hand and got the same answer as the code.\n",
    "9/30/2017\n",
    "working on C & D matrix\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "import os\n",
    "from sympy import *\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "init_printing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# initialize some variables, count the types of elements\n",
    "num_rlc = 0 # number of passive elements\n",
    "num_ind = 0 # number of inductors\n",
    "num_v = 0    # number of independent voltage sources\n",
    "num_i = 0    # number of independent current sources\n",
    "i_unk = 0  # number of current unknowns\n",
    "num_opamps = 0   # number of op amps\n",
    "num_vcvs = 0     # number of controlled sources of various types\n",
    "num_vccs = 0\n",
    "num_cccs = 0\n",
    "num_ccvs = 0\n",
    "num_cpld_ind = 0 # number of coupled inductors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## open file and preprocess it\n",
    "- file name extenstion is defaulted to .net\n",
    "- remove blank lines and comments\n",
    "- convert first letter of element name to upper case\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": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "fn = 'example48'\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",
    "# remove other comment lines, these start with a semicolon ;\n",
    "content = [n for n in content if not n.startswith(';')]\n",
    "# remove spice directives, these start with a period, .\n",
    "content = [n for n in content if not n.startswith('.')]\n",
    "# converts 1st letter to upper case\n",
    "#content = [x.upper() for x in content] <- this converts all to upper case\n",
    "content = [x.capitalize() for x in content]\n",
    "# removes extra spaces between entries\n",
    "content = [' '.join(x.split()) for x in content]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "line_cnt = len(content) # number of lines in the netlist\n",
    "branch_cnt = 0  # number of btanches in the netlist\n",
    "# check number of entries on each line\n",
    "for i in range(line_cnt):\n",
    "    x = content[i][0]\n",
    "    tk_cnt = len(content[i].split()) # split the line into tokens\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(\"had {:d} items and should only be 4\".format(tk_cnt))\n",
    "        num_rlc += 1\n",
    "        branch_cnt += 1\n",
    "        if x == 'L':\n",
    "            num_ind += 1\n",
    "    elif x == 'V':\n",
    "        if tk_cnt != 4:\n",
    "            print(\"branch {:d} not formatted correctly, {:s}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 4\".format(tk_cnt))\n",
    "        num_v += 1\n",
    "        branch_cnt += 1\n",
    "    elif x == 'I':\n",
    "        if tk_cnt != 4:\n",
    "            print(\"branch {:d} not formatted correctly, {:s}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 4\".format(tk_cnt))\n",
    "        num_i += 1\n",
    "        branch_cnt += 1\n",
    "    elif x == 'O':\n",
    "        if tk_cnt != 4:\n",
    "            print(\"branch {:d} not formatted correctly, {:s}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 4\".format(tk_cnt))\n",
    "        num_opamps += 1\n",
    "    elif x == 'E':\n",
    "        if (tk_cnt != 6):\n",
    "            print(\"branch {:d} not formatted correctly, {}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 6\".format(tk_cnt))\n",
    "        num_vcvs += 1\n",
    "        branch_cnt += 1\n",
    "    elif x == 'G':\n",
    "        if (tk_cnt != 6):\n",
    "            print(\"branch {:d} not formatted correctly, {}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 6\".format(tk_cnt))\n",
    "        num_vccs += 1\n",
    "        branch_cnt += 1\n",
    "    elif x == 'F':\n",
    "        if (tk_cnt != 5):\n",
    "            print(\"branch {:d} not formatted correctly, {}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 5\".format(tk_cnt))\n",
    "        num_cccs += 1\n",
    "        branch_cnt += 1\n",
    "    elif x == 'H':\n",
    "        if (tk_cnt != 5):\n",
    "            print(\"branch {:d} not formatted correctly, {}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 5\".format(tk_cnt))\n",
    "        num_ccvs += 1\n",
    "        branch_cnt += 1\n",
    "    elif x == 'K':\n",
    "        if (tk_cnt != 4):\n",
    "            print(\"branch {:d} not formatted correctly, {}\".format(i,content[i]))\n",
    "            print(\"had {:d} items and should only be 4\".format(tk_cnt))\n",
    "        num_cpld_ind += 1\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\n",
    "\n",
    "data frame lables:\n",
    "- count: data frame index\n",
    "- element: type of element\n",
    "- p node: positive node\n",
    "- n node: negitive node, for a current source, the arrow terminal\n",
    "- cp node: controlling positive node of branch\n",
    "- cn node: controlling negitive node of branch\n",
    "- Vout: opamp output node\n",
    "- value: value of element or voltage\n",
    "- Vname: voltage source through which the controlling current flows. Need to add a zero volt voltage source to the controlling branch.\n",
    "- Lname1: name of coupled inductor 1\n",
    "- Lname2: name of coupled inductor 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# build the pandas data frame\n",
    "df = pd.DataFrame(columns=['element','p node','n node','cp node','cn node',\n",
    "    'Vout','value','Vname','Lname1','Lname2'])\n",
    "\n",
    "# this data frame is for branches with unknown currents, need better name\n",
    "#df2 = pd.DataFrame(columns=['element','p node','n node'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### functions to load branch elements into data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# loads voltage or current sources into branch structure\n",
    "def indep_source(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'p node'] = int(tk[1])\n",
    "    df.loc[line_nu,'n node'] = int(tk[2])\n",
    "    df.loc[line_nu,'value'] = float(tk[3])\n",
    "\n",
    "# loads passive elements into branch structure\n",
    "def rlc_element(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'p node'] = int(tk[1])\n",
    "    df.loc[line_nu,'n node'] = int(tk[2])\n",
    "    df.loc[line_nu,'value'] = float(tk[3])\n",
    "\n",
    "# loads multi-terminal elements into branch structure\n",
    "# O - Op Amps\n",
    "def opamp_sub_network(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'p node'] = int(tk[1])\n",
    "    df.loc[line_nu,'n node'] = int(tk[2])\n",
    "    df.loc[line_nu,'Vout'] = int(tk[3])\n",
    "\n",
    "# G - VCCS\n",
    "def vccs_sub_network(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'p node'] = int(tk[1])\n",
    "    df.loc[line_nu,'n node'] = int(tk[2])\n",
    "    df.loc[line_nu,'cp node'] = int(tk[3])\n",
    "    df.loc[line_nu,'cn node'] = int(tk[4])\n",
    "    df.loc[line_nu,'value'] = float(tk[5])\n",
    "\n",
    "# E - VCVS\n",
    "def vcvs_sub_network(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'p node'] = int(tk[1])\n",
    "    df.loc[line_nu,'n node'] = int(tk[2])\n",
    "    df.loc[line_nu,'cp node'] = int(tk[3])\n",
    "    df.loc[line_nu,'cn node'] = int(tk[4])\n",
    "    df.loc[line_nu,'value'] = float(tk[5])\n",
    "\n",
    "# F - CCCS\n",
    "def cccs_sub_network(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'p node'] = int(tk[1])\n",
    "    df.loc[line_nu,'n node'] = int(tk[2])\n",
    "    df.loc[line_nu,'Vname'] = tk[3].capitalize()\n",
    "    df.loc[line_nu,'value'] = float(tk[4])\n",
    "\n",
    "# H - CCVS\n",
    "def ccvs_sub_network(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'p node'] = int(tk[1])\n",
    "    df.loc[line_nu,'n node'] = int(tk[2])\n",
    "    df.loc[line_nu,'Vname'] = tk[3].capitalize()\n",
    "    df.loc[line_nu,'value'] = float(tk[4])\n",
    "\n",
    "# K - Coupled inductors\n",
    "def cpld_ind_sub_network(line_nu):\n",
    "    tk = content[line_nu].split()\n",
    "    df.loc[line_nu,'element'] = tk[0]\n",
    "    df.loc[line_nu,'Lname1'] = tk[1].capitalize()\n",
    "    df.loc[line_nu,'Lname2'] = tk[2].capitalize()\n",
    "    df.loc[line_nu,'value'] = float(tk[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# function to scan df and get largest node number\n",
    "def count_nodes():\n",
    "    # need to check that nodes are consecutive\n",
    "    # fill array with node numbers\n",
    "    p = np.zeros(line_cnt+1)\n",
    "    for i in range(line_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, node {:.0f} is missing'.format(p[i-1]+1))\n",
    "\n",
    "    return largest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# load branch info into data frame\n",
    "for i in range(line_cnt):\n",
    "    x = content[i][0]\n",
    "\n",
    "    if (x == 'R') or (x == 'L') or (x == 'C'):\n",
    "        rlc_element(i)\n",
    "    elif (x == 'V') or (x == 'I'):\n",
    "        indep_source(i)\n",
    "    elif x == 'O':\n",
    "        opamp_sub_network(i)\n",
    "    elif x == 'E':\n",
    "        vcvs_sub_network(i)\n",
    "    elif x == 'G':\n",
    "        vccs_sub_network(i)\n",
    "    elif x == 'F':\n",
    "        cccs_sub_network(i)\n",
    "    elif x == 'H':\n",
    "        ccvs_sub_network(i)\n",
    "    elif x == 'K':\n",
    "        cpld_ind_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": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### new function\n",
    "don't need, delete when debugging is done."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# This is a function to generate a data frame of branches that have current unknowns\n",
    "# this is needed to be able to find the column number and nodes for controlled sources\n",
    "def func1():  # need a better name\n",
    "    count = 0\n",
    "    # need to walk through data frame and find these parameters\n",
    "    for i in range(len(df)):\n",
    "        n1 = df.loc[i,'p node']\n",
    "        n2 = df.loc[i,'n node']\n",
    "\n",
    "        # process all the elements creating unknown currents\n",
    "        x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "        if (x == 'L') or (x == 'V') or (x == 'O') or (x == 'E') or (x == 'H') or (x == 'F'):\n",
    "            df2.loc[count,'element'] = df.loc[i,'element']\n",
    "            df2.loc[count,'p node'] = df.loc[i,'p node']\n",
    "            df2.loc[count,'n node'] = df.loc[i,'n node']\n",
    "            count += 1\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "func1()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net list report\n",
      "number of lines in netlist: 9\n",
      "number of branches: 9\n",
      "number of nodes: 5\n",
      "number of unknown currents: 3\n",
      "number of passive components: 4\n",
      "number of inductors: 0\n",
      "number of independent voltage sources: 2\n",
      "number of independent current sources: 1\n",
      "number of op amps: 0\n",
      "\n",
      "Not implemented yet\n",
      "number of E - VCVS: 0\n",
      "number of G - VCCS: 1\n",
      "number of F - CCCS: 0\n",
      "number of H - CCVS: 1\n",
      "number of K - Coupled inductors: 0\n"
     ]
    }
   ],
   "source": [
    "# print a report\n",
    "print('Net list report')\n",
    "print('number of lines in netlist: {:d}'.format(line_cnt))\n",
    "print('number of branches: {:d}'.format(branch_cnt))\n",
    "print('number of nodes: {:d}'.format(num_nodes))\n",
    "# count the number of element types that affect the size of the B, C, D, E and J arrays\n",
    "# these are current unknows\n",
    "i_unk = num_v+num_opamps+num_vcvs+num_ccvs+num_ind\n",
    "print('number of unknown currents: {:d}'.format(i_unk))\n",
    "print('number of passive components: {:d}'.format(num_rlc))\n",
    "print('number of inductors: {:d}'.format(num_ind))\n",
    "print('number of independent voltage sources: {:d}'.format(num_v))\n",
    "print('number of independent current sources: {:d}'.format(num_i))\n",
    "print('number of op amps: {:d}'.format(num_opamps))\n",
    "\n",
    "# not implemented yet\n",
    "print('\\nNot implemented yet')\n",
    "print('number of E - VCVS: {:d}'.format(num_vcvs))\n",
    "print('number of G - VCCS: {:d}'.format(num_vccs))\n",
    "print('number of F - CCCS: {:d}'.format(num_cccs))\n",
    "print('number of H - CCVS: {:d}'.format(num_ccvs))\n",
    "print('number of K - Coupled inductors: {:d}'.format(num_cpld_ind))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>element</th>\n",
       "      <th>p node</th>\n",
       "      <th>n node</th>\n",
       "      <th>cp node</th>\n",
       "      <th>cn node</th>\n",
       "      <th>Vout</th>\n",
       "      <th>value</th>\n",
       "      <th>Vname</th>\n",
       "      <th>Lname1</th>\n",
       "      <th>Lname2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>R1</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>R2</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>R3</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>R4</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>V1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>I1</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>9</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>H1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "      <td>V2</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>G1</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>V2</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ]
     },
     "execution_count": 10,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# store the data frame as a pickle file\n",
    "# df.to_pickle(fn+'.pkl')  # <- uncomment if needed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
    "# initialize some symbolic matrix with zeros\n",
    "# A is formed by [[G, C] [B, D]]\n",
    "# Z = [I,E]\n",
    "# X = [V, J]\n",
    "V = zeros(num_nodes,1)\n",
    "I = zeros(num_nodes,1)\n",
    "G = zeros(num_nodes,num_nodes)  # also called Yr, the reduced nodal matrix\n",
    "s = Symbol('s')  # the Laplace variable\n",
    "\n",
    "# count the number of element types that affect the size of the B, C, D, E and J arrays\n",
    "# these are current unknows\n",
    "# is is possible to have i_unk == 0 ?, what about a network with only current sources?\n",
    "i_unk = num_v+num_opamps+num_vcvs+num_ccvs+num_ind+num_cccs\n",
    "if i_unk != 0:\n",
    "    B = zeros(num_nodes,i_unk)\n",
    "    C = zeros(i_unk,num_nodes)\n",
    "    D = zeros(i_unk,i_unk)\n",
    "    E = zeros(i_unk,1)\n",
    "    J = zeros(i_unk,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## G matrix\n",
    "The G matrix is n by n and is determined by the interconnections between Rs and Cs.  The G matrix is formed in three 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",
    "3) Add vccs element type according to the elemet stamp rule.  (insert discription of the rule)\n",
    "\n",
    "**Notes:**  \n",
    "In the orginal paper G is called Yr, where Yr, is a reduced form of the nodal matrix excluding the contributions due to voltage sources, current controlling elements, etc.\n",
    "\n",
    "<span style=\"color:red\">\\----need to check on inductor treatment, doesn't verify with LTspice testing, inductor stamp affects the B,C and D arrays</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}\\frac{1}{R_{2}} + \\frac{1}{R_{1}} & - \\frac{1}{R_{2}} & 0 & - \\frac{1}{R_{1}} & 0\\\\- \\frac{1}{R_{2}} & \\frac{1}{R_{4}} + \\frac{1}{R_{2}} & 0 & 0 & - \\frac{1}{R_{4}}\\\\- g_{1} & 0 & \\frac{1}{R_{3}} & g_{1} - \\frac{1}{R_{3}} & 0\\\\- \\frac{1}{R_{1}} & 0 & - \\frac{1}{R_{3}} & \\frac{1}{R_{3}} + \\frac{1}{R_{1}} & 0\\\\0 & - \\frac{1}{R_{4}} & 0 & 0 & \\frac{1}{R_{4}}\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 12,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# G matrix\n",
    "for i in range(len(df)):  # process each row in the data frame\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    cn1 = df.loc[i,'cp node']\n",
    "    cn2 = df.loc[i,'cn 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'])  # this matches Eric's code, but I thinks is wrong\n",
    "    if x == 'C':\n",
    "        g = s*sympify(df.loc[i,'element'])\n",
    "    if x == 'G':   #vccs type element\n",
    "        g = sympify(df.loc[i,'element'].lower())  # use a symbol for gain value\n",
    "\n",
    "    if (x == 'R') or (x == 'C'):   # fix this don't do L's <----\n",
    "    #if (x == 'R') or (x == 'L') or (x == 'C'):   # fix this don't do L's <----\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 ground, add element to diagonal of matrix\n",
    "        if n1 != 0:\n",
    "            G[n1-1,n1-1] += g\n",
    "\n",
    "        # same for for node 2\n",
    "        if n2 != 0:\n",
    "            G[n2-1,n2-1] += g\n",
    "\n",
    "    if x == 'G':    #vccs type element\n",
    "        # check to see if any terminal is grounded\n",
    "        # then stamp the matrix\n",
    "        if n1 != 0 and cn1 != 0:\n",
    "            G[n1-1,cn1-1] += g\n",
    "\n",
    "        if n2 != 0 and cn2 != 0:\n",
    "            G[n2-1,cn2-1] += g\n",
    "\n",
    "        if n1 != 0 and cn2 != 0:\n",
    "            G[n1-1,cn2-1] -= g\n",
    "\n",
    "        if n2 != 0 and cn1 != 0:\n",
    "            G[n2-1,cn1-1] -= g\n",
    "\n",
    "G  # display the G matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## B Matrix\n",
    "Rules for making the B matrix\n",
    "The B matrix is an n by m matrix with only 0, 1 and -1 elements.  There is one column for each unknown current.  loop through all the branches and process elements that have stamps for the B matrix:  \n",
    "V: voltage sources, O: opamps, H: ccvs, F: cccs, E: vcvs and inductors, these are counted in variable i_unk  \n",
    "The of the columns is as they appear in the netlist  \n",
    "F: cccs does not get its own column because the controlling current is through a zero volt voltage source, called Vname  <- not true?  cccs is an unknown current\n",
    "\n",
    "```\n",
    "old notes  \n",
    "Each location in the matrix corresponds to an unknown current 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",
    "coding notes:\n",
    "\n",
    "not only voltage sources but controlled sources like cccs\n",
    "\n",
    "probably need some code to make sure number of column equals the number of voltage sources.\n",
    "\n",
    "number of columns = num_v+num_opamps+num_ccvs+num_cccs+num_vcvs ;5 element types, every column is a current i sub k\n",
    "if num_v_sources > 1, the B is n by m, otherwise B is n by 1.\n",
    "\n",
    "B[row, column]\n",
    "\n",
    "Is there a valid case for not having a B matrix, i_unk = 0? \n",
    "Is there a valid op amp case where  B is n by 1?\n",
    "\n",
    "\n",
    "loop through all the branches and process elements that have stamps for the B matrix\n",
    "V: voltage sources, O: opamps, H: ccvs, F: cccs, E: vcvs and inductors, these are counted in variable i_unk\n",
    "The of the columns is as they appear in the netlist\n",
    "F: cccs does not get its own column because the controlling current is through a zero volt voltage source, called Vname  <- not true?  cccs is an unknown current\n",
    "```"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "need n1, n2 and column number for B\n",
    "build a list of i_unk ?\n",
    "given element name\n",
    "find the colum number and return the node numbers"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# find the the column position in the B matrix\n",
    "def find_vname(name):\n",
    "    # need to walk through data frame and find these parameters\n",
    "    for i in range(len(df2)):\n",
    "        n1 = df2.loc[i,'p node']\n",
    "        n2 = df2.loc[i,'n node']\n",
    "\n",
    "        # process all the elements creating unknown currents\n",
    "        if name == df2.loc[i,'element']:\n",
    "            return n1, n2, i+1  # vn1, vn2, col_num\n",
    "\n",
    "    print('failed to find matching branch element in find_vname')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left ( 0, \\quad 5, \\quad 3\\right )$$"
      ]
     },
     "execution_count": 30,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i=6\n",
    "#df.loc[i,'element']\n",
    "#df.loc[i,'cp node'] # nodes for controlled sources\n",
    "#df.loc[i,'cn node']\n",
    "#df.loc[i,'Vout'] # node connected to op amp output\n",
    "find_vname(df.loc[i,'Vname'])\n",
    "#df.loc[i,'p node']\n",
    "#df.loc[i,'n node']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$4$$"
      ]
     },
     "execution_count": 58,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i_unk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$4$$"
      ]
     },
     "execution_count": 59,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & -1 & 0\\\\0 & 0 & 0\\\\0 & 0 & -1\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 17,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate the B Matrix\n",
    "sn = 0   # count source number as code walks through the data frame\n",
    "for i in range(len(df)):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    #cn1 = df.loc[i,'cp node'] # nodes for controlled sources\n",
    "    #cn2 = df.loc[i,'cn node']\n",
    "    n_vout = df.loc[i,'Vout'] # node connected to op amp output\n",
    "\n",
    "    # process elements with input to B matrix\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'V':\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, V\n",
    "            if n1 != 0:\n",
    "                B[n1-1,sn] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1,sn] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                B[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "    if x == 'O':  # op amp type\n",
    "        B[n_vout-1,sn] = 1\n",
    "        sn += 1   # increment source count\n",
    "    if (x == 'H') or (x == 'F'):  # H: ccvs, F: cccs,\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, H, F\n",
    "            # check to see if any terminal is grounded\n",
    "            # then stamp the matrix\n",
    "            if n1 != 0:\n",
    "                B[n1-1,sn] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1,sn] = -1\n",
    "            # need to find the vn for Vname\n",
    "            # for H, maybe don't need this because a V source is included in the netlist  <---\n",
    "#            vn1, vn2, col_num = find_vname(df.loc[i,'Vname'])\n",
    "#            if vn2 != 0:\n",
    "#                B[col_num-1,vn1] = 1 # need to fix this, not cn\n",
    "#            if vn1 != 0:\n",
    "#                B[col_num-1,vn2] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                B[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "    if x == 'E':   # vcvs type, only ik column is altered at n1 and n2\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, E\n",
    "            if n1 != 0:\n",
    "                B[n1-1,sn] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1,sn] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                B[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "\n",
    "    if x == 'L':\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, L\n",
    "            if n1 != 0:\n",
    "                B[n1-1,sn] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1,sn] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                B[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                B[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "\n",
    "# check source count\n",
    "if sn != i_unk:\n",
    "    print('source number not equal to i_unk in matrix B')\n",
    "\n",
    "B   # display the B matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## C matrix\n",
    "\n",
    "\n",
    "vcvc code need to be fixed, the controlling node gets and entry\n",
    "~~~\n",
    "old notes\n",
    "The C matrix is an m by n matrix with only 0, 1 and -1 elements (except for controlled sources).  Each location in the matrix corresponds to a particular node (first dimension) or voltage source (second dimension).  If the positive terminal of the ith voltage source is connected to node k, then the element (k,i) in the C matrix is a 1.  If the negative terminal of the ith voltage source is connected to node k, then the element (k,i) in the C matrix is a -1.  Otherwise, elements of the C matrix are zero.\n",
    "\n",
    "<span style=\"color:red\">C matrix needs to be fixed</span>\n",
    "\n",
    "Follow the B matric example  \n",
    "copied code from B matrix, changing B to C\n",
    "swapping index\n",
    "~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}1 & 0 & 0 & 0 & 0\\\\0 & 1 & -1 & 0 & 0\\\\0 & -1 & 0 & 0 & -1\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 19,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate the C Matrix\n",
    "sn = 0   # count source number as code walks through the data frame\n",
    "for i in range(len(df)):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    #cn1 = df.loc[i,'cp node'] # nodes for controlled sources\n",
    "    #cn2 = df.loc[i,'cn node']\n",
    "    n_vout = df.loc[i,'Vout'] # node connected to op amp output\n",
    "\n",
    "    # process elements with input to B matrix\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'V':\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, V\n",
    "            if n1 != 0:\n",
    "                C[sn,n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[sn,n2-1] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                C[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "    if x == 'O':  # op amp type\n",
    "        C[sn,n_vout-1] = 1\n",
    "        sn += 1   # increment source count\n",
    "    if (x == 'H') or (x == 'F'):  # H: ccvs, F: cccs,\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, H, F\n",
    "            # check to see if any terminal is grounded\n",
    "            # then stamp the matrix\n",
    "            if n1 != 0:\n",
    "                C[sn,n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[sn,n2-1] = -1\n",
    "            # need to find the vn for Vname\n",
    "            # for H, maybe don't need this because a V source is included in the netlist  <---\n",
    "#            vn1, vn2, col_num = find_vname(df.loc[i,'Vname'])\n",
    "#            if vn2 != 0:\n",
    "#                B[col_num-1,vn1] = 1 # need to fix this, not cn\n",
    "#            if vn1 != 0:\n",
    "#                B[col_num-1,vn2] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                C[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "    if x == 'E':   # vcvs type, only ik column is altered at n1 and n2\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, E\n",
    "            if n1 != 0:\n",
    "                C[sn,n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[sn,n2-1] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                C[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "\n",
    "    if x == 'L':\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, L\n",
    "            if n1 != 0:\n",
    "                C[sn,n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[sn,n2-1] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                C[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "\n",
    "# check source count\n",
    "if sn != i_unk:\n",
    "    print('source number not equal to i_unk in matrix C')\n",
    "\n",
    "C   # display the C matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# generate the C matrix   <--- OLD C Matrix code\n",
    "sn = 0   # count source number\n",
    "for i in range(len(df)):\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+num_opamps > 1:\n",
    "            if n1 != 0:\n",
    "                C[sn,n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[sn,n2-1] = -1\n",
    "            sn += 1   #increment source count\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                C[n1-1] = 1\n",
    "            if n2 != 0:\n",
    "                C[n2-1] = -1\n",
    "\n",
    "# loop through all the branches and process op amps\n",
    "oan = 0   # running count of op amp number\n",
    "for i in range(len(df)):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    n_vout = df.loc[i,'Vout'] # node connected to op amp output\n",
    "    # look for branches with op amps and process\n",
    "    x = df.loc[i,'element'][0]   # get 1st letter of element name\n",
    "    if x == 'O':\n",
    "        if n1 != 0:\n",
    "            C[oan+num_v,n1-1] = 1\n",
    "        if n2 != 0:\n",
    "            C[oan+num_v,n2-1] = -1\n",
    "        oan += 1  # increment op amp number\n",
    "\n",
    "C   # display the C matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## D matrix\n",
    "The D matrix is an mxm matrix, where m is the number of unknown currents.\n",
    "> m = i_unk = num_v+num_opamps+num_vcvs+num_ccvs+num_ind+num_cccs  \n",
    "\n",
    "Stamps that affect the D matrix are: inductor, ccvs and cccs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}0\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 45,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate the D Matrix\n",
    "sn = 0   # count source number as code walks through the data frame\n",
    "for i in range(len(df)):\n",
    "    n1 = df.loc[i,'p node']\n",
    "    n2 = df.loc[i,'n node']\n",
    "    #cn1 = df.loc[i,'cp node'] # nodes for controlled sources\n",
    "    #cn2 = df.loc[i,'cn node']\n",
    "    #n_vout = df.loc[i,'Vout'] # node connected to op amp output\n",
    "\n",
    "    # process elements with input to B matrix\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'L':\n",
    "        if i_unk > 1:  #is D greater than 1 by 1?\n",
    "            D[sn,sn] += 1/s/sympify(df.loc[i,'element'])\n",
    "        else:\n",
    "            D[sn] += 1/s/sympify(df.loc[i,'element'])\n",
    "        sn += 1   #increment source count\n",
    "\n",
    "    if (x == 'H') or (x == 'F'):  # H: ccvs, F: cccs,\n",
    "        if i_unk > 1:  #is B greater than 1 by n?, H, F\n",
    "            # check to see if any terminal is grounded\n",
    "            # then stamp the matrix\n",
    "            if n1 != 0:\n",
    "                D[sn,n1-1] += sympify(df.loc[i,'element'].lower())  # use a symbol for gain value\n",
    "            if n2 != 0:\n",
    "                D[sn,n2-1] = -1\n",
    "            # need to find the vn for Vname\n",
    "            # for H, maybe don't need this because a V source is included in the netlist  <---\n",
    "#            vn1, vn2, col_num = find_vname(df.loc[i,'Vname'])\n",
    "#            if vn2 != 0:\n",
    "#                B[col_num-1,vn1] = 1 # need to fix this, not cn\n",
    "#            if vn1 != 0:\n",
    "#                B[col_num-1,vn2] = -1\n",
    "        else:\n",
    "            if n1 != 0:\n",
    "                D[n1-1] += sympify(df.loc[i,'element'].lower())  # use a symbol for gain value\n",
    "            if n2 != 0:\n",
    "                D[n2-1] = -1\n",
    "        sn += 1   #increment source count\n",
    "\n",
    "# check source count\n",
    "if sn != i_unk:\n",
    "    print('source number not equal to i_unk in matrix D')\n",
    "\n",
    "# display the The D matrix\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## I matrix\n",
    "The I matrix is an n by 1 matrix with each element of the matrix corresponding to a particular node.  The value of each element of I is determined by the sum of current sources into the corresponding node.  If there are no current sources connected to the node, the value is zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}0\\\\0\\\\0\\\\0\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 40,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate the I matrix, current sources have N2 = arrow end\n",
    "for i in range(len(df)):\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",
    "        g = sympify(df.loc[i,'element'])\n",
    "        # sum the current into each node\n",
    "        if n1 != 0:\n",
    "            I[n1-1] -= g\n",
    "        if n2 != 0:\n",
    "            I[n2-1] += g\n",
    "\n",
    "I  # display the I matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## V matrix\n",
    "The V matrixis an nx1 matrix formed of the node voltages.  Each element in V corresponds to the voltage at the equivalent node in the circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}v_{1}\\\\v_{2}\\\\v_{3}\\\\v_{4}\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 41,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate the V matrix\n",
    "for i in range(num_nodes):\n",
    "    V[i] = sympify('v{:d}'.format(i+1))\n",
    "\n",
    "V  # display the V matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## J matrix\n",
    "The is an m by 1 matrix, with one entry for the current through each voltage source."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}I_{V1}\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 43,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The J matrix is an mx1 matrix, with one entry for the current through each voltage source.\n",
    "sn = 0   # count source number\n",
    "oan = 0   #count op amp number\n",
    "for i in range(len(df)):\n",
    "    # process all the passive elements\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'V':\n",
    "        J[sn] = sympify('I_{:s}'.format(df.loc[i,'element']))\n",
    "        sn += 1\n",
    "    if x == 'O':  # this needs to be checked <---- needs debugging\n",
    "        J[oan+num_v] = sympify('I_{:s}'.format(df.loc[i,'element']))\n",
    "        oan += 1\n",
    "\n",
    "J  # diplay the J matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## E matrix\n",
    "The E matrix is mx1 and holds the values of the independent voltage sources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}V_{1}\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 46,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate the E matrix\n",
    "sn = 0   # count source number\n",
    "for i in range(len(df)):\n",
    "    # process all the passive elements\n",
    "    x = df.loc[i,'element'][0]   #get 1st letter of element name\n",
    "    if x == 'V':\n",
    "        E[sn] = sympify(df.loc[i,'element'])\n",
    "        sn += 1\n",
    "\n",
    "E   # display the E matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Z matrix\n",
    "The Z matrix holds the independent voltage and current sources and is the combination of 2 smaller matrices I and E.  The Z matrix is (m+n) by 1, n is the number of nodes, and m is the number of independent voltage sources.  The I matrix is n by 1 and contains the sum of the currents through the passive elements into the corresponding node (either zero, or the sum of independent current sources). The E matrix is m by 1 and holds the values of the independent voltage sources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left [ 0, \\quad 0, \\quad 0, \\quad 0, \\quad V_{1}\\right ]$$"
      ]
     },
     "execution_count": 47,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z = I[:] + E[:]\n",
    "Z  # display the Z matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## X matrix\n",
    "The X matrix is an (n+m) by 1 vector that holds the unknown quantities (node voltages and the currents through the independent voltage sources). The top n elements are the n node voltages. The bottom m elements represent the currents through the m independent voltage sources in the circuit. The V matrix is n by 1 and holds the unknown voltages.  The J matrix is m by 1 and holds the unknown currents through the voltage sources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left [ v_{1}, \\quad v_{2}, \\quad v_{3}, \\quad v_{4}, \\quad I_{V1}\\right ]$$"
      ]
     },
     "execution_count": 48,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = V[:] + J[:]\n",
    "X  # display the X matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## A matrix\n",
    "The A matrix is (m+n) by (m+n) and will be developed as the combination of 4 smaller matrices, G, B, C, and D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}\\frac{1}{R_{1}} & - \\frac{1}{R_{1}} & 0 & 0 & 1\\\\- \\frac{1}{R_{1}} & C_{1} s + \\frac{1}{R_{1}} + \\frac{1}{L_{1} s} & - \\frac{1}{L_{1} s} & 0 & 0\\\\0 & - \\frac{1}{L_{1} s} & C_{2} s + \\frac{1}{L_{2} s} + \\frac{1}{L_{1} s} & - \\frac{1}{L_{2} s} & 0\\\\0 & 0 & - \\frac{1}{L_{2} s} & \\frac{1}{R_{2}} + \\frac{1}{L_{2} s} & 0\\\\1 & 0 & 0 & 0 & 0\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 49,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = num_nodes\n",
    "m = num_v+num_opamps\n",
    "A = zeros(m+n,m+n)\n",
    "for i in range(n):\n",
    "    for j in range(n):\n",
    "        A[i,j] = G[i,j]\n",
    "\n",
    "if num_v+num_opamps > 1:\n",
    "    for i in range(n):\n",
    "        for j in range(m):\n",
    "            A[i,n+j] = B[i,j]\n",
    "            A[n+j,i] = C[j,i]\n",
    "else:\n",
    "    for i in range(n):\n",
    "        A[i,n] = B[i]\n",
    "        A[n,i] = C[i]\n",
    "\n",
    "A  # display the A matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}I_{V1} + \\frac{v_{1}}{R_{1}} - \\frac{v_{2}}{R_{1}} = 0\\\\v_{2} \\left(C_{1} s + \\frac{1}{R_{1}} + \\frac{1}{L_{1} s}\\right) - \\frac{v_{1}}{R_{1}} - \\frac{v_{3}}{L_{1} s} = 0\\\\v_{3} \\left(C_{2} s + \\frac{1}{L_{2} s} + \\frac{1}{L_{1} s}\\right) - \\frac{v_{4}}{L_{2} s} - \\frac{v_{2}}{L_{1} s} = 0\\\\v_{4} \\left(\\frac{1}{R_{2}} + \\frac{1}{L_{2} s}\\right) - \\frac{v_{3}}{L_{2} s} = 0\\\\v_{1} = V_{1}\\end{matrix}\\right]$$"
      ]
     },
     "execution_count": 50,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate the circuit equations\n",
    "n = num_nodes\n",
    "m = num_v+num_opamps\n",
    "eq_temp = 0  # temporary equation used to build up the equation\n",
    "equ = zeros(m+n,1)  #initialize the array to hold the equations\n",
    "for i in range(n+m):\n",
    "    for j in range(n+m):\n",
    "        eq_temp += A[i,j]*X[j]\n",
    "    equ[i] = Eq(eq_temp,Z[i])\n",
    "    eq_temp = 0\n",
    "\n",
    "equ   # display the equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Use the str() function to convert sympy equations to strings.  These strings can be copid to a new notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Matrix([[Eq(I_V1 + v1/R1 - v2/R1, 0)], [Eq(v2*(C1*s + 1/R1 + 1/(L1*s)) - v1/R1 - v3/(L1*s), 0)], [Eq(v3*(C2*s + 1/(L2*s) + 1/(L1*s)) - v4/(L2*s) - v2/(L1*s), 0)], [Eq(v4*(1/R2 + 1/(L2*s)) - v3/(L2*s), 0)], [Eq(v1, V1)]])'"
      ]
     },
     "execution_count": 51,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(equ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{v4, R1, C1, v1, v3, L1, V1, I_V1, C2, v2, R2, L2, s}'"
      ]
     },
     "execution_count": 52,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(equ.free_symbols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[v1, v2, v3, v4, I_V1]'"
      ]
     },
     "execution_count": 53,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>element</th>\n",
       "      <th>p node</th>\n",
       "      <th>n node</th>\n",
       "      <th>cp node</th>\n",
       "      <th>cn node</th>\n",
       "      <th>Vout</th>\n",
       "      <th>value</th>\n",
       "      <th>Vname</th>\n",
       "      <th>Lname1</th>\n",
       "      <th>Lname2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>V1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>L1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4.411</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>L2</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.535</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>C1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.653</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>C2</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.814</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>R2</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>R1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ]
     },
     "execution_count": 54,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
   ],
   "source": [
   ]
  },
  {
   "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
}