Circuit Solver: Primitive Components

One nice feature of CMax is that it lets us simulate circuits before building them. However, simulating in CMax requires creating a protoboard layout; often, we may be interested in simulating a circuit without having to first generate a protoboard layout, particularly in the case of more complicated circuits.

In this exercise, we will build on the linear equation solver developed in the previous exercises to implement the "base layer" of a circuit solver, which can be used to solve arbitrary linear circuits.

1) Getting Started

Template code for these exercise is available (in zip format) here. You should do your work in these files and save it on your computer, as some of the following exercises (both this week and next) will build on this exercise.

2) Human vs. Machine

In our approach to solving circuits, we were able to take advantage of our human intuition about circuits, and to leverage many common patterns (resistor combinations, voltage dividers, etc). When we are programming the computer to solve circuits, it will not be able to so easily take advantage of that intuition.

However, while solving large systems of equations is very difficult for humans, computers have little trouble with it. Thus, while our human approach to solving circuits relied heavily on intuition, our computational approach will simply involve setting up a system of linear equations and letting the computer solve for it.

It is important that even though this method works, it should only be used as a last resort by humans because humans are bad (and slow) at algebra.

3) Specifying and Solving Systems of Linear Equations

Consider the problem of finding values for x and y that satisfy the two equations:

In the previous two exercises, we developed a system for specifying and solving systems of linear equations, so that we can solve a system of equations with:

answer = solve_equations(eqnlist)

where eqnlist is a list of equations to be solved.

We can think of each equation as a list of terms that sum to zero. We will represent an equation by a list of tuples of the form (coefficient, variable) where coefficient is a number and variable is a string that represents the name of a variable, so that each tuple represents a term of the form coefficient*variable. If variable is None, then the associated coefficient is taken to be a constant term. The following code specifies the equations in the previous example:

eq1 = [(5,'x'), (-2,'y'), (-3,None)]
eq2 = [(3,'x'), (4,'y'), (-33,None)]

The following code solves eq1 and eq2:

answer = solve_equations([eq1,eq2],verbose=False)
print('x =', answer['x'])
print('y =', answer['y'])

If you have not yet completed the gauss_solve or solve_equations functions from the previous exercises, you can import working versions for debugging purposes by adding the following to the top of your circ.py file:

from lib601.le import gauss_solve, solve_equations

4) Circuit Equations

We will use the linear equations solver described in the previous questions to solve circuits using the node method. The first step is to identify the nodes of the circuit, and to associate voltages with each of those nodes. The node voltages are labeled as e_0, e_1, and e_2 in the diagram below. Choose one of these nodes as ground (here e_0).

Next, associate currents with each of the components (here i_1, i_2, i_3, and i_4).

Now, write three sets of equations:

1. one constitutive equation for each component
2. one KCL equation for each node except ground
3. one equation to set the ground potential to zero

In the previous example, the component equations are:

The KCL equations are:

The ground equation is:

Equations

In the following box, set a variable equation_list to be a list containing these equations, represented as tuples as described above. Use variable names as shown in the diagram (e.g. 'e0', 'e1', 'i4', etc.).

#Your Code Here equation_list = None

5) Describing Circuits

In this section, we will develop a representation for circuit elements in Python. We will begin with one-ports, which are components through which a single current flows, and across which a single voltage develops:

We will think of the voltage across the one-port as the difference between two node voltages (labeled as e_1 and e_2 in this diagram). Thus, the one-port is characterized by three electrical variables: e_1, e_2, and i.

We have provided (in circ.py) a generic superclass OnePort, which will serve as a superclass for all our circuit components. OnePort takes three strings at initialization time, representing the names of the specific nodes connected to e_1, e_2, and i in the diagram above, and stores these in instance variables e1, e2, and i, respectively.

We have discussed several types of one-ports, including voltage sources, current sources, and resistors:

Notice that the reference direction for a current source is downward. This makes the component current (i above) equal to the source current I_o.

Write subclasses of OnePort to characterize sources and resistors as follows:

• `VSrc(v0, e1, e2, i)` represents a voltage source with (constant) voltage `v0`.
• `ISrc(i0, e1, e2, i)` represents a current source with (constant) current `i0`.
• `Resistor(r, e1, e2, i)` represents a resistor with (constant) resistance `r`.

Notice that e1, e2, and i are strings representing variable names, but v0, i0, and r are numbers representing constants.

The initialization methods for these subclasses should create instance variables e1, e2, and i by calling the initialization method for OnePort. Each initialization method should also create an equation (as a list of the form described in the previous exercise) and store the equation in an instance variable called equation.

Enter your definitions for VSrc, ISrc, and Resistor below:

class VSrc(OnePort): def __init__(self, v0, e1, e2, i): OnePort.__init__(self,e1,e2,i) pass #Your Code Here class ISrc(OnePort): def __init__(self, i0, e1, e2, i): OnePort.__init__(self,e1,e2,i) pass #Your Code Here class Resistor(OnePort): def __init__(self, r, e1, e2, i): OnePort.__init__(self,e1,e2,i) pass #Your Code Here

6) Solving Circuits

Write a procedure called solve_circuit that takes two inputs. The first is a list of instances of OnePort (described above) describing the circuit to be solved. The second is a string that represents the ground node. The procedure should create a system of equations as described in the first section:

1. one component (or constitutive) equation for each component,
2. one KCL equation for each node except ground, and
3. one equation to set the ground potential to zero.

and should return a dictionary that maps those circuit variables with numbers that represent their values. Note that this is precisely the type of object that is returned by solve_equations.

You may assume that OnePort, as well as the classes from the previous section, are defined for you, and that the functions and variable from le are imported as in the skeleton file circ.py.

Note that you can test your code in IDLE by trying to use your solver on some of the circuits you have solved by hand in the last few weeks' exercises (for which you should already know the answer!).

def solve_circuit(component_list, GND): # flatten_list is necessary for lists that contain two-ports. # It has no effect on lists that contain just one-ports. # Do not remove the following line. component_list = flatten_list(component_list) pass #Your Code Here

7) Solving

Finally, use your circuit solver to solve the following circuit when all resistors have some constant resistance R:

assuming that V_i is specified in a Python variable vi, and R is specified in a Python variable r.

Store a list of circuit components representing the circuit above in the variable circuit_components below. Use the name 'gnd' to represent the ground node, and 'v+' and 'v-' to represent the positive and negative terminals of the V_o port.

On your own machine, use solve_circuit to solve for the specified voltage when V_i = 125 Volts and R = 31086\Omega. Enter your result below, in Volts, accurate to within 10^{-6} Volts:

On your own machine, use solve_circuit to solve for the specified voltage when V_i = 185 Volts and R = 72761\Omega. Enter your result below, in Volts, accurate to within 10^{-6} Volts:

On your own machine, use solve_circuit to solve for the specified voltage when V_i = 99 Volts and R = 83363\Omega. Enter your result below, in Volts, accurate to within 10^{-6} Volts: