Releasing version 0.2.2

Finally, releasing the next version 0.2.2. The example of the buck converter is there in testckt16.csv with the control code in control.py. And the description of the circuit parameters in testckt16_params.csv and the controls in control_desc.csv.

http://sourceforge.net/projects/pythonpowerelec/

Well, well, well. It is the 31st of December 2013. I started this project a little more than a year ago and frankly I never thought I would get this far. So far everything has been coded to be automatic and without hardcoding any particular circuits which I feared I might have to. If all goes well, I will add other equipment like transformers, motors. But first I need to simulate power electronic converters of every type which just the library that I have. I suppose a lot of errors will creep up but I think the main concept is there and should work out.


And finally a big thank you to my blog readers. I see a lot of hits to the blog and also received some very nice comments. Thank you so much for reading my blog and I hope that soon I'll have a real simulator that every one of you can use on any OS. This has been a great year 2013 and I hope 2014 is just as good if not better.

Happy New Year to all of you and I wish you all the success for an awesome 2014!

I'll take a break for a few days and post again when I recover from my hangover :)

Diode freewheeling - nodal analysis

Where do I begin? Been coding continuously for the past three days and now have to find where I am.

As posted before, the only way to solve the problem of getting the diode to freewheel is by a nodal analysis. Essentially, the current through an inductor should not change instantaneously. If it does, it is bad design and I'll have to figure that out later. But in standard converter circuits, the inductor is expected to freewheel through a diode. As in the example of the buck converter.

So what I have coded is a function to perform nodal analysis take inductors as current sources. So I perform a dc analysis on a snapshot of the circuit at an instant and find out where the currents would flow if the inductor current were to remain constant.

Take the snapshot when the switch turns off with the inductor La having a non-zero current. So this current will flow through the switch and the diode almost equally since these are two high resistance paths.

With these currents calculated through nodal analysis, I try to figure out if any of the devices in the circuit has the capability to change its state. Since only nonlinear devices can do so, the remaining devices will have empty functions. The diode and switch will have the function called determine_state. Here is the code for the switch (click on "View Raw" at the bottom of the code box to see code in another window)

	def determine_state(self, br_currents, sys_branches, sys_events):
	""" Determines the state of the switch following an event
	where the continuity of current through an inductor is
	about to be broken."""
	# Mark the position of the switch in sys_branches
	for c1 in range(len(sys_branches)):
	if csv_tuple(self.pos) in sys_branches[c1]:
	branch_pos=c1
	# Since branch current direction is by default considered
	# positive when flowing away from the starting node
	# If the branch current is negative, with the switch cathode
	# closer towards the starting node, current direction is
	# positive
	if br_currents[branch_pos]*self.resistor<-1.0:
	if sys_branches[branch_pos].index(self.polrty)<sys_branches[branch_pos].index(csv_tuple(self.pos)):
	if self.status=="off" and self.control_values[0]>0.0:
	sys_events[branch_pos]="yes"
	self.status="on"
	# If the current direction is reverse, switch can never conduct
	if br_currents[branch_pos]<0.0:
	if sys_branches[branch_pos].index(self.polrty)>sys_branches[branch_pos].index(csv_tuple(self.pos)):
	if self.status=="on":
	sys_events[branch_pos]="yes"
	self.status="off"
	if br_currents[branch_pos]*self.resistor>1.0:
	if sys_branches[branch_pos].index(self.polrty)>sys_branches[branch_pos].index(csv_tuple(self.pos)):
	if self.status=="off" and self.control_values[0]>0.0:
	sys_events[branch_pos]="yes"
	self.status="on"
	if br_currents[branch_pos]>0.0:
	if sys_branches[branch_pos].index(self.polrty)<sys_branches[branch_pos].index(csv_tuple(self.pos)):
	if self.status=="on":
	sys_events[branch_pos]="yes"
	self.status="off"
	# Update the value of resistance
	if self.status=="off":
	self.resistor=self.resistor_off
	else:
	self.resistor=self.resistor_on
	return

view raw determine_state.py hosted with ❤ by GitHub

And here is the code for the nodal analysis (click on "View Raw" at the bottom of the code box to see code in another window)

	def current_continuity(list_of_nodes, branch_info, branch_stiff, nd_voltage, br_currents, mho_matrix, src_vector, sys_inputs):
	"""Following an event, to find the branch currents through nodal analysis.
	The objective is to determine if certain devices must change their status
	to maintain continuity of inductor currents."""
	# Node voltages. There will be one reference node
	for c1 in range(len(nd_voltage)):
	nd_voltage[c1]=0.0
	# The admittance matrix. As it is more or less
	# a dc analysis of a snapshot of the circuit
	# only resistances are considered.
	for c1 in range(len(mho_matrix)):
	for c2 in range(len(mho_matrix)):
	mho_matrix[c1][c2]=0.0
	# The source vector. This will contain
	# currents sources - inductor currents,
	# currents through zero impedance branches
	# and finally also voltages across zero
	# impedance branches
	for c1 in range(len(src_vector)):
	src_vector[c1]=0.0
	# The concept is of nodal analysis.
	# If a branch has only a resistance the currents
	# are expressed as a difference of node voltages divided
	# by the resistance.
	# If a branch has an inductance and it is non stiff,
	# it is treated as a current source. This is the main
	# feature as the inductor current must not change
	# instantaneously.
	# If it has zero impedance, it is treated as a current
	# source. This was done later as the currents through
	# these branches can't be accounted for by nodal analysis
	# and these currents aren't suppose to change anyway.
	# It is only the nonlinear devices that are essentially
	# variable resistances that are supposed to have changing
	# currents.
	# Start iterating through the nodes
	for c1 in range(len(list_of_nodes)):
	# Look for the node as the starting or ending node in branches
	for c2 in range(len(branch_info)):
	if ((list_of_nodes[c1]==branch_info[c2][0]) or (list_of_nodes[c1]==branch_info[c2][-2])):
	# Mark the position of the other node
	if (list_of_nodes[c1]==branch_info[c2][0]):
	end_node_pos=list_of_nodes.index(branch_info[c2][-2])
	# The default direction of current is taken to be
	# away from the starting node - start to end.
	branch_src_dir=1.0
	else:
	end_node_pos=list_of_nodes.index(branch_info[c2][0])
	branch_src_dir=-1.0
	# If resistance of the branch is non-zero
	if branch_info[c2][-1][0][0]:
	# If the branch has no inductance or is a stiff branch
	# in which case inductance is negligible compared
	# to the resistance and the branch is stiff.
	if (branch_info[c2][-1][0][1]==0.0):
	mho_matrix[c1][c1]+=1.0/branch_info[c2][-1][0][0]
	mho_matrix[c1][end_node_pos]-=1.0/branch_info[c2][-1][0][0]
	# Similarly, any voltage source that exists
	# will be treated as positive if it forces a
	# a current away the starting node.
	# The way branch_info contains these sources is
	# compatible to the definition
	# src_vector is on the RHS of the equation,
	# so thus the -ve sign
	for c3 in range(len(branch_info[c2][-1][1])):
	src_vector[c1]-=branch_src_dir*branch_info[c2][-1][1][c3]*sys_inputs.data[c3][0]/branch_info[c2][-1][0][0]
	# Check if inductance is non-zero
	if branch_info[c2][-1][0][1]:
	# Check if branch is not stiff
	if branch_stiff[c2]=="no":
	# Add the current to the src_vector as a current source
	src_vector[c1]-=branch_src_dir*br_currents[c2]
	# Check if is a zero impedance branch
	if ((branch_info[c2][-1][0][0]==0.0) and (branch_info[c2][-1][0][1]==0.0)):
	src_vector[c1]-=branch_src_dir*br_currents[c2]
	# There are some rows that are exact negatives of the other for the reason, that
	# they are essentially reference nodes. So these need not be included
	for c1 in range(len(mho_matrix)-1):
	for c2 in range(c1+1, len(mho_matrix)):
	rows_the_same="yes"
	for c3 in range(len(mho_matrix[c1])):
	if (mho_matrix[c1][c3]+mho_matrix[c2][c3]):
	rows_the_same="no"
	if rows_the_same=="yes":
	src_vector[c2]=0.0
	for c3 in range(len(mho_matrix[c2])):
	mho_matrix[c2][c3]=0.0
	# Finding the supernodes in the system
	# Supernodes are essentially those nodes that
	# have a zero impedance branch connected to them
	# These branches may or may not have a voltage source.
	# When there is a supernode, KCL continues to the other node
	# of the zero impedance branch. So essentially the two end
	# nodes of a zero impedance branch have their KCL equations
	# added and their node voltages are expressed by an equation
	# depending on whether they have a voltage source.
	# The complete list of supernodes
	supernode_list=[]
	for c1 in range(len(list_of_nodes)):
	# Each small segment of supernodes
	current_supernode=[]
	# Check if the node has been found as a supernode before
	node_found="no"
	for c2 in range(len(supernode_list)):
	if c1 in supernode_list[c2]:
	node_found="yes"
	# If not add it as a supernode
	# This is the first node in the current
	# running list. If no other nodes are found,
	# it will be deleted at the next iteration
	# as the node is not a supernode in that case.
	if node_found=="no":
	current_supernode.append(c1)
	# Iterate through the remaining nodes
	for c2 in range(len(list_of_nodes)):
	# Look for the nodes in both the
	# current list and the complete list
	node_found="no"
	if c2 in current_supernode:
	node_found=="yes"
	if node_found=="no":
	for c3 in range(len(supernode_list)):
	if c2 in supernode_list[c3]:
	node_found="yes"
	# If the node has not been found, check if it is connected
	# to any of the existing nodes in the current list
	# by branches with zero impedance.
	if node_found=="no":
	for c3 in range(len(branch_info)):
	# Check if a branch has zero impedance.
	if ((branch_info[c3][-1][0][0]==0.0) and (branch_info[c3][-1][0][1]==0.0)):
	# If the current node is the first node in the current
	# branch being examined, check if any of the nodes
	# in the current supernode list are the ending nodes.
	# If so append the current node to the current super node list
	if (list_of_nodes[c2]==branch_info[c3][0]):
	for c4 in current_supernode:
	if list_of_nodes[c4]==branch_info[c3][-2]:
	current_supernode.append(c2)
	# If the current node is the ending node in the current
	# branch being examined, check if any of the nodes
	# in the current supernode list are the starting nodes.
	# If so append the current node to the current super node list
	if (list_of_nodes[c2]==branch_info[c3][-2]):
	for c4 in current_supernode:
	if list_of_nodes[c4]==branch_info[c3][0]:
	current_supernode.append(c2)
	# There is another possibility
	# A node could be a supernode, but is connected only
	# to another node which appears later in the node list
	# So, the above calculation will not work as it looks
	# for a node connected to existing supernodes by zero
	# impedance branches.
	# So essentially it is a rerun to pickup any nodes
	# that were missed the first time.
	# Iterate through existing list of current supernodes.
	for c2 in current_supernode:
	# Then look through the entire list of nodes.
	for c3 in range(len(list_of_nodes)):
	# Check it is has been found as a supernode
	# in the current list
	node_found="no"
	if c3 in current_supernode:
	node_found="yes"
	# Check it has been found elsewhere.
	if node_found=="no":
	for c4 in range(len(supernode_list)):
	if c3 in supernode_list[c4]:
	node_found="yes"
	# Check if the current node is connected to any of the nodes
	# in the current supernode list by a zero impedance branch.
	if node_found=="no":
	for c5 in range(len(branch_info)):
	if ((branch_info[c5][-1][0][0]==0.0) and (branch_info[c5][-1][0][1]==0.0)):
	if (list_of_nodes[c3]==branch_info[c5][0]):
	for c6 in current_supernode:
	if (list_of_nodes[c6]==branch_info[c5][-2]):
	current_supernode.append(c3)
	if (list_of_nodes[c3]==branch_info[c5][-2]):
	for c6 in current_supernode:
	if (list_of_nodes[c6]==branch_info[c5][0]):
	current_supernode.append(c3)
	# Sort the list of current supernodes
	# The reason is so that the KCL equations can be added
	# and the first node will contain the sum.
	current_supernode.sort()
	# # If the current super node list has more than
	# # one node, there is a zero impedance branch
	# # and so it is super node list.
	if len(current_supernode)>1:
	supernode_list.append(current_supernode)
	# For every supernode list,
	# add the KCL equations at subsequnt supernodes to the
	# first node in the supernode list. Then set the other
	# equations to zero. Also, with the source vector.
	for c1 in range(len(supernode_list)):
	row1=supernode_list[c1][0]
	for c2 in range(1, len(supernode_list[c1])):
	row2=supernode_list[c1][c2]
	src_vector[row1]+=src_vector[row2]
	src_vector[row2]=0.0
	for c3 in range(len(mho_matrix[0])):
	mho_matrix[row1][c3]+=mho_matrix[row2][c3]
	mho_matrix[row2][c3]=0.0
	# Make a list of the zero rows.
	zero_rows=[]
	for c1 in range(len(mho_matrix)):
	is_row_zero="yes"
	for c2 in range(len(mho_matrix[c1])):
	if mho_matrix[c1][c2]:
	is_row_zero="no"
	if is_row_zero=="yes":
	zero_rows.append(c1)
	# Move the zero rows to the end of the matrix by row interchanges.
	for c1 in zero_rows:
	for c2 in range(len(mho_matrix)-1, c1, -1):
	if c2 not in zero_rows:
	src_vector[c1], src_vector[c2] = src_vector[c2], src_vector[c1]
	for c3 in range(len(mho_matrix[c1])):
	mho_matrix[c1][c3], mho_matrix[c2][c3] = mho_matrix[c2][c3], mho_matrix[c1][c3]
	# Now to add equations that describe the voltage difference
	# between two nodes connected by a zero impedance branch
	# The starting row if the size of the addmitance matrix
	# minus the zero rows.
	supernode_row=len(mho_matrix)-len(zero_rows)
	# Iterate through the supernode lists
	for c1 in range(len(supernode_list)):
	# In every supernode list, take a supernode
	# and express its voltage with respect to every
	# other supernode in that list
	for c2 in range(len(supernode_list[c1])-1):
	for c3 in range(c2+1, len(supernode_list[c1])):
	# Find out which supernode is the start and which is
	# the end node of the branch.
	for c4 in range(len(branch_info)):
	if ((branch_info[c4][0]==list_of_nodes[supernode_list[c1][c2]]) and (branch_info[c4][-2]==list_of_nodes[supernode_list[c1][c3]])):
	# Confirm whether the branch is a zero impedance branch
	if (branch_info[c4][-1][0][0]==0.0 and branch_info[c4][-1][0][1]==0.0):
	# This is mere V1-V2=Vbranch
	# The plus and minus signs are for different cases of
	# starting node and ending node.
	mho_matrix[supernode_row][supernode_list[c1][c2]]=1.0
	mho_matrix[supernode_row][supernode_list[c1][c3]]=-1.0
	for c5 in range(len(branch_info[c4][-1][1])):
	src_vector[supernode_row]+=branch_info[c4][-1][1][c5]*sys_inputs.data[c5][0]
	# Increment the supernode row pointer
	supernode_row+=1
	if ((branch_info[c4][-2]==list_of_nodes[supernode_list[c1][c2]]) and (branch_info[c4][0]==list_of_nodes[supernode_list[c1][c3]])):
	if (branch_info[c4][-1][0][0]==0.0 and branch_info[c4][-1][0][1]==0.0):
	mho_matrix[supernode_row][supernode_list[c1][c2]]=-1.0
	mho_matrix[supernode_row][supernode_list[c1][c3]]=1.0
	for c5 in range(len(branch_info[c4][-1][1])):
	src_vector[supernode_row]-=branch_info[c4][-1][1][c5]*sys_inputs.data[c5][0]
	supernode_row+=1
	# Now to solve the equation AX=B
	# Look for diagonal elements - check if they are zero
	# If so, look in that same column in subsequent rows
	# if there is a non zero element and exchange them
	# Later, make the matrix upper triangular.
	# Using row manipulations, make all the elements
	# below a diagonal row zero.
	for c1 in range(len(mho_matrix)):
	if not mho_matrix[c1][c1]:
	for c2 in range(c1+1, len(mho_matrix)):
	if mho_matrix[c2][c1]:
	src_vector[c1], src_vector[c2] = src_vector[c2], src_vector[c1]
	for c3 in range(len(mho_matrix[c1])):
	mho_matrix[c1][c3], mho_matrix[c2][c3] = mho_matrix[c2][c3], mho_matrix[c1][c3]
	if mho_matrix[c1][c1]:
	for c2 in range(c1+1, len(mho_matrix)):
	if mho_matrix[c2][c1]:
	src_vector[c2]-=src_vector[c1]*mho_matrix[c2][c1]/mho_matrix[c1][c1]
	for c3 in range(len(mho_matrix[c1])):
	mho_matrix[c2][c3]-=mho_matrix[c2][c1]*mho_matrix[c1][c3]/mho_matrix[c1][c1]
	# The last row of the manipulated admittance matrix will
	# be zero as it is the reference node. So taking this
	# voltage to be zero, calculate all the other node voltages
	# from second last to first.
	for c1 in range(len(mho_matrix)-2, -1, -1):
	if mho_matrix[c1][c1]:
	nd_voltage[c1]=src_vector[c1]
	for c2 in range(c1+1, len(mho_matrix[c1])):
	nd_voltage[c1]-=mho_matrix[c1][c2]*nd_voltage[c2]
	nd_voltage[c1]=nd_voltage[c1]/mho_matrix[c1][c1]
	# Calculate the branch currents as I=(Vnode1-Vnode2-Vsource)/Rbranch
	for c1 in range(len(branch_info)):
	if branch_stiff=="yes" or branch_info[c1][-1][0][1]==0.0:
	start_node=list_of_nodes.index(branch_info[c1][0])
	end_node=list_of_nodes.index(branch_info[c1][-2])
	if branch_info[c1][-1][0][0]:
	br_currents[c1]=(nd_voltage[start_node]-nd_voltage[end_node])/branch_info[c1][-1][0][0]
	for c2 in range(len(branch_info[c1][-1][1])):
	br_currents[c1]+=branch_info[c1][-1][1][c2]*sys_inputs.data[c2][0]/branch_info[c1][-1][0][0]
	return

view raw nodal_analysis.py hosted with ❤ by GitHub

Yes, it is a monster. Anyway, the basic concept is:

1. If a branch is not stiff and has an inductor, it becomes a current source.
2. If it has no impedance, the nodes on either end of the branch become super nodes.
3. If it only a resistance or is a stiff branch, it is expressed in KCL
(Vnode1-Vnode2)/Rbranch=Ibranch

4. Also if a branch has zero impedance, the current through it is treated as a current source.
5. Because of this, the only thing to be calculated are the resistive branches which is what needs to be done because that is where the non-linear devices will be.

6. The super node was a little tough to handle. When two nodes are connected by a branch with zero impedance, the current through that branch is tough to define. Therefore, the KCLs at the two nodes can be added up to form one KCL equation. And the second equation will be the voltage of the branch connecting these nodes.

7. In general, several nodes can be connected together to form a super node. Even worse, several groups of super nodes can exist.

8. Once the KCL equations are established, they need to reduced to upper triangular form and solved backwards. One node will become the reference node and will have zero voltage.

9. The branch currents will then be calculated from these node voltages. and there comes the next part of the story.


Because the nodal analysis could have changed the nature of the circuit by changing the state of nonlinear devices, it may so happen that the loop currents calculated before are not correct. So we need to recalculate the loop currents from the branch currents that the nodal analysis has given. The code for that is in compute_loop_currents (click on "View Raw" at the bottom of the code box to see code in another window)

	def compute_loop_currents(matrix_e, matrix_a, matrix_b, dt, sys_loops, branch_info, stiff_info, sys_loop_map, src_list, state_vector):
	""" Calculates the loop currents after an event from branch currents."""
	# Make a list of the nonstiff loops
	# Because stiff loops will essentially have a negligible
	# current.
	nonstiff_loops=[]
	for c1 in range(len(sys_loop_map)):
	# Check if loop c1 has a stiff branch
	is_loop_stiff="no"
	for c2 in range(len(branch_info)):
	if sys_loop_map[c1][c2]=="stiff":
	is_loop_stiff="yes"
	if is_loop_stiff=="no":
	nonstiff_loops.append(c1)
	# To begin with find out which of the branches
	# occur only in one loop. This will make
	# computations easier as those branch currents
	# will automatically become the initial values
	# for the loop currents in the next loop analysis.
	# A list of loops and branches with this info
	# It is a corresponding mapping.
	single_loops=[]
	single_branches=[]
	# Iterate through the nonstiff loops.
	for c1 in nonstiff_loops:
	# Iterate through the branches
	for c2 in range(len(branch_info)):
	# Check if the corresponding system map is a "yes"
	# Which means branch exixts.
	if sys_loop_map[c1][c2]=="yes":
	# Look for the branch in all other nonstiff loops
	# A single occurance elsewhere will mean loop exists
	# So start with the default "no"
	does_branch_occur="no"
	for c3 in nonstiff_loops:
	if not c1==c3:
	if sys_loop_map[c3][c2]=="yes":
	does_branch_occur="yes"
	if does_branch_occur=="no":
	# Next check is both the loop and the branch have not been
	# found before to prevent clashes.
	if ((c1 not in single_loops) and (c2 not in single_branches)):
	single_loops.append(c1)
	single_branches.append(c2)
	# If the number of loops where a branch occurs in only one
	# loop is less than the number of nonstiff loops, row
	# manipulations will have to be done to the remaining loops
	# so that one branch current can be taken as the loop current
	if (len(single_loops)<len(nonstiff_loops)):
	# Iterate through the nonstiff loops
	for c1 in nonstiff_loops:
	# Make sure the loop has not been found.
	# Don't manipulate those which have been isolated.
	if c1 not in single_loops:
	# Look through the branches
	for c2 in range(len(branch_info)):
	# Again check if the branch has not been isolated.
	if c2 not in single_branches:
	# If a loop exists. So this will find the
	# first loop that exists in a loop
	if sys_loop_map[c1][c2]=="yes":
	# Look at the remaining nonstiff loops.
	for c3 in nonstiff_loops:
	if not c1==c3:
	# If branch exists in any other nonstiff loop
	# Need to manipulate the loops and for that
	# need to find out the sense in which the branches
	# are in the loops.
	if sys_loop_map[c3][c2]=="yes":
	# Basically take a running counter with loop c1
	# starting from the last branch and keep checking
	# whether a branch exists. This is because as
	# manipulations take place, branches disappear
	# so an exception mght be thrown.
	c4=len(sys_loops[c1][c1])-1
	while c4>=0:
	try:
	sys_loops[c1][c1][c4]
	except:
	pass
	else:
	c5=len(sys_loops[c3][c3])-1
	while c5>=0:
	try:
	sys_loops[c3][c3][c5]
	except:
	pass
	else:
	if sys_loops[c1][c1][c4][:-1]==sys_loops[c3][c3][c5][:-1]:
	if branch_info[c2][:-1]==sys_loops[c1][c1][c4][:-1]:
	# If the branches are in the same sense, subtract them
	# or else add them.
	if sys_loops[c1][c1][c4][-1]==sys_loops[c3][c3][c5][-1]:
	loop_manipulate(sys_loops, c3, c1, "diff")
	else:
	loop_manipulate(sys_loops, c3, c1, "add")
	c5=c5-1
	c4=c4-1
	# If both loop and branch have not been found add them
	if ((c1 not in single_loops) and (c2 not in single_branches)):
	single_loops.append(c1)
	single_branches.append(c2)
	# Update the sys_loop_map info
	for c4 in range(len(branch_info)):
	if sys_loop_map[c1][c4]=="yes" and sys_loop_map[c3][c4]=="yes":
	sys_loop_map[c3][c4]="no"
	elif sys_loop_map[c1][c4]=="yes" and sys_loop_map[c3][c4]=="no":
	sys_loop_map[c3][c4]="yes"
	# Now to set the loop currents equal to branch currents.
	# Take every loop and branch in the single_loop and single_branch lists
	# Since they are a one-to-one mapping, just equate the state vectors to
	# to the branch currents.
	for c1 in range(len(single_loops)):
	loop_row=single_loops[c1]
	for c2 in range(len(sys_loops[loop_row][loop_row])):
	if (sys_loops[loop_row][loop_row][c2][:-1]==branch_info[single_branches[c1]][:-1]):
	if sys_loops[loop_row][loop_row][c2][-1]=="forward":
	state_vector[0].data[single_loops[c1]][0]=branch_info[single_branches[c1]][-1][2]
	state_vector[1].data[single_loops[c1]][0]=branch_info[single_branches[c1]][-1][2]
	else:
	state_vector[0].data[single_loops[c1]][0]=-branch_info[single_branches[c1]][-1][2]
	state_vector[1].data[single_loops[c1]][0]=-branch_info[single_branches[c1]][-1][2]
	# This is to recalculate the sys_loops matrix.
	# First the diagonal loops are recalculated.
	# Then the off-diagonal (interactions)
	readjust_sys_loops(sys_loops, branch_info, stiff_info)
	# Re-initialize the matrices A, B, and E
	matrix_a.zeros(len(sys_loops),len(sys_loops))
	matrix_e.zeros(len(sys_loops),len(sys_loops))
	matrix_b.zeros(len(sys_loops),matrix_b.columns)
	# Recalculate the matrices A, B and E
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops)):
	for c3 in range(len(sys_loops[c1][c2])):
	for c4 in range(len(branch_info)):
	if sys_loops[c1][c2][c3][:-1]==branch_info[c4][:-1]:
	if c1==c2:
	matrix_a.data[c1][c2]+=branch_info[c4][-1][0][0]
	matrix_e.data[c1][c2]+=branch_info[c4][-1][0][1]
	if sys_loops[c1][c2][c3][-1]=="forward":
	for c5 in range(matrix_b.columns):
	matrix_b.data[c1][c5]+=branch_info[c4][-1][1][c5]
	else:
	for c5 in range(matrix_b.columns):
	matrix_b.data[c1][c5]-=branch_info[c4][-1][1][c5]
	else:
	if sys_loops[c1][c2][c3][-1]=="forward":
	matrix_a.data[c1][c2]+=branch_info[c4][-1][0][0]
	matrix_e.data[c1][c2]+=branch_info[c4][-1][0][1]
	else:
	matrix_a.data[c1][c2]-=branch_info[c4][-1][0][0]
	matrix_e.data[c1][c2]-=branch_info[c4][-1][0][1]
	# Make sure that the stiff loops have no inductances
	# so that they are treated as static equations.
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	for c3 in range(len(branch_info)):
	if sys_loops[c1][c1][c2][:-1]==branch_info[c3][:-1]:
	if stiff_info[c3]=="yes":
	for c4 in range(matrix_e.columns):
	matrix_e.data[c1][c4]=0.0
	return

view raw compute_loops.py hosted with ❤ by GitHub

This function looks to isolate branches to single loops and once that happens, the current of that branch becomes the loop current. If you are lucky, and in the case of the buck converter I was, the loops will be such that every non stiff loop will have a non stiff branch in that loop only and no other. Otherwise, a row operation is performed to isolate branches.

Anyway, long post but it is long overdue. The buck converter is now working. I am not sure if this will work in its present form for all power electronic converters. Need to test it thoroughly. But I'll release the next version soon.

Getting the diode to freewheel - II

To begin with, today marks the completion of one year of blogging on this project. The project has come pretty far though not as far as I had hoped.

The problem with the approach that I have been using is that it is based exclusively on loop analysis. This breaks almost every time with every modification to the logic I try to make for every variation of the circuit. Nothing universal seems to be coming out. I have been spending the entire week drawing circuits, writing loops, scratching them out and repeating over and over again.

So need to change my approach. How about I mix in some nodal analysis as well? The loop analysis gives me all the loop currents for any one iteration. The control changes the circuit. Now, to determine how the currents will be rearranged, nodal analysis seems to be the only solution.

I am thinking about it this way:

1. At the end of an iteration, mark which loops were non-stiff and therefore may have had inductors carrying a non-negligible current.

2. When an event occurs, we need to rearrange the circuit, the loops, the loop currents and also decide any freewheeling effects.

3. At this point, the one circuit law that should be obeyed is - the current through an inductor cannot change instantaneously. Using this as a starting point, apply nodal analysis to calculate the current through all the branches.

4. Based on the preliminary calculations, check if the branch currents result in any changes in circuit topology - diodes freewheeling or IGBTs conducting. This seems a bit complicated - will need to expand on this.

5. Now that circuit topology is updated, another nodal analysis will update the branch currents. Using these updated branch currents, the loop currents will need to be calculated for the next round of loop analysis.


Only worry is that these tasks seem computationally heavy. Even if they are executed only when events occur, every effort will need to be made to make them simpler.

Getting the diode to freewheel

The diode must freewheel when:

1. An inductor (for now, but in general an energy storage element) contains non-negligible current because a negligible current could simply mean it is in a loop that is stiff but finds itself only in stiff loops.

2. For this current to break would be either bad design which means undue voltage stress on devices as stored energy has nowhere to go or the current freewheels through a diode (or any other device such as an IGBT with an anti-parallel diode).

And this is essentially how the algorithm develops:

1. After one iteration is over, suppose the ideal switch in the buck converter turns off.

2. The next iteration will throw up an event. So new loop manipulations will be done, an effort will be made to remove stiffness, and this effort will fail because there are two parallel stiff branches.

3. The check to be done - is there any inductor in all the loops which has a non-negligible current but now finds itself only in stiff loops? Right now I will restrict the search to inductors but I will expand the criteria later if needed.

4. If so, check if it can freewheel through a device capable of freewheeling. Now this is the tough part.

5. Start with the loop that contains the inductor but has a non-negligible current. This is because the inductor could have been in multiple loops to begin with and some of them may have been stiff in the first place.

6. Check if any of the devices in the loop are capable of freewheeling. This will be done by running a function within all devices but will be empty for all devices that can't freewheel and will contain code for those than can freewheel. The function will check if the loop current and direction are such that the device will start conducting if the current were to flow through it. If so, the device state changes.

7. Now check again if loop containing the inductor is stiff. Why? Because there may be two diodes connected in series. So repeat the above procedure.

8. There could be another possibility. Suppose there are two diodes connected in series in the buck converter and they have high resistance snubbers connected in parallel with them. So now we won't know how the loops are formed. It could be that the inductor appears in a loop with the snubbers and not the diodes. The diodes appear in a loop with the snubbers. So the above algorithm will give up because the inductor loop never encounters a diode.

9. So if upon encountering a stiff branch, it so turns out that the stiff branch does not contain an element that can freewheel, check if that branch exists in other loops. If so, perform a loop manipulation and bring those other loops into the inductor loop. Now repeat the above process.

10. When will the algorithm give up? Not sure how this will work. I will have to run different cases and check. There may be times when it goes into an infinite loop.

Now I will code this. Not sure if I can finish it tonight. Probably will post again tomorrow.
 

Ideal switch

It is winter again and I am buried in snow in Toronto. I am not much into winter activities and this means only coding can stop me for going crazy. So I am back again to this project. After weeks of dithering, pretending to review code and thinking of future strategies, I finally gotten around to taking this project further.

Like I said before, the diode model is not complete because the diode doesn't know when and where to freewheel. To highlight this, I made the ideal switch model and tried to simulate a buck converter. Here's the code for the ideal switch (click on view raw below the code box to see the code in another window):

	class Switch:
	""" Ideal switch class. Contains functions to initiliaze
	the switch according to name tag, unique cell position,
	update system matrix on each iteration. """
	def __init__(self, switch_index, switch_pos, switch_tag):
	""" Constructor to initialize value.
	Also, takes in the identifiers -
	index (serial number), cell position and tag. """
	self.type="Switch"
	self.number=switch_index
	self.pos=switch_pos
	self.tag=switch_tag
	self.has_voltage="yes"
	self.switch_level=120.0
	self.current=0.0
	self.voltage=0.0
	self.polrty=[-1, -1]
	self.resistor_on=0.01
	self.status="off"
	self.control_tag=["Control"]
	self.control_values=[0.0]
	def display(self):
	print "Switch is ",
	print self.tag,
	print " located at ",
	print self.pos,
	print " with negative polarity towards %s" %(csv_element(self.polrty))
	return
	def ask_values(self, x_list, ckt_mat, sys_branch):
	""" Writes the values needed to the spreadsheet."""
	switch_params=["Switch"]
	switch_params.append(self.tag)
	switch_params.append(self.pos)
	switch_params.append("Voltage level (V) = %f" %self.switch_level)
	if self.polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.switch_elem=csv_tuple(self.pos)
	if self.switch_elem[0]>0:
	if ckt_mat[self.switch_elem[0]-1][self.switch_elem[1]]:
	self.polrty=[self.switch_elem[0]-1, self.switch_elem[1]]
	if self.switch_elem[1]>0:
	if ckt_mat[self.switch_elem[0]][self.switch_elem[1]-1]:
	self.polrty=[self.switch_elem[0], self.switch_elem[1]-1]
	if self.switch_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.switch_elem[0]+1][self.switch_elem[1]]:
	self.polrty=[self.switch_elem[0]+1, self.switch_elem[1]]
	if self.switch_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.switch_elem[0]][self.switch_elem[1]+1]:
	self.polrty=[self.switch_elem[0], self.switch_elem[1]+1]
	else:
	for c1 in range(len(sys_branch)):
	if csv_tuple(self.pos) in sys_branch[c1]:
	if not self.polrty in sys_branch[c1]:
	print
	print "!"*50
	print "ERROR!!! Switch polarity should be in the same branch as the switch. Check switch at %s" %self.pos
	print "!"*50
	print
	switch_params.append("Negative polarity towards (cell) = %s" %csv_element(self.polrty))
	switch_params.append("Name of control signal = %s" %self.control_tag[0])
	print switch_params
	x_list.append(switch_params)
	return
	def get_values(self, x_list, ckt_mat):
	""" Takes the parameter from the spreadsheet."""
	self.switch_level=float(x_list[0].split("=")[1])
	# Choosing 1 micro Amp as the leakage current that
	# is drawn by the switch in off state.
	self.resistor_off=self.switch_level/1.0e-6
	self.resistor=self.resistor_off
	switch_polrty=x_list[1].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while switch_polrty[0]==" ":
	switch_polrty=switch_polrty[1:]
	self.polrty=csv_tuple(switch_polrty)
	if not ckt_mat[self.polrty[0]][self.polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.polrty)
	self.control_tag[0]=x_list[2].split("=")[1]
	while self.control_tag[0][0]==" ":
	self.control_tag[0]=self.control_tag[0][1:]
	return
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix A in E.dx/dt=Ax+Bu will be updated by the
	resistor value of the switch."""
	for c1 in range(len(sys_loops)):
	for c2 in range(c1, len(sys_loops)):
	# Updating the elements depending
	# on the sense of the loops (aiding or opposing)
	for c3 in range(len(sys_loops[c1][c2])):
	# Check if current source position is there in the loop.
	if csv_tuple(self.pos) in sys_loops[c1][c2][c3]:
	# Add current source series resistor
	# if branch is in forward direction
	if sys_loops[c1][c2][c3][-1]=="forward":
	mat_a.data[c1][c2]+=self.resistor
	else:
	# Else subtract if branch is in reverse direction
	mat_a.data[c1][c2]-=self.resistor
	# Because the matrices are symmetric
	mat_a.data[c2][c1]=mat_a.data[c1][c2]
	# If the positive polarity appears before the voltage position
	# it means as per KVL, we are moving from +ve to -ve
	# and so the voltage will be taken negative
	if sys_loops[c1][c1][c2].index(self.polrty)>sys_loops[c1][c1][c2].index(csv_tuple(self.pos)):
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.pos)]=-1.0
	else:
	mat_b.data[c1][source_list.index(self.pos)]=1.0
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.pos)]=1.0
	else:
	mat_b.data[c1][source_list.index(self.pos)]=-1.0
	return
	def transfer_to_branch(self, sys_branch, source_list):
	""" Update the resistor info of the switch
	to the branch list """
	if csv_tuple(self.pos) in sys_branch:
	sys_branch[-1][0][0]+=self.resistor
	# For the switch forward voltage drop.
	if csv_tuple(self.pos) in sys_branch:
	if sys_branch.index(self.polrty)>sys_branch.index(csv_tuple(self.pos)):
	sys_branch[-1][1][source_list.index(self.pos)]=-1.0
	else:
	sys_branch[-1][1][source_list.index(self.pos)]=1.0
	return
	def generate_val(self, source_lst, sys_loops, mat_e, mat_a, mat_b, mat_u, t, dt):
	""" The switch forward drop voltage is updated
	in the matrix u in E.dx/dt=Ax+Bu ."""
	if self.status=="on":
	mat_u.data[source_lst.index(self.pos)][0]=0.7
	else:
	mat_u.data[source_lst.index(self.pos)][0]=0.0
	return
	def update_val(self, sys_loops, lbyr_ratio, mat_e, mat_a, mat_b, state_vec, mat_u, sys_branches, sys_events):
	""" This function calculates the actual current in the
	switch branch. With this, the branch voltage is found
	with respect to the existing switch resistance. The switch
	voltage is then used to decide the turn on condition. """
	# Local variable to calculate the branch
	# current from all loops that contain
	# the current source branch.
	act_current=0.0
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	if csv_tuple(self.pos) in sys_loops[c1][c1][c2]:
	# If switch negative polarity is after the switch
	# position, the current is positive.
	if sys_loops[c1][c1][c2].index(self.polrty)>sys_loops[c1][c1][c2].index(csv_tuple(self.pos)):
	# Then check is the loop is aiding or opposing
	# the main loop.
	if sys_loops[c1][c1][c2][-1]=="forward":
	act_current+=state_vec.data[c1][0]
	else:
	act_current-=state_vec.data[c1][0]
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	act_current-=state_vec.data[c1][0]
	else:
	act_current+=state_vec.data[c1][0]
	self.current=act_current
	self.voltage=self.current*self.resistor
	# Identifying the position of the switch branch
	# to generate events.
	for c1 in range(len(sys_branches)):
	if csv_tuple(self.pos) in sys_branches[c1]:
	branch_pos=c1
	# Switch will turn on when it is forward biased
	# and it is gated on.
	if self.control_values[0]>=1.0 and self.voltage>1.0:
	if self.status=="off":
	sys_events[branch_pos]="yes"
	self.status="on"
	# Switch will turn off when gated off or
	# when current becomes negative.
	if self.control_values[0]==0.0 or self.current<0.0:
	if self.status=="on":
	sys_events[branch_pos]="yes"
	self.status="off"
	if self.status=="off":
	self.resistor=self.resistor_off
	else:
	self.resistor=self.resistor_on
	return

view raw switch.py hosted with ❤ by GitHub

This is the circuit for the buck converter.

And this is the control code - actually just an open loop with a constant 50% duty ratio  (click on view raw below the code box to see the code in another window):

	import math
	carr_freq=5000.0
	if (x_tri>1.0):
	x_tri=1.0
	if (x_tri<0.0):
	x_tri=0.0
	dt_sample=10.0e-6
	try:
	str(switch_control)
	except:
	switch_control=0.0
	else:
	pass
	if t_clock>t1:
	x_tri+=(0.5*carr_freq)*dt_sample
	if (x_tri>1.0):
	x_tri=0.0
	if (x_tri<0.5):
	switch_control=1.0
	else:
	switch_control=0.0
	t1=t1+10.0e-6

view raw buck_control.py hosted with ❤ by GitHub

And on execution, the current (measured by Ammeter_La) through the inductor La is:

And as can be seen, the diode does not free wheel at all. The current rises when the switch turns on and drops to zero when it is turned off.

The strategy to overcome this will be my next blog entry as it is a fairly detailed algorithm.

Next step - getting back

Been a long time since my last post. Been a while so I will spend some maybe a week reviewing code before starting up again.

Some updates from outside the project. My aim is to build a hardware prototype of a microgrid and I have managed to finish building one inverter with LCL filter. Attached is the pic.

Happy to say that it works and I am able to do a current control in grid connected mode. I have revised the control PCBs and once that comes back after may be a week, I'll build the second and then the third inverter. The objective is to have an isolated microgrid and try out some control techniques on it.

I did give a lightening talk in Pycon 2013 held in Toronto. They put the talk on YouTube. Here's the link:
http://www.youtube.com/watch?v=WGliZOtQZmU
Yes, that's me :) It's just a 5 minute lightening talk so not much I could talk about other than tell people what I am trying to do. Met some other interesting people who were trying to something in the electronics field that showed interest so the conference was definitely productive.

Next step

Been a while since I updated this blog. I have been incredibly busy with my day job and so not much progress since the last update. I haven't given up on this project. I'll be back soon once my main project goes into autopilot.

The diode model is not complete yet. There is no special function for the diode to freewheel. So that would be the next step.

I will be giving a lightening talk (5 minutes only) in Pycon Canada to be held in Toronto next month. So if any of you are planning to attend, do send me an email.

Version 0.2.1 released

Released the next version of the simulator with diode model:
http://sourceforge.net/projects/pythonpowerelec/

As always, for questions or comments, please send me an email at pythonpowerelectronics@gmail.com

Diode model - loops and manipulations

For any circuit, the number of independent loops is Branches-Nodes+1. The loop finder function returns excess loops for all circuits except maybe the simplest circuits. Initially, I had removed the excess loops and assumed they were linear combinations of the previous loops. But when the circuit has a ladder structure, it may so happen that some of the essential loops appear right at the end and get thrown out.

This is what I found when I was trying to figure out why the three-phase diode bridge rectifier was not working. The only way to ensure that essential loops are not deleted is to let all of them be to begin with. With row operations, some loops will be eliminated. As and how loops are eliminated, they should be completely deleted and the system should be reduced.

So, first the loop finder function (click on "View Raw" below the code box to see the code in a new window):

	def find_loop(br_map, nd_list, lp_list, lp_iter, elem, lp_count, lp_limit):
	"""Find the loops from info on branches and
	nodes. The starting point is the first branch in br_map.
	The loops found need not be independent loops."""
	no_nodes=len(br_map)
	# First branch
	start_row=elem[0]
	start_col=elem[1]
	# Move right from that element
	# This is the first element
	# In a general sense, the direction is horiz
	loop_dir="horiz"
	# The termination condition is
	# that there should not be any element
	# in the nd_list. The nodes are deleted
	# as a completed loop contains them.
	# This is to ensure that all the nodes
	# are included in the loops found.
	# To ensure that parallel loops between
	# a few pair of nodes, do not cause
	# loops to be left out, additionally,
	# it is checked whether
	# Loops < Branches - Nodes + 1
	# while (nd_list or lp_count<lp_limit):
	while (lp_iter):
	# Will be executed if we are moving horizontally
	if (loop_dir == "horiz"):
	lp_count, lp_iter=loop_horiz(br_map, nd_list, lp_list, lp_iter, elem, lp_count)
	# Change direction to vertical
	loop_dir="vert"
	# Will be executed if we are moving vertically
	if (loop_dir == "vert"):
	lp_count, lp_iter=loop_vert(br_map, nd_list, lp_list, lp_iter, elem, lp_count)
	# Change direction to horizontal
	loop_dir="horiz"
	return lp_count

view raw loop_finder.py hosted with ❤ by GitHub

The difference is in the terminating condition:
if loop_iter:
As long as loop_iter is searching, let it search. So let it add as many valid loops as possible.
The number of excess loops can be pretty huge (x6).

Next comes the main circuit_solver.py. In this, another matrix has been conceived called the system_loop_map. This is to indicate which branches are stiff so as to eliminate stiff branches from as many loops as possible. The code for this has been put together in one block (click on "View Raw" below the code box to see the code in a new window):

	# Stiff ratio indicates whether a branch
	# is stiff.
	stiff_ratio=[]
	for c1 in range(len(branch_params)):
	stiff_ratio.append("no")
	max_res=abs(branch_params[0][-1][0][0])
	for c1 in range(1, len(branch_params)):
	if branch_params[c1][-1][0][0]>max_res:
	max_res=branch_params[c1][-1][0][0]
	# Calculates the time constants of the loops
	# from the diagonal elements as L/R ratios.
	for c1 in range(len(branch_params)):
	if branch_params[c1][-1][0][0]:
	if abs(branch_params[c1][-1][0][1]/branch_params[c1][-1][0][0])<0.1*dt:
	if branch_params[c1][-1][0][0]/max_res > dt:
	stiff_ratio[c1]="yes"
	system_loop_map=[]
	for c1 in range(len(system_loops_copy)):
	br_vector=[]
	for c2 in range(len(branch_params)):
	br_vector.append("no")
	system_loop_map.append(br_vector)
	for c1 in range(len(system_loops_copy)):
	for c3 in range(len(branch_params)):
	for c2 in range(len(system_loops_copy[c1][c1])):
	if branch_params[c3][:-1]==system_loops_copy[c1][c1][c2][:-1]:
	if stiff_ratio[c3]=="yes":
	system_loop_map[c1][c3]="stiff"
	else:
	system_loop_map[c1][c3]="yes"

view raw system_loop_map.py hosted with ❤ by GitHub

So essentially, for every loop there is minimal information about every branch in the circuit - if it exists and if it does, is the branch stiff.

	# The concept here is to minimize the number of times
	# a stiff branch appears in loops. To do so a sys_loop_map
	# has been constructed. This has three options "stiff", "yes"
	# and "no". Using row operations, this sys_loop_map is made
	# into a upper triangular matrix only with respect to the
	# stiff branches.
	for c1 in range(len(sys_loop_map)):
	# Check if loop c1 has a stiff branch
	is_loop_stiff="no"
	for c2 in range(len(branch_info)):
	if sys_loop_map[c1][2]=="stiff":
	is_loop_stiff="yes"
	# Check if there is another loop after c1 (>c1)
	# which has a stiff branch "sooner" than c1 has.
	# All this is mere nomenclature.
	# If so, exchange the loops for the triangularization.
	if is_loop_stiff=="yes":
	c2=0
	while c2<len(branch_info) and sys_loop_map[c1][c2]!="stiff":
	for c3 in range(c1+1, len(sys_loop_map)):
	if sys_loop_map[c3][c2]=="stiff":
	c2=len(branch_info)-1
	for c4 in range(len(branch_info)):
	sys_loop_map[c1][c4], sys_loop_map[c3][c4] = sys_loop_map[c3][c4], sys_loop_map[c1][c4]
	sys_loops[c1][c1], sys_loops[c3][c3] = sys_loops[c3][c3], sys_loops[c1][c1]
	c2=c2+1
	# Look for the first stiff branch
	c2=0
	while c2<len(branch_info) and sys_loop_map[c1][c2]!="stiff":
	c2=c2+1
	if c2<len(branch_info):
	# Eliminate that stiff branch from subsequent loops.
	for c3 in range(c1+1, len(sys_loop_map)):
	if sys_loop_map[c3][c2]=="stiff":
	# Loop manipulations may cause loops
	# to change lenghts rapidly. So the try/except
	# statmements are used to avoid exceeding indices.
	c4=len(sys_loops[c1][c1])-1
	while c4>=0:
	try:
	sys_loops[c1][c1][c4]
	except:
	pass
	else:
	c5=len(sys_loops[c3][c3])-1
	while c5>=0:
	try:
	sys_loops[c3][c3][c5]
	except:
	pass
	else:
	if sys_loops[c1][c1][c4][:-1]==sys_loops[c3][c3][c5][:-1]:
	if branch_info[c2][:-1]==sys_loops[c1][c1][c4][:-1]:
	if sys_loops[c1][c1][c4][-1]==sys_loops[c3][c3][c5][-1]:
	loop_manipulate(sys_loops, c3, c1, "diff")
	else:
	loop_manipulate(sys_loops, c3, c1, "add")
	c5=c5-1
	c4=c4-1
	# Update the sys_loop_map info
	for c4 in range(len(branch_info)):
	if sys_loop_map[c1][c4]=="yes" and sys_loop_map[c3][c4]=="yes":
	sys_loop_map[c3][c4]="no"
	elif sys_loop_map[c1][c4]=="yes" and sys_loop_map[c3][c4]=="no":
	sys_loop_map[c3][c4]="yes"
	elif sys_loop_map[c1][c4]=="stiff" and sys_loop_map[c3][c4]=="stiff":
	sys_loop_map[c3][c4]="no"
	elif sys_loop_map[c1][c4]=="stiff" and sys_loop_map[c3][c4]=="no":
	sys_loop_map[c3][c4]="stiff"
	# This is to make sure, that stiff loops
	# are connected to an input.
	for c1 in range(len(sys_loops)):
	is_loop_stiff="no"
	has_input="no"
	for c2 in range(len(sys_loops[c1][c1])):
	# Check if any of the branches are stiff
	for c3 in range(len(branch_info)):
	if branch_info[c3][:-1]==sys_loops[c1][c1][c2][:-1]:
	if stiff_info[c3]=="yes":
	is_loop_stiff="yes"
	# Check if any branch has a non-zero B matrix entry.
	for c4 in range(len(branch_info[c3][-1][1])):
	if branch_info[c3][-1][1][c4]:
	has_input="yes"
	# If loop is stiff and has no input
	if is_loop_stiff=="yes" and has_input=="no":
	c2=0
	flag_input="no"
	# Check all other loops whether they are stiff
	# and whether they have inputs.
	while flag_input=="no" and c2<len(sys_loops):
	if not c1==c2:
	is_loop_stiff="no"
	flag_input="no"
	for c3 in range(len(sys_loops[c2][c2])):
	for c4 in range(len(branch_info)):
	if branch_info[c4][:-1]==sys_loops[c2][c2][c3][:-1]:
	if stiff_info[c4]=="yes":
	is_loop_stiff="yes"
	if is_loop_stiff=="no":
	for c5 in range(len(branch_info[c4][-1][1])):
	if branch_info[c4][-1][1][c5]:
	flag_input="yes"
	c2=c2+1
	# Perform a row operation with a loop that is non-stiff
	# and has an input.
	if is_loop_stiff=="no" and flag_input=="yes":
	c2=c2-1
	loop_manipulate(sys_loops, c1, c2, "add")

view raw stiffness_removal.py hosted with ❤ by GitHub

So essentially, I use system_loops_map to make the system upper triangular as far as stiff branches are concerned. The next block I am not sure if it is needed. Whether it is necessary to make sure a stiff loop is connected to the input. I'll test it and try to get rid of it. For some reason, it looks like an ugly code block.

The last part of to reduce the size of the system by getting rid of redundant loops (click on "View Raw" below the code box to see the code in a new window):

	# This is to recalculate the sys_loops matrix.
	# First the diagonal loops are recalculated.
	# Then the off-diagonal (interactions)
	readjust_sys_loops(sys_loops, branch_info, stiff_info)
	# Re-initialize the matrices A, B, and E
	matrix_a.zeros(len(sys_loops),len(sys_loops))
	matrix_e.zeros(len(sys_loops),len(sys_loops))
	matrix_b.zeros(len(sys_loops),matrix_b.columns)
	# Recalculate the matrices A, B and E
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops)):
	for c3 in range(len(sys_loops[c1][c2])):
	for c4 in range(len(branch_info)):
	if sys_loops[c1][c2][c3][:-1]==branch_info[c4][:-1]:
	if c1==c2:
	matrix_a.data[c1][c2]+=branch_info[c4][-1][0][0]
	matrix_e.data[c1][c2]+=branch_info[c4][-1][0][1]
	if sys_loops[c1][c2][c3][-1]=="forward":
	for c5 in range(matrix_b.columns):
	matrix_b.data[c1][c5]+=branch_info[c4][-1][1][c5]
	else:
	for c5 in range(matrix_b.columns):
	matrix_b.data[c1][c5]-=branch_info[c4][-1][1][c5]
	else:
	if sys_loops[c1][c2][c3][-1]=="forward":
	matrix_a.data[c1][c2]+=branch_info[c4][-1][0][0]
	matrix_e.data[c1][c2]+=branch_info[c4][-1][0][1]
	else:
	matrix_a.data[c1][c2]-=branch_info[c4][-1][0][0]
	matrix_e.data[c1][c2]-=branch_info[c4][-1][0][1]
	# This part if to eliminate the empty (redundant) loops
	# based on zero rows in A, E and B matrices.
	# At the same time, A, B and E matrices are resized.
	for c1 in range(len(sys_loops)-1, -1, -1):
	empty_loop="yes"
	for c2 in range(matrix_a.columns):
	if matrix_a.data[c1][c2]:
	empty_loop="no"
	for c2 in range(matrix_e.columns):
	if matrix_e.data[c1][c2]:
	empty_loop="no"
	for c2 in range(matrix_b.columns):
	if matrix_b.data[c1][c2]:
	empty_loop="no"
	if empty_loop=="yes":
	# If a loop is empty, the column c1 is first deleted
	# and then the row c1 is deleted.
	for c2 in range(len(sys_loops)-1, -1, -1):
	for c3 in range(len(sys_loops[c2][c1])-1, -1, -1):
	del sys_loops[c2][c1][c3]
	del sys_loops[c2][c1]
	for c2 in range(len(sys_loops[c1])-1, -1, -1):
	del sys_loops[c1][c2]
	del sys_loops[c1]
	# Same for the matrices A and E
	for c2 in range(matrix_a.rows-1, -1, -1):
	del matrix_a.data[c2][c1]
	del matrix_e.data[c2][c1]
	matrix_a.columns-=1
	matrix_e.columns-=1
	for c2 in range(matrix_a.columns-1, -1, -1):
	del matrix_a.data[c1][c2]
	del matrix_e.data[c1][c2]
	del matrix_a.data[c1]
	del matrix_e.data[c1]
	matrix_a.rows-=1
	matrix_e.rows-=1
	for c2 in range(matrix_b.columns-1, -1, -1):
	del matrix_b.data[c1][c2]
	del matrix_b.data[c1]
	matrix_b.rows-=1
	# Make sure that the stiff loops have no inductances
	# so that they are treated as static equations.
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	for c3 in range(len(branch_info)):
	if sys_loops[c1][c1][c2][:-1]==branch_info[c3][:-1]:
	if stiff_info[c3]=="yes":
	for c4 in range(matrix_e.columns):
	matrix_e.data[c1][c4]=0.0

view raw sys_red.py hosted with ❤ by GitHub

Diode model - part I

Where do I begin? Massive number of changes. So first, the diode class (clink on "View Raw" below the code box to see the code in a new window):

	class Diode:
	""" Diode class. Contains functions to initiliaze
	the diode according to name tag, unique cell position,
	update system matrix on each iteration. """
	def __init__(self, diode_index, diode_pos, diode_tag):
	""" Constructor to initialize value.
	Also, takes in the identifiers -
	index (serial number), cell position and tag. """
	self.type="Diode"
	self.number=diode_index
	self.pos=diode_pos
	self.tag=diode_tag
	self.has_voltage="yes"
	self.diode_level=120.0
	self.current=0.0
	self.voltage=0.0
	self.polrty=[-1, -1]
	self.resistor_on=0.01
	self.status="off"
	def display(self):
	print "Diode is ",
	print self.tag,
	print " located at ",
	print self.pos,
	print " with cathode polarity towards %s" %(csv_element(self.polrty))
	return
	def ask_values(self, x_list, ckt_mat, sys_branch):
	""" Writes the values needed to the spreadsheet."""
	diode_params=["Diode"]
	diode_params.append(self.tag)
	diode_params.append(self.pos)
	diode_params.append("Voltage level (V) = %f" %self.diode_level)
	if self.polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.diode_elem=csv_tuple(self.pos)
	if self.diode_elem[0]>0:
	if ckt_mat[self.diode_elem[0]-1][self.diode_elem[1]]:
	self.polrty=[self.diode_elem[0]-1, self.diode_elem[1]]
	if self.diode_elem[1]>0:
	if ckt_mat[self.diode_elem[0]][self.diode_elem[1]-1]:
	self.polrty=[self.diode_elem[0], self.diode_elem[1]-1]
	if self.diode_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.diode_elem[0]+1][self.diode_elem[1]]:
	self.polrty=[self.diode_elem[0]+1, self.diode_elem[1]]
	if self.diode_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.diode_elem[0]][self.diode_elem[1]+1]:
	self.polrty=[self.diode_elem[0], self.diode_elem[1]+1]
	else:
	for c1 in range(len(sys_branch)):
	if csv_tuple(self.pos) in sys_branch[c1]:
	if not self.polrty in sys_branch[c1]:
	print
	print "!"*50
	print "ERROR!!! Diode polarity should be in the same branch as the diode. Check diode at %s" %self.pos
	print "!"*50
	print
	diode_params.append("Cathode polarity towards (cell) = %s" %csv_element(self.polrty))
	x_list.append(diode_params)
	return
	def get_values(self, x_list, ckt_mat):
	""" Takes the parameter from the spreadsheet."""
	self.diode_level=float(x_list[0].split("=")[1])
	# Choosing 1 micro Amp as the leakage current that
	# is drawn by the diode in off state.
	self.resistor_off=self.diode_level/1.0e-6
	self.resistor=self.resistor_off
	diode_polrty=x_list[1].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while diode_polrty[0]==" ":
	diode_polrty=diode_polrty[1:]
	self.polrty=csv_tuple(diode_polrty)
	if not ckt_mat[self.polrty[0]][self.polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.polrty)
	return
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix A in E.dx/dt=Ax+Bu will be updated by the
	resistor value of the diode."""
	for c1 in range(len(sys_loops)):
	for c2 in range(c1, len(sys_loops)):
	# Updating the elements depending
	# on the sense of the loops (aiding or opposing)
	for c3 in range(len(sys_loops[c1][c2])):
	# Check if current source position is there in the loop.
	if csv_tuple(self.pos) in sys_loops[c1][c2][c3]:
	# Add current source series resistor
	# if branch is in forward direction
	if sys_loops[c1][c2][c3][-1]=="forward":
	mat_a.data[c1][c2]+=self.resistor
	else:
	# Else subtract if branch is in reverse direction
	mat_a.data[c1][c2]-=self.resistor
	# Because the matrices are symmetric
	mat_a.data[c2][c1]=mat_a.data[c1][c2]
	# If the positive polarity appears before the voltage position
	# it means as per KVL, we are moving from +ve to -ve
	# and so the voltage will be taken negative
	if sys_loops[c1][c1][c2].index(self.polrty)>sys_loops[c1][c1][c2].index(csv_tuple(self.pos)):
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.pos)]=-1.0
	else:
	mat_b.data[c1][source_list.index(self.pos)]=1.0
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.pos)]=1.0
	else:
	mat_b.data[c1][source_list.index(self.pos)]=-1.0
	return
	def transfer_to_branch(self, sys_branch, source_list):
	""" Update the resistor info of the diode
	to the branch list """
	if csv_tuple(self.pos) in sys_branch:
	sys_branch[-1][0][0]+=self.resistor
	if csv_tuple(self.pos) in sys_branch:
	if sys_branch.index(self.polrty)>sys_branch.index(csv_tuple(self.pos)):
	sys_branch[-1][1][source_list.index(self.pos)]=-1.0
	else:
	sys_branch[-1][1][source_list.index(self.pos)]=1.0
	return
	def generate_val(self, source_lst, sys_loops, mat_e, mat_a, mat_b, mat_u, t, dt):
	""" The diode forward drop voltage is updated
	in the matrix u in E.dx/dt=Ax+Bu ."""
	if self.status=="on":
	mat_u.data[source_lst.index(self.pos)][0]=0.7
	else:
	mat_u.data[source_lst.index(self.pos)][0]=0.0
	return
	def update_val(self, sys_loops, lbyr_ratio, mat_e, mat_a, mat_b, state_vec, mat_u, sys_branches, sys_events):
	""" This function calculates the actual current in the
	diode branch. With this, the branch voltage is found
	with respect to the existing diode resistance. The diode
	voltage is then used to decide the turn on condition. """
	# Local variable to calculate the branch
	# current from all loops that contain
	# the current source branch.
	act_current=0.0
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	if csv_tuple(self.pos) in sys_loops[c1][c1][c2]:
	# If diode cathode polarity is after the diode
	# position, the current is positive.
	if sys_loops[c1][c1][c2].index(self.polrty)>sys_loops[c1][c1][c2].index(csv_tuple(self.pos)):
	# Then check is the loop is aiding or opposing
	# the main loop.
	if sys_loops[c1][c1][c2][-1]=="forward":
	act_current+=state_vec.data[c1][0]
	else:
	act_current-=state_vec.data[c1][0]
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	act_current-=state_vec.data[c1][0]
	else:
	act_current+=state_vec.data[c1][0]
	self.current=act_current
	self.voltage=self.current*self.resistor
	for c1 in range(len(sys_branches)):
	if csv_tuple(self.pos) in sys_branches[c1]:
	branch_pos=c1
	if self.status=="off" and self.voltage>0.9:
	sys_events[branch_pos]="yes"
	self.status="on"
	if self.status=="on" and self.current<-1.0e-5:
	sys_events[branch_pos]="yes"
	self.status="off"
	if self.current<-1.0e-5:
	self.status="off"
	if self.status=="off":
	self.resistor=self.resistor_off
	else:
	self.resistor=self.resistor_on
	return

view raw diode_class.py hosted with ❤ by GitHub

Similar to many of the others. In the parameter specification, the user needs to enter the voltage level of the diode and the polarity in terms of where the cathode is.

The diode resistance changes with the status whether "ON" or "OFF". The diode is ON when it is forward biased beyond a certain threshold voltage. It turns "OFF" when current becomes negative. The ON resistance, forward bias threshold voltage and the ON drop voltage can be made user defined parameters.

Testing the circuit solver

Now that a basic control interface is ready, I can begin with the power electronics library. Main focus would be on the diode and IGBT (or simply an ideal switch). With these, the intent would be to start rigorously testing the circuit solver. Something which I put off before because I wanted to get to the power electronics library ASAP.

A basic problem has arisen particularly in the solving of stiff equations. A single phase diode bridge rectifier threw this error up. It it in the way the loops are rewritten whenever a diode turns on and off.

Found out the problem this afternoon and will figure it out tomorrow.

Version 0.2.0 released

Releasing version 0.2.0 with controlled voltage source as library element.
http://sourceforge.net/projects/pythonpowerelec/

Just realized while moving version 0.1.5 to the archives that the zip archive was empty. Added another zip file in the archives. In case of doubts, email to pythonpowerelectronics@gmail.com.

Controlled Voltage Source

Think I got a basic code working for a controlled voltage source. To begin with here is the code for the class (click on "view raw" below the code box to see the code in a new window):

	class Controlled_Voltage_Source:
	""" Controlled Voltage Source class. Takes the instantaneous
	voltage as input from the user file. """
	def __init__(self, volt_index, volt_pos, volt_tag):
	""" Constructor to initialize value.
	Also, takes in the identifiers -
	index (serial number), cell position and tag. """
	self.type="ControlledVoltageSource"
	self.volt_number=volt_index
	self.volt_pos=volt_pos
	self.pos=volt_pos
	self.volt_tag=volt_tag
	self.tag=volt_tag
	self.voltage=0.0
	self.current=0.0
	self.op_value=0.0
	self.v_polrty=[-1, -1]
	self.control_tag=["Control"]
	self.control_values=[0.0]
	def display(self):
	""" Displays info about the component."""
	print "Controlled Voltage Source is ",
	print self.volt_tag,
	print " located at ",
	print self.volt_pos,
	print " with positive polarity towards %s" %(csv_element(self.v_polrty))
	def ask_values(self, x_list, ckt_mat, sys_branch):
	""" Writes the values needed to the spreadsheet."""
	volt_params=["ControlledVoltageSource"]
	volt_params.append(self.volt_tag)
	volt_params.append(self.volt_pos)
	if self.v_polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.volt_elem=csv_tuple(self.volt_pos)
	if self.volt_elem[0]>0:
	if ckt_mat[self.volt_elem[0]-1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]-1, self.volt_elem[1]]
	if self.volt_elem[1]>0:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]-1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]-1]
	if self.volt_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]+1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]+1, self.volt_elem[1]]
	if self.volt_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]+1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]+1]
	else:
	for c1 in range(len(sys_branch)):
	if csv_tuple(self.volt_pos) in sys_branch[c1]:
	if not self.v_polrty in sys_branch[c1]:
	print
	print "!"*50
	print "ERROR!!! Voltage source polarity should be in the same branch as the voltage source. Check source at %s" %self.volt_pos
	print "!"*50
	print
	volt_params.append("Positive polarity towards (cell) = %s" %csv_element(self.v_polrty))
	volt_params.append("Name of control signal = %s" %self.control_tag[0])
	x_list.append(volt_params)
	def get_values(self, x_list, ckt_mat):
	""" Takes the parameter from the spreadsheet."""
	volt_polrty=x_list[0].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while volt_polrty[0]==" ":
	volt_polrty=volt_polrty[1:]
	self.v_polrty=csv_tuple(volt_polrty)
	if not ckt_mat[self.v_polrty[0]][self.v_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.v_polrty)
	self.control_tag[0]=x_list[1].split("=")[1]
	while self.control_tag[0][0]==" ":
	self.control_tag[0]=self.control_tag[0][1:]
	return
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix B in E.dx/dt=Ax+Bu will be updated by the
	polarity of the voltage source."""
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	if csv_tuple(self.volt_pos) in sys_loops[c1][c1][c2]:
	# If the positive polarity appears before the voltage position
	# it means as per KVL, we are moving from +ve to -ve
	# and so the voltage will be taken negative
	if sys_loops[c1][c1][c2].index(self.v_polrty)<sys_loops[c1][c1][c2].index(csv_tuple(self.volt_pos)):
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.volt_pos)]=-1.0
	else:
	mat_b.data[c1][source_list.index(self.volt_pos)]=1.0
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.volt_pos)]=1.0
	else:
	mat_b.data[c1][source_list.index(self.volt_pos)]=-1.0
	return
	def transfer_to_branch(self, sys_branch, source_list):
	""" Transfers parameters to system branch if voltage
	source exists in the branch. """
	if csv_tuple(self.volt_pos) in sys_branch:
	if sys_branch.index(self.v_polrty)<sys_branch.index(csv_tuple(self.volt_pos)):
	sys_branch[-1][1][source_list.index(self.volt_pos)]=-1.0
	else:
	sys_branch[-1][1][source_list.index(self.volt_pos)]=1.0
	def generate_val(self, source_lst, sys_loops, mat_e, mat_a, mat_b, mat_u, t, dt):
	""" The source voltage is updated in the matrix u in
	E.dx/dt=Ax+Bu ."""
	mat_u.data[source_lst.index(self.volt_pos)][0]=self.control_values[0]
	self.op_value=self.control_values[0]
	def update_val(self, sys_loops, lbyr_ratio, mat_e, mat_a, mat_b, state_vec, mat_u):
	pass

view raw cont_vot_source.py hosted with ❤ by GitHub

The only difference between a normal voltage source is that it has two lists control_tag and control_values. The control tag is the name of the control input and the corresponding index in the other list is its value. These are lists because there can be multiple control inputs to any controllable device.

Next in the main program "circuit_solver.py". The first stage is to get the names of the control codes from the user. Then generate "descriptor" files for each of these control codes. Check if they exist. If they don't create blank templates (check the previous blog entry). This is the code (click on "view raw" below the code box to see it in a new window):

	# This is the main control program
	# It will contain the individual control
	# codes as functions.
	complete_control=open("__control.py","w")
	# Check if there exists a controlled element
	if controlled_elements:
	user_input=raw_input("Enter the control files. Omit the .py extension and just leave spaces between files --> ")
	control_files=user_input.split()
	control_descs=[]
	for c1 in range(len(control_files)):
	control_descs.append(control_files[c1]+"_desc.csv")
	control_functions=[]
	for c1 in range(len(control_files)):
	control_functions.append(control_files[c1]+"_func")
	for c1 in range(len(control_files)):
	control_files[c1]=control_files[c1]+".py"
	# These lists will contain separate dictionaries
	# for every control file.
	control_file_inputs=[]
	control_file_outputs=[]
	control_file_staticvars=[]
	control_file_timeevents=[]
	control_desc_handles=[]
	for c1 in range(len(control_files)):
	# Adding an empty dictionary for a control file.
	control_file_inputs.append({})
	control_file_outputs.append({})
	control_file_staticvars.append({})
	control_file_timeevents.append({})
	# Check if the descriptor exists.
	try:
	control_desc_handles.append(open(control_descs[c1],"r"))
	except:
	# If it doesn't create a blank template.
	control_desc_handles.append(open(control_descs[c1],"w"))
	# Input template
	control_desc_handles[c1].write("Input")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	# Output template. Create a line for every
	# control input a particular controlled
	# element has.
	for c2 in range(len(component_objects[controlled_elements[0]].control_tag)):
	control_desc_handles[c1].write("Output")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[controlled_elements[0]].type+"_"+component_objects[controlled_elements[0]].tag))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Control tag defined in parameters spreadhseet = %s" %(component_objects[controlled_elements[0]].control_tag[c2]))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[controlled_elements[0]].control_tag[c2]))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	# Static variable template
	control_desc_handles[c1].write("StaticVariable")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = Var1")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Initial value of variable = 0.0")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	# Time event template
	control_desc_handles[c1].write("TimeEvent")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = t1")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("First time event = 0.0")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	control_desc_handles[c1].close()

view raw cont_interface1.py hosted with ❤ by GitHub

The next step is to take in the descriptor parameters. These will be used to update the dictionaries for the inputs, outputs, staticvariables and time events. Here is the code (click on "view raw" below the code box to see it in a new window):

	# Wait for the user to enter parameters before
	# reading the *_desc.csv file.
	cont_ans="n"
	while cont_ans.lower()!="y":
	print "Enter control parameters in the following files --> "
	for c1 in range(len(control_descs)):
	print "%s " %control_descs[c1]
	cont_ans=raw_input("When ready press y and enter to continue -> ")
	# Read the parameters from the descriptor spreadsheet.
	control_desc_handles=[]
	for c1 in range(len(control_files)):
	control_desc_handles.append(open(control_descs[c1],"r"))
	params_from_file=reading_params(control_desc_handles[c1])
	for c2 in range(len(params_from_file)):
	# Scrubbing blank spaces from the beginning
	# and the end of the first cell.
	while params_from_file[c2][0][0]==" ":
	params_from_file[c2][0]=params_from_file[c2][0][1:]
	while params_from_file[c2][0][-1]==" ":
	params_from_file[c2][0]=params_from_file[c2][0][:-1]
	if params_from_file[c2][0].lower()=="input":
	# If it is an input, it will be a meter.
	meter_type=params_from_file[c2][1].split("=")[1]
	while meter_type[0]==" ":
	meter_type=meter_type[1:]
	while meter_type[-1]==" ":
	meter_type=meter_type[:-1]
	# Look for the meter in components_found
	# and get the cell position from the meter tag.
	# The cell position which is unique will be the
	# dictionary key for control_file_inputs.
	for c3 in range(len(components_found[meter_type.split("_")[0].lower()])):
	if components_found[meter_type.split("_")[0].lower()][c3][1]==meter_type.split("_")[1]:
	meter_type_ref=meter_type.split("_")[0].lower()
	control_file_inputs[c1][components_found[meter_type_ref][c3][0]]=[components_found[meter_type_ref][c3][1]]
	var_name=params_from_file[c2][2].split("=")[1]
	while var_name[0]==" ":
	var_name=var_name[1:]
	while var_name[-1]==" ":
	var_name=var_name[:-1]
	control_file_inputs[c1][components_found[meter_type_ref][c3][0]].append(var_name)
	if params_from_file[c2][0].lower()=="output":
	# If it is an output, it is a controlled element
	element_type=params_from_file[c2][1].split("=")[1]
	while element_type[0]==" ":
	element_type=element_type[1:]
	while element_type[-1]==" ":
	element_type=element_type[:-1]
	# Look for the controlled element in components_found
	# and get the cell position from the device tag.
	# The cell position will be the unique dictionary key
	for c3 in range(len(components_found[element_type.split("_")[0].lower()])):
	if components_found[element_type.split("_")[0].lower()][c3][1]==element_type.split("_")[1]:
	element_type_ref=element_type.split("_")[0].lower()
	# Since a controlled element can have more than one control input
	# Check if it has been found before.
	if not components_found[element_type_ref][c3][0] in control_file_outputs[c1].keys():
	control_file_outputs[c1][components_found[element_type_ref][c3][0]]=[components_found[element_type_ref][c3][1]]
	control_tag_name=params_from_file[c2][2].split("=")[1]
	control_var_name=params_from_file[c2][3].split("=")[1]
	while control_tag_name[0]==" ":
	control_tag_name=control_tag_name[1:]
	while control_tag_name[-1]==" ":
	control_tag_name=control_tag_name[:-1]
	while control_var_name[0]==" ":
	control_var_name=control_var_name[1:]
	while control_var_name[-1]==" ":
	control_var_name=control_var_name[:-1]
	control_file_outputs[c1][components_found[element_type_ref][c3][0]].append([control_tag_name, control_var_name, 0.0])
	if params_from_file[c2][0].lower()=="staticvariable":
	# If it is a staticvariable, the dictionary key
	# will be the variable name.
	staticvar_type=params_from_file[c2][1].split("=")[1]
	while staticvar_type[0]==" ":
	staticvar_type=staticvar_type[1:]
	while staticvar_type[-1]==" ":
	staticvar_type=staticvar_type[:-1]
	staticvar_val=params_from_file[c2][2].split("=")[1]
	while staticvar_val[0]==" ":
	staticvar_val=staticvar_val[1:]
	while staticvar_val[-1]==" ":
	staticvar_val=staticvar_val[:-1]
	control_file_staticvars[c1][staticvar_type]=float(staticvar_val)
	if params_from_file[c2][0].lower()=="timeevent":
	# If it is a timeevent, the dictionary key
	# will be the variable name.
	timeevent_type=params_from_file[c2][1].split("=")[1]
	while timeevent_type[0]==" ":
	timeevent_type=timeevent_type[1:]
	while timeevent_type[-1]==" ":
	timeevent_type=timeevent_type[:-1]
	timeevent_val=params_from_file[c2][2].split("=")[1]
	while timeevent_val[0]==" ":
	timeevent_val=timeevent_val[1:]
	while timeevent_val[-1]==" ":
	timeevent_val=timeevent_val[:-1]
	control_file_timeevents[c1][timeevent_type]=float(timeevent_val)
	control_desc_handles[c1].close()

view raw cont_interface2.py hosted with ❤ by GitHub

The next step was a bit tricky. The idea is to write all these different control codes into one main program called __control.py and import this file. Each control code will be written as a function.

So basically, define the function, assign the input to variables, assign the static variables to local variables, assign the time events to local variables. And then finally embed the control code. Then assign the local variables to outputs, reassign local variables to static variables and time events as applicable to take these back to the main program.

Here is the code (click on "view raw" below the code box to see it in a new window):

	# Wait for use to update the control code.
	cont_ans="n"
	while cont_ans.lower()!="y":
	print "Enter control code in the following files --> "
	for c1 in range(len(control_files)):
	print "%s " %control_files[c1]
	cont_ans=raw_input("When ready press y and enter to continue -> ")
	# This list will contain the control
	# code as lists of strings.
	control_code=[]
	for c1 in range(len(control_files)):
	control_code.append([])
	control_handles=[]
	for c1 in range(len(control_files)):
	control_handles.append(open(control_files[c1],"r"))
	# Add the lines in the control codes
	# to the lists.
	for line in control_handles[c1]:
	control_code[c1].append(line)
	control_handles[c1].close()
	# Check for any import statements.
	# If any of the control codes have import statements
	# add them to the main control program.
	for c1 in range(len(control_code)):
	for c2 in range(len(control_code[c1])):
	if "import" in control_code[c1][c2].split():
	complete_control.write(control_code[c1][c2])
	complete_control.write("\n")
	for c1 in range(len(control_code)):
	# For each control code, define a function
	# Name of function has been defined in
	# control_functions.
	complete_control.write("def %s(interface_inputs, interface_outputs, interface_static, interface_time, circuit_components, pos, t_clock):" %control_functions[c1])
	complete_control.write("\n")
	# The remaining statements have a tab \t for indentation
	# Assign the input variables to the meter outputs
	for ip_keys in control_file_inputs[c1].keys():
	complete_control.write("\t")
	complete_control.write("%s=circuit_components['%s'].op_value" %(control_file_inputs[c1][ip_keys][1], ip_keys))
	complete_control.write("\n")
	# Assign the static variables to their latest values
	for static_keys in control_file_staticvars[c1].keys():
	complete_control.write("\t")
	complete_control.write("%s=interface_static[pos]['%s']" %(static_keys, static_keys))
	complete_control.write("\n")
	# Assign the time events variables to their latest values
	for time_keys in control_file_timeevents[c1].keys():
	complete_control.write("\t")
	complete_control.write("%s=interface_time[pos]['%s']" %(time_keys, time_keys))
	complete_control.write("\n")
	# Include the control code.
	for c2 in range(len(control_code[c1])):
	complete_control.write("\t")
	complete_control.write(control_code[c1][c2])
	# Assign the output controlled elements to the
	# variables. Additionally, check each control element
	# for multiple control inputs.
	for op_keys in control_file_outputs[c1].keys():
	for c3 in range(1, len(control_file_outputs[c1][op_keys])):
	control_pos=component_objects[op_keys].control_tag.index(control_file_outputs[c1][op_keys][c3][0])
	complete_control.write("\t")
	# Update the object control values
	complete_control.write("circuit_components['%s'].control_values[%d]=%s" %(op_keys, control_pos, control_file_outputs[c1][op_keys][c3][1]))
	complete_control.write("\n")
	complete_control.write("\t")
	# Update the dictionary values
	complete_control.write("interface_outputs[pos]['%s'][%d][2]=%s" %(op_keys, c3, control_file_outputs[c1][op_keys][c3][1]))
	complete_control.write("\n")
	# Store the static variables in the dictionary
	for static_keys in control_file_staticvars[c1].keys():
	complete_control.write("\t")
	complete_control.write("interface_static[pos]['%s']=%s" %(static_keys, static_keys))
	complete_control.write("\n")
	# Store the time events in the dictionary
	for time_keys in control_file_timeevents[c1].keys():
	complete_control.write("\t")
	complete_control.write("interface_time[pos]['%s']=%s" %(time_keys, time_keys))
	complete_control.write("\n")
	# end the function
	complete_control.write("\t")
	complete_control.write("return")
	complete_control.write("\n")
	complete_control.write("\n")
	complete_control.close()
	# Import the main control program
	from __control import *

view raw cont_interface3.py hosted with ❤ by GitHub

Anyway, a basic circuit with a controlled voltage source works. So I'll just release this as the next minor version.

Control interface - code

Here's the code for just the basic design of the control interface (click on "view raw" to view it in another window):

	# Check if there exists a controlled element
	if controlled_elements:
	user_input=raw_input("Enter the control files. Omit the .py extension and just leave spaces between files --> ")
	control_files=user_input.split()
	control_descs=[]
	for c1 in range(len(control_files)):
	control_descs.append(control_files[c1]+"_desc.csv")
	for c1 in range(len(control_files)):
	control_files[c1]=control_files[c1]+".py"
	# These lists will contain separate dictionaries
	# for every control file.
	control_file_inputs=[]
	control_file_outputs=[]
	control_file_staticvars=[]
	control_file_timeevents=[]
	control_desc_handles=[]
	for c1 in range(len(control_files)):
	# Adding an empty dictionary for a control file.
	control_file_inputs.append({})
	control_file_outputs.append({})
	control_file_staticvars.append({})
	control_file_timeevents.append({})
	# Check if the descriptor exists.
	try:
	control_desc_handles.append(open(control_descs[c1],"r"))
	except:
	# If it doesn't create a blank template.
	control_desc_handles.append(open(control_descs[c1],"w"))
	# Input template
	control_desc_handles[c1].write("Input")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	# Output template. Create a line for every
	# control input a particular controlled
	# element has.
	for c2 in range(len(component_objects[controlled_elements[0]].control_tag)):
	control_desc_handles[c1].write("Output")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[controlled_elements[0]].type+"_"+component_objects[controlled_elements[0]].tag))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Control tag defined in parameters spreadhseet = %s" %(component_objects[controlled_elements[0]].control_tag[c2]))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[controlled_elements[0]].control_tag[c2]))
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	# Static variable template
	control_desc_handles[c1].write("StaticVariable")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = Var1")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Initial value of variable = 0.0")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	# Time event template
	control_desc_handles[c1].write("TimeEvent")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("Desired variable name in control code = t1")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("First time event = 0.0")
	control_desc_handles[c1].write(", ")
	control_desc_handles[c1].write("\n")
	control_desc_handles[c1].close()
	# Wait for the user to enter parameters before
	# reading the nw_params.csv file.
	cont_ans="n"
	while cont_ans.lower()!="y":
	print "Enter control parameters in the following files --> "
	for c1 in range(len(control_descs)):
	print "%s " %control_descs[c1]
	cont_ans=raw_input("When ready press y and enter to continue -> ")
	# Read the parameters from the descriptor spreadsheet.
	control_desc_handles=[]
	for c1 in range(len(control_files)):
	control_desc_handles.append(open(control_descs[c1],"r"))
	params_from_file=reading_params(control_desc_handles[c1])
	for c2 in range(len(params_from_file)):
	# Scrubbing blank spaces from the beginning
	# and the end of the first cell.
	while params_from_file[c2][0][0]==" ":
	params_from_file[c2][0]=params_from_file[c2][0][1:]
	while params_from_file[c2][0][-1]==" ":
	params_from_file[c2][0]=params_from_file[c2][0][:-1]
	if params_from_file[c2][0].lower()=="input":
	# If it is an input, it will be a meter.
	meter_type=params_from_file[c2][1].split("=")[1]
	while meter_type[0]==" ":
	meter_type=meter_type[1:]
	while meter_type[-1]==" ":
	meter_type=meter_type[:-1]
	# Look for the meter in components_found
	# and get the cell position from the meter tag.
	# The cell position which is unique will be the
	# dictionary key for control_file_inputs.
	for c3 in range(len(components_found[meter_type.split("_")[0].lower()])):
	if components_found[meter_type.split("_")[0].lower()][c3][1]==meter_type.split("_")[1]:
	meter_type_ref=meter_type.split("_")[0].lower()
	control_file_inputs[c1][components_found[meter_type_ref][c3][0]]=[components_found[meter_type_ref][c3][1]]
	var_name=params_from_file[c2][2].split("=")[1]
	while var_name[0]==" ":
	var_name=var_name[1:]
	while var_name[-1]==" ":
	var_name=var_name[:-1]
	control_file_inputs[c1][components_found[meter_type_ref][c3][0]].append(var_name)
	if params_from_file[c2][0].lower()=="output":
	# If it is an output, it is a controlled element
	element_type=params_from_file[c2][1].split("=")[1]
	while element_type[0]==" ":
	element_type=element_type[1:]
	while element_type[-1]==" ":
	element_type=element_type[:-1]
	# Look for the controlled element in components_found
	# and get the cell position from the device tag.
	# The cell position will be the unique dictionary key
	for c3 in range(len(components_found[element_type.split("_")[0].lower()])):
	if components_found[element_type.split("_")[0].lower()][c3][1]==element_type.split("_")[1]:
	element_type_ref=element_type.split("_")[0].lower()
	# Since a controlled element can have more than one control input
	# Check if it has been found before.
	if not components_found[element_type_ref][c3][0] in control_file_outputs[c1].keys():
	control_file_outputs[c1][components_found[element_type_ref][c3][0]]=[components_found[element_type_ref][c3][1]]
	control_tag_name=params_from_file[c2][2].split("=")[1]
	control_var_name=params_from_file[c2][3].split("=")[1]
	while control_tag_name[0]==" ":
	control_tag_name=control_tag_name[1:]
	while control_tag_name[-1]==" ":
	control_tag_name=control_tag_name[:-1]
	while control_var_name[0]==" ":
	control_var_name=control_var_name[1:]
	while control_var_name[-1]==" ":
	control_var_name=control_var_name[:-1]
	control_file_outputs[c1][components_found[element_type_ref][c3][0]].append([control_tag_name, control_var_name, 0.0])
	if params_from_file[c2][0].lower()=="staticvariable":
	# If it is a staticvariable, the dictionary key
	# will be the variable name.
	staticvar_type=params_from_file[c2][1].split("=")[1]
	while staticvar_type[0]==" ":
	staticvar_type=staticvar_type[1:]
	while staticvar_type[-1]==" ":
	staticvar_type=staticvar_type[:-1]
	staticvar_val=params_from_file[c2][2].split("=")[1]
	while staticvar_val[0]==" ":
	staticvar_val=staticvar_val[1:]
	while staticvar_val[-1]==" ":
	staticvar_val=staticvar_val[:-1]
	control_file_staticvars[c1][staticvar_type]=float(staticvar_val)
	if params_from_file[c2][0].lower()=="timeevent":
	# If it is a timeevent, the dictionary key
	# will be the variable name.
	timeevent_type=params_from_file[c2][1].split("=")[1]
	while timeevent_type[0]==" ":
	timeevent_type=timeevent_type[1:]
	while timeevent_type[-1]==" ":
	timeevent_type=timeevent_type[:-1]
	timeevent_val=params_from_file[c2][2].split("=")[1]
	while timeevent_val[0]==" ":
	timeevent_val=timeevent_val[1:]
	while timeevent_val[-1]==" ":
	timeevent_val=timeevent_val[:-1]
	control_file_timeevents[c1][timeevent_type]=float(timeevent_val)
	control_desc_handles[c1].close()

view raw cont_interface.py hosted with ❤ by GitHub

Control interface design

I have been thinking of how the control interface would be like for the user. A user needs a few essentials:

1. An easy way to define inputs, outputs. So, in the same was you would join an ammeter output to an in-port, you need to be able to define such a connection and use the variable inside the code. Also, the output of a block should be connected to a controllable device. In case the controllable device has multiple controls, the user should be able to define which controls get what variables.

2. Time events: The simplest thing to do would be to define a constant sampling frequency but this would make multi-rate sampling impossible. Also, ideally, the user should be able to decide when the code will run next. As a reference, the user will be given the current simulation time as t_clock. Really, that is also not needed, because the user needs to define "after" how much time the control code will run again and not "at" what time the control code will run again.

3. The nature of the code: One of the reasons for using Python was to be able to combine some of the other efforts in signal processing, linear algebra etc that are happening and give the user the chance to write advanced control code. So the user can write anything that is valid code. For that matter I am not sure if it is possible to embed a C program/function within a Python program. But if that is possible, why not? Essentially, anything that you can do in Python in general.


So this is what the code I have written has designed so far.

1. Take from the user the name of the control files that he wants to use. For every control file, there will be a "descriptor" file with a _desc. This will be a CSV file. This file contains four keywords - "Input", "Output", "StaticVariable" and "TimeEvent".

2. As a framework, a sample of all these will be provided in every descriptor file. So there will be one of each to tell the user how to do the rest.

3. An "Input" will be from a meter. So the user will need to specify the name of the meter as in the circuit spreadsheet and the variable name by which they want to refer to it in the control code.
An "Output" will be at a controllable device and additionally a control tag to account for devices that have multiple control inputs and finally the variable name in the control code.
"StaticVariables" will be variables that will continue to be available with their latest values in the control code. So these will passed back and forth with the main program. All other variables used in the code will be temporary and will exist only in the control code (local variables).
"TimeEvent" will be when the code runs next. Here not fully sure what to do. Supposing there are multiple blocks of code the user wants to execute at different rates - say 100 microseconds and 145 microseconds. The user can define two time events. A simple way would be let the user take the simulation time in the form of "t_clock" and compare t_clock with the time events. A more elaborate way would be define any tevent as tevent=tevent+x. x could be constant or variable. And tevent can be initialized by the user.

4. With every control file, there will be a descriptor file. So there can be multiple control codes.

5. Once this is defined, the user writes the control code. The program takes the control code, embeds it inside a function and maps the inputs, outputs etc to variables passed from the main program. All this will be written automatically into another program with any import statements the user includes. This program will be imported by the main program and the functions will be executed automatically.


So this is the plan. Steps 1, 2, 3 and 4 are done. The code is almost ready and I need to think over it. Step 5 will then follow.

Next step - controlled sources and power electronics

The thought of spending the next few weeks sorting out the exception handling put me off completely. So I decided to skip that stage and move on to expanding the library instead. Whats the point of having my own project if I can't do what I want?

So, now designing the interface for a controllable object for example a controllable voltage source. The primary objective with this software is that an advanced user should be able to code whatever he wants as the control code. Taking my requirements specifically, I would like the control code that I write to be able to translate into a C program that I can compile into a DSP.

So, with any controllable object, what are the major interface requirements?
1. Inputs - preferrably in the form of meaurements from meters
2. Control outputs - can be defined in the parameter specification sheet.
3. An event generator - when must the control values be updated.

With no. 1 and no. 2 the objective will be that the user should have convenient interface to access the outputs of measurement meters and  update the controls without getting too much into the way objects are defined. So this means, I would have to add another layer between the "component_objects" dictionary in the main circuit_solver.py and the control code. So the next question, how will this interface be decided? In most simulators, input ports are defined and these are connected to signals in the outer layer. This might be one way to design an interface. Ask the user to choose what are the inputs to the control code.

With no. 3 the purpose of an event generator is that different objects have to be upated at different rates - i.e multi-rate sampling. So the control code must execute when the object with the nearest update time is called. Also, how to ensure that objects are updated only when necessary?

Version 0.1.5 released

Version 0.1.5 released.

http://sourceforge.net/projects/pythonpowerelec/?source=navbar
Also, just in case, since some of the blog may be written in a cryptic manner, specific questions can be directed to pythonpowerelectronics@gmail.com

Current Source

This current source turned out to be a little more tricky that I thought because I was looking for an elegant solution, something with cool network tricks or that uses object oriented programming inheritance techniques. Ended up using the easiest way - model the current source as a voltage source in series with a resistance. The end result is a little dirty - calculate one temporary value to update another temporary value. This is evident from the glitches in the first quarter cycle. Will have to test how this works particularly in an inductive-capacitive circuit. So nothing final yet.

Been a while since I released a version, so I am going to release it soon. Also, the next step will be to move on to version 0.2.0 which will look at structural changes to the code that will bring in error messages and directions of usage.

Anyway, here is the code (click on "view raw" below the code box to see it in a new window):

	class Current_Source:
	""" Current source class. Contains functions to initiliaze
	the resistor according to name tag, unique cell position,
	update system matrix on each iteration. """
	def __init__(self, cs_index, cs_pos, cs_tag):
	""" Constructor to initialize value.
	Also, takes in the identifiers -
	index (serial number), cell position and tag. """
	self.type="CurrentSource"
	self.cs_number=cs_index
	self.cs_pos=cs_pos
	self.cs_tag=cs_tag
	self.cs_peak=5.0
	self.cs_freq=60.0
	self.cs_phase=0.0
	self.cs_level=120.0
	self.resistor=1.0
	self.current=0.0
	self.voltage=0.0
	self.op_value=0.0
	self.cs_polrty=[-1, -1]
	def display(self):
	print "Current Source is ",
	print self.cs_tag,
	print "of %f A (peak), %f Hz(frequency) and %f (degrees phase shift)" %(self.cs_peak, self.cs_freq, self.cs_phase),
	print " located at ",
	print self.cs_pos,
	print " with positive polarity towards %s" %(csv_element(self.cs_polrty))
	return
	def ask_values(self, x_list, ckt_mat, sys_branch):
	""" Writes the values needed to the spreadsheet."""
	cs_params=["CurrentSource"]
	cs_params.append(self.cs_tag)
	cs_params.append(self.cs_pos)
	cs_params.append("Peak (Amps) = %f" %self.cs_peak)
	cs_params.append("Frequency (Hertz) = %f" %self.cs_freq)
	cs_params.append("Phase (degrees) = %f" %self.cs_phase)
	if self.cs_polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.cs_elem=csv_tuple(self.cs_pos)
	if self.cs_elem[0]>0:
	if ckt_mat[self.cs_elem[0]-1][self.cs_elem[1]]:
	self.cs_polrty=[self.cs_elem[0]-1, self.cs_elem[1]]
	if self.cs_elem[1]>0:
	if ckt_mat[self.cs_elem[0]][self.cs_elem[1]-1]:
	self.cs_polrty=[self.cs_elem[0], self.cs_elem[1]-1]
	if self.cs_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.cs_elem[0]+1][self.cs_elem[1]]:
	self.cs_polrty=[self.cs_elem[0]+1, self.cs_elem[1]]
	if self.cs_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.cs_elem[0]][self.cs_elem[1]+1]:
	self.cs_polrty=[self.cs_elem[0], self.cs_elem[1]+1]
	else:
	for c1 in range(len(sys_branch)):
	if csv_tuple(self.cs_pos) in sys_branch[c1]:
	if not self.cs_polrty in sys_branch[c1]:
	print
	print "!"*50
	print "ERROR!!! Current source polarity should be in the same branch as the current source. Check source at %s" %self.cs_pos
	print "!"*50
	print
	cs_params.append("Positive polarity towards (cell) = %s" %csv_element(self.cs_polrty))
	x_list.append(cs_params)
	return
	def get_values(self, x_list, ckt_mat):
	""" Takes the parameter from the spreadsheet."""
	self.cs_peak=float(x_list[0].split("=")[1])
	self.cs_freq=float(x_list[1].split("=")[1])
	self.cs_phase=float(x_list[2].split("=")[1])
	curr_polrty=x_list[3].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while curr_polrty[0]==" ":
	curr_polrty=curr_polrty[1:]
	self.cs_polrty=csv_tuple(curr_polrty)
	if not ckt_mat[self.cs_polrty[0]][self.cs_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.cs_polrty)
	return
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix A in E.dx/dt=Ax+Bu will be updated by the
	resistor value."""
	for c1 in range(len(sys_loops)):
	for c2 in range(c1, len(sys_loops)):
	# Updating the elements depending
	# on the sense of the loops (aiding or opposing)
	for c3 in range(len(sys_loops[c1][c2])):
	# Check if current source position is there in the loop.
	if csv_tuple(self.cs_pos) in sys_loops[c1][c2][c3]:
	# Add current source series resistor
	# if branch is in forward direction
	if sys_loops[c1][c2][c3][-1]=="forward":
	mat_a.data[c1][c2]+=self.resistor
	else:
	# Else subtract if branch is in reverse direction
	mat_a.data[c1][c2]-=self.resistor
	# Because the matrices are symmetric
	mat_a.data[c2][c1]=mat_a.data[c1][c2]
	return
	def transfer_to_branch(self, sys_branch, source_list):
	""" Update the resistor info of the voltmeter
	to the branch list """
	if csv_tuple(self.cs_pos) in sys_branch:
	sys_branch[-1][0][0]+=self.resistor
	if csv_tuple(self.cs_pos) in sys_branch:
	if sys_branch.index(self.cs_polrty)<sys_branch.index(csv_tuple(self.cs_pos)):
	sys_branch[-1][1][source_list.index(self.cs_pos)]=-1.0
	else:
	sys_branch[-1][1][source_list.index(self.cs_pos)]=1.0
	return
	def generate_val(self, source_lst, sys_loops, mat_e, mat_a, mat_b, mat_u, state_vec, t, dt):
	""" The source current is updated in the matrix u in
	E.dx/dt=Ax+Bu. The matrix E has a row set to zero. The
	matrix B has the diagonal element in the row set to 1,
	others set to zero."""
	# Updating the current source value
	self.current=self.cs_peak*math.sin(2*math.pi*self.cs_freq*t+self.cs_phase)
	# The value passed to the input matrix is
	# the voltage calculated
	mat_u.data[source_lst.index(self.cs_pos)][0]=self.voltage
	# The output value of the source will the current
	# even though it is actually modelled as a
	# voltage source with a series resistance.
	self.op_value=self.current
	return
	def update_val(self, sys_loops, lbyr_ratio, mat_e, mat_a, mat_b, state_vec, mat_u):
	""" This function calculates the actual current in
	the current source branch. With this, the branch voltage is
	found with respect to the existing voltage source. The branch
	voltage is then used to calculate the new voltage source value. """
	# Local variable to calculate the branch
	# current from all loops that contain
	# the current source branch.
	act_current=0.0
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	if csv_tuple(self.cs_pos) in sys_loops[c1][c1][c2]:
	# If current source polarity is before the source
	# position, it means actual current is negative.
	if sys_loops[c1][c1][c2].index(self.cs_polrty)<sys_loops[c1][c1][c2].index(csv_tuple(self.cs_pos)):
	# Then check is the loop is aiding or opposing
	# the main loop.
	if sys_loops[c1][c1][c2][-1]=="forward":
	act_current+=state_vec.data[c1][0]
	else:
	act_current-=state_vec.data[c1][0]
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	act_current-=state_vec.data[c1][0]
	else:
	act_current+=state_vec.data[c1][0]
	# The branch voltage is the KVL with the
	# existing voltage source and the branch current
	branch_voltage=self.voltage+act_current*self.resistor
	# The new source voltage will be the branch voltage
	# in addition to the desired value of current.
	self.voltage=branch_voltage+self.current*self.resistor
	return

view raw currentsource.py hosted with ❤ by GitHub

User defined objects - II

Spent a couple of days thinking about ways in which a user can define a "block" that could be connected repeatedly in the circuit. But something similar has made that half-possible already - the "jump" labels.

A crude way of defining blocks would be to simply describe a part of a circuit (for example an RLC circuit or a three-phase inverter) and connect it to the rest of the circuit using jump labels. The reason this would be crude is that the entire sub-circuit would have to be copied that many number of times and for each object, the constituent components would have to be given separate labels.

A much more elegant manner would be to define a single sub-circuit as the base class. The main circuit will then contain references to this class and the connections could be made by jump labels with additional unique identifiers. For example a RL sub-circuit could have a jump1 and jump2 labels as connectors. The main circuit can have jump labels as jump1_RL1 and jump2_RL1 to signify a component RL1. The extention "RL1" will result in labels RL1 automatically created that will be appended to the resistor and inductor within the sub-circuit.

The problem with this method is that in a very large circuit with several sub-components repeated, it may be necessary to change the parameters of some of them to simulate special conditions such as nonideal parameters. So by having a single block, additional changes to the structure won't be possible. So, by copying the sub-circuit again and again, this flexibility is provided. The only drawback is that the user will have to edit all the component labels. But that may not be such a bad thing because the program does the error checking for duplicate labels. So a circuit will not run with multiple labels if the user accidentally forgets to edit some of the labels.

So this option of copying a circuit as many times as you need in the circuit is not such a bad idea because even for the sake of appearance, you can have these blocks anywhere in the spreadhseet, not necesarily bang in the middle of the main circuit.

So, now all I have to do is define a current source and I'll be done with the first set of elements.

User defined objects

While examining current sources, I figured that since the basis for the circuit solver is mesh analysis, the current source will have to be converted to a voltage source in series with a resistance. This means a voltage source and a resistance in series connected in parallel with a voltmeter. So essentially the voltage source has to be adjusted with respect to the voltage measured so as to produce the necessary current.

So this starts another task that I was planning to do just before I released a major version. That is of user defined objects. Suppose, a user wants to create an object which is a voltage source in series with an RLC network and make a dozen copies of it in the circuit, how would that be done? As of now, the entire solver works on the basis of cell positions on the spreadsheet. But now these cell positions won't exist in real but fictitious cell positions will have to be created.

Suppose such an object is to be defined. How would the details be internally? Suppose it is placed at position 7E in the spreadsheet. How would each element be defined as cell positions in the loop as it may be more than one loop if there is a parallel element. One possibility is to go ahead with just one cell position but replicate the loop by the number of parallel elements in the loop (essentially the number of branches in parallel). So every time the object is called, an identifier needs to be created to know which parallel element to consider.

So essentially a third dimension needs to be added. This makes sense as we are adding layers to the spreadsheet. But this might need a complete rework of the entire solver! Need to think over this.

Capacitor class

Been a long time since I updated the blog.

To add another element to the library - the capacitor. Anyway, the code is just an extension/combination of the voltmeter/voltage source classes. Here is the code (click on "view raw" below the code box to see it in a new window):

	class Capacitor:
	""" Capacitor class. Contains functions to initiliaze
	the resistor according to name tag, unique cell position,
	update system matrix on each iteration. """
	def __init__(self, cap_index, cap_pos, cap_tag):
	""" Constructor to initialize value.
	Also, takes in the identifiers -
	index (serial number), cell position and tag. """
	self.type="Capacitor"
	self.cap_number=cap_index
	self.cap_pos=cap_pos
	self.cap_tag=cap_tag
	self.capacitor=10.0e-6
	self.current=0.0
	self.voltage=0.0
	self.v_dbydt=0.0
	self.cap_polrty=[-1, -1]
	def display(self):
	""" Displays info about the component."""
	print "Capacitor is ",
	print self.cap_tag,
	print "= %f" %self.capacitor,
	print " located at ",
	print self.cap_pos,
	print " with positive polarity towards %s" %(csv_element(self.cap_polrty))
	def ask_values(self, x_list, ckt_mat, sys_branch):
	""" Writes the values needed to the spreadsheet."""
	cap_params=["Capacitor"]
	cap_params.append(self.cap_tag)
	cap_params.append(self.cap_pos)
	cap_params.append(self.capacitor)
	if self.cap_polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.cap_elem=csv_tuple(self.cap_pos)
	if self.cap_elem[0]>0:
	if ckt_mat[self.cap_elem[0]-1][self.cap_elem[1]]:
	self.cap_polrty=[self.cap_elem[0]-1, self.cap_elem[1]]
	if self.cap_elem[1]>0:
	if ckt_mat[self.cap_elem[0]][self.cap_elem[1]-1]:
	self.cap_polrty=[self.cap_elem[0], self.cap_elem[1]-1]
	if self.cap_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.cap_elem[0]+1][self.cap_elem[1]]:
	self.cap_polrty=[self.cap_elem[0]+1, self.cap_elem[1]]
	if self.cap_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.cap_elem[0]][self.cap_elem[1]+1]:
	self.cap_polrty=[self.cap_elem[0], self.cap_elem[1]+1]
	else:
	for c1 in range(len(sys_branch)):
	if csv_tuple(self.cap_pos) in sys_branch[c1]:
	if not self.cap_polrty in sys_branch[c1]:
	print
	print "!"*50
	print "ERROR!!! Capacitor polarity should be in the same branch as the capacitor. Check source at %s" %self.cap_pos
	print "!"*50
	print
	cap_params.append("Positive polarity towards (cell) = %s" %csv_element(self.cap_polrty))
	x_list.append(cap_params)
	def get_values(self, x_list, ckt_mat):
	""" Takes the parameter from the spreadsheet."""
	self.capacitor=float(x_list[0])
	cap_polrty=x_list[1].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while cap_polrty[0]==" ":
	cap_polrty=cap_polrty[1:]
	self.cap_polrty=csv_tuple(cap_polrty)
	if not ckt_mat[self.cap_polrty[0]][self.cap_polrty[1]]:
	print "Polarity incorrect or changed. Branch does not exist at %s" %csv_element(self.cap_polrty)
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix B in E.dx/dt=Ax+Bu will be updated by the
	polarity of the capacitor."""
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	if csv_tuple(self.cap_pos) in sys_loops[c1][c1][c2]:
	# If the positive polarity appears before the capacitor position
	# it means as per KVL, we are moving from +ve to -ve
	# and so the capacitor voltage will be taken negative
	if sys_loops[c1][c1][c2].index(self.cap_polrty)<sys_loops[c1][c1][c2].index(csv_tuple(self.cap_pos)):
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.cap_pos)]=-1.0
	else:
	mat_b.data[c1][source_list.index(self.cap_pos)]=1.0
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	mat_b.data[c1][source_list.index(self.cap_pos)]=1.0
	else:
	mat_b.data[c1][source_list.index(self.cap_pos)]=-1.0
	return
	def transfer_to_branch(self, sys_branch, source_list):
	""" Transfers parameters to system branch if capacitor
	exists in the branch. """
	if csv_tuple(self.cap_pos) in sys_branch:
	if sys_branch.index(self.cap_polrty)<sys_branch.index(csv_tuple(self.cap_pos)):
	sys_branch[-1][1][source_list.index(self.cap_pos)]=-1.0
	else:
	sys_branch[-1][1][source_list.index(self.cap_pos)]=1.0
	return
	def generate_val(self, source_lst, sys_loops, mat_u, t, dt):
	""" The capacitor voltage is updated in the matrix u in
	E.dx/dt=Ax+Bu ."""
	self.v_dbydt=self.current/self.capacitor
	self.voltage+=self.v_dbydt*dt
	mat_u.data[source_lst.index(self.cap_pos)][0]=self.voltage
	self.op_value=self.voltage
	def update_val(self, sys_loops, lbyr_ratio, mat_e, mat_a, mat_b, state_vec, mat_u):
	""" The capacitor current is calculated as a result of the KVL."""
	self.current=0.0
	for c1 in range(len(sys_loops)):
	for c2 in range(len(sys_loops[c1][c1])):
	if csv_tuple(self.cap_pos) in sys_loops[c1][c1][c2]:
	# If capacitor polarity is before the capacitor
	# position, it means current is positive.
	if sys_loops[c1][c1][c2].index(self.cap_polrty)<sys_loops[c1][c1][c2].index(csv_tuple(self.cap_pos)):
	# Then check is the loop is aiding or opposing
	# the main loop.
	if sys_loops[c1][c1][c2][-1]=="forward":
	self.current+=state_vec.data[c1][0]
	else:
	self.current-=state_vec.data[c1][0]
	else:
	if sys_loops[c1][c1][c2][-1]=="forward":
	self.current-=state_vec.data[c1][0]
	else:
	self.current+=state_vec.data[c1][0]
	return

view raw capacitor.py hosted with ❤ by GitHub

I'll release another version after completing the current source class which I hope will be in a few days.

For the current source class, my guess it would be best to exclude it from the branch list so that it doesn't appear in any of the loops. For every current source a simple nodal equation can then be added.

Version 0.1.4 released

Released another version:
http://sourceforge.net/projects/pythonpowerelec/files/

Next step:
Complete the passive library - include capacitor and current source. Current source is extremely important for us power electronics guys and that might be a bit of a challenge as the loops will be refined every time a current source is found.

Simulation speed

Before the topic of simulation speed, a minor check to be performed on components that have polarity like voltage sources, ammeters and voltmeters.

Until now, the only check on the polarity of these elements is that it is within the physical circuit map. But now that branches have been defined, another check can be enforced about whether the polarity element is in the same branch as the component. This is the code (click on "view raw" below the box to see the code in a new window):

	def ask_values(self, x_list, ckt_mat, sys_branch):
	""" Writes the values needed to the spreadsheet."""
	volt_params=["VoltageSource"]
	volt_params.append(self.volt_tag)
	volt_params.append(self.volt_pos)
	volt_params.append("Peak (Volts) = %f" %self.v_peak)
	volt_params.append("Frequency (Hertz) = %f" %self.v_freq)
	volt_params.append("Phase (degrees) = %f" %self.v_phase)
	if self.v_polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.volt_elem=csv_tuple(self.volt_pos)
	if self.volt_elem[0]>0:
	if ckt_mat[self.volt_elem[0]-1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]-1, self.volt_elem[1]]
	if self.volt_elem[1]>0:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]-1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]-1]
	if self.volt_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]+1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]+1, self.volt_elem[1]]
	if self.volt_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]+1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]+1]
	else:
	for c1 in range(len(sys_branch)):
	if csv_tuple(self.volt_pos) in sys_branch[c1]:
	if not self.v_polrty in sys_branch[c1]:
	print
	print "!"*50
	print "ERROR!!! Voltage source polarity should be in the same branch as the voltage source. Check source at %s" %self.volt_pos
	print "!"*50
	print
	volt_params.append("Positive polarity towards (cell) = %s" %csv_element(self.v_polrty))
	x_list.append(volt_params)

view raw polarity_check.py hosted with ❤ by GitHub

For this to happen, the main program "circuit_solver.py" has been rearranged a bit. No changes to the code as such. Just that the network interpreter is called immediately after the circuit layout file is interpreted and checked for basic errors like componenents not found in library or duplicate components. The idea is that polarity errors should be picked up at the design stage before the simulation starts.

Now the other change of simulation speed. My concept has been similar to an interrupt driver program. Instead of an interrupt vector, generate an "event vector". This event vector will be "yes" corresponding to a branch is an element has changed in the branch. Otherwise, it will remain "no". If there is a single "yes", this would mean the all the system matrices A, B and E would be calculated completely. Currently, this might be necessary. At a later stage, I could think of ways to recalculate only the parts that are affected.

	# Check is an event has been generated. If yes,
	# recalculate the system matrices. If not, just
	# solve the ODE
	if "yes" in branch_events:
	# Make a copy of the system_loops
	# as row operations may be performed on them.
	system_loops_copy=[]
	for c1 in range(system_size):
	row_vector=[]
	for c2 in range(system_size):
	element_vector=[]
	for c3 in range(len(system_loops[c1][c2])):
	inter_vector=[]
	for c4 in range(len(system_loops[c1][c2][c3])):
	inter_vector.append(system_loops[c1][c2][c3][c4])
	element_vector.append(inter_vector)
	row_vector.append(element_vector)
	system_loops_copy.append(row_vector)
	# Initialize the entries in branch_params
	for c1 in range(len(branch_params)):
	branch_params[c1][-1][0][0]=0.0
	branch_params[c1][-1][0][1]=0.0
	for c2 in range(len(source_list)):
	branch_params[c1][-1][1][c2]=0.0
	# Initialize A,E and B matrices to zero.
	sys_mat_a.zeros(system_size, system_size)
	sys_mat_e.zeros(system_size, system_size)
	sys_mat_b.zeros(system_size, source_size)
	# To update the branch_params list.
	# Take every element in a branch and check
	# if that is a valid object identifier
	# If not, i.e if it is a wire, an exception will
	# be raised in which case nothing will happen.
	# If no exception is raised, do the transfer to the branch
	for c1 in range(len(branch_params)):
	for c2 in range(len(branch_params[c1][:-1])):
	try:
	comp_pos=csv_element(branch_params[c1][c2])
	component_objects[comp_pos]
	except:
	pass
	else:
	component_objects[comp_pos].transfer_to_branch(branch_params[c1], source_list)
	# Now transfer values from the branch to the matrices A,B and E.
	# Look where each branch appears and transfer the info.
	for c1 in range(len(system_loops_copy)):
	for c2 in range(len(system_loops_copy)):
	for c3 in range(len(system_loops_copy[c1][c2])):
	for c4 in range(len(branch_params)):
	if system_loops_copy[c1][c2][c3][:-1]==branch_params[c4][:-1]:
	if c1==c2:
	sys_mat_a.data[c1][c2]+=branch_params[c4][-1][0][0]
	sys_mat_e.data[c1][c2]+=branch_params[c4][-1][0][1]
	if system_loops_copy[c1][c2][c3][-1]=="forward":
	for c5 in range(len(source_list)):
	sys_mat_b.data[c1][c5]+=branch_params[c4][-1][1][c5]
	else:
	for c5 in range(len(source_list)):
	sys_mat_b.data[c1][c5]-=branch_params[c4][-1][1][c5]
	else:
	if system_loops_copy[c1][c2][c3][-1]=="forward":
	sys_mat_a.data[c1][c2]+=branch_params[c4][-1][0][0]
	sys_mat_e.data[c1][c2]+=branch_params[c4][-1][0][1]
	else:
	sys_mat_a.data[c1][c2]-=branch_params[c4][-1][0][0]
	sys_mat_e.data[c1][c2]-=branch_params[c4][-1][0][1]
	# Check if the system is stiff and recalculate if it is.
	remove_stiffness(sys_mat_e, sys_mat_a, sys_mat_b, dt, system_loops_copy, branch_params)
	mat_ode_reduce(sys_mat_e, sys_mat_a, sys_mat_b)
	# Remove the branch events
	for c1 in range(len(branch_events)):
	branch_events[c1]="no"
	# Update the input values in u matrix
	for c1 in range(len(source_list)):
	component_objects[source_list[c1]].generate_val(source_list, system_loops_copy, sys_mat_u, t, dt)
	# The ODE solver.
	# Will return the x(k+1) value called
	# as next_state_vec from x(k) value
	# called curr_state_vec
	mat_ode(sys_mat_e, sys_mat_a, sys_mat_b, [curr_state_vec, next_state_vec], sys_mat_u, dt, ode_var, system_loops_copy, node_list)

view raw sim_speed.py hosted with ❤ by GitHub

So, the branch_events vector is reset to "no" at the end of the code block. This vector is initialized to "yes" at the beginning to ensure that at least one computation takes place. With passive circuits, there won't be any event generation and therefore, there will be no recalculation.

This has speeded up the execution quite a bit but still not as much as I would have liked. Need to figure which of the code blocks can be done away with. A fairly simple circuit like "testckt7.csv" in the example list which results in a 4x4 system takes around 2 minutes to solve for a run time of 0.5s and a time step of 10 microseconds. Which is quite slow. At later stages, this might be a problem when simulating an inverter with a time step of 1 microsecond. If the inverter has a switching frequency of 5 kHz, an event would be generated around every 30 microseconds. No idea how it is going to be.

Version 0.1.3 released

Been incredibly busy with my official research project. Will continue to be busy for another week until my PCBs are sent out for fabrication. Thought I would release another version just so that I don't loose track of what I have done.

http://sourceforge.net/projects/pythonpowerelec/

Created a voltmeter model that you can use to measure voltage. The concept is it is a large resistance is parallel with the nodes across which voltage is to be measured. The parameter taken as input is the rated voltage of the system. This is just an approximate value so as to choose the voltmeter resistance large enough that a negligible current of 1 microampere flows through the voltmeter.

Version 0.1.2 released.

Released the next minor patch:
http://sourceforge.net/projects/pythonpowerelec/files/

Stiff Systems - III

Several changes made to the entire codes. In order to solve every type of stiff system effectively, the only was seems to be to completely recalculate not only the A, B and E matrices but the KVL loops and their interactions.

At the highest level, I defined another layer called the branch. Currently, it is another list, but it may be an object depending on the later use. I have defined the branch as follows (click on "view raw" to see the code in a new window):

	### This list contains every branch and
	### at the end contains the elements that
	### would go into A, B and E matrices.
	branch_params=[]
	for c1 in range(len(system_loops)):
	# Check if a branch has already been added to
	# branch_params.
	for c2 in range(len(system_loops[c1][c1])):
	branch_found="no"
	for c4 in range(len(branch_params)):
	if system_loops[c1][c1][c2][:-1]==branch_params[c4][:-1]:
	branch_found="yes"
	# Matrix B will have the number
	# of entries equal to the number
	# of sources.
	if branch_found=="no":
	source_add=[]
	for c3 in range(len(source_list)):
	source_add.append(0.0)
	branch_add=system_loops[c1][c1][c2][:-1]
	params_add=[]
	params_add.append([0.0,0.0])
	params_add.append(source_add)
	branch_add.append(params_add)
	branch_params.append(branch_add)
	### This is an additional layer of check to make sure
	### that none of the branches in branch_params is the
	### reverse of another.
	for c1 in range(len(branch_params)-1, -1, -1):
	# Start from the last branch and compute
	# the reverse.
	# Make a copy
	check_br_reverse=[]
	for c2 in range(len(branch_params[c1])-1):
	check_br_reverse.append(branch_params[c1][c2])
	# Reverse the copy
	for c2 in range(len(check_br_reverse)/2):
	check_br_reverse[c2], check_br_reverse[len(check_br_reverse)-1-c2] = \
	check_br_reverse[len(check_br_reverse)-1-c2], check_br_reverse[c2]
	# Iterate through the branches.
	c2=0
	while c2<len(branch_params):
	# Check if the reverse of the branch c1
	# is equal to the current branch
	if check_br_reverse==branch_params[c2][:-1]:
	# In this case, two things need to be done
	# Find out where the branch occurs in
	# system_loops and reverse those branches
	# Second, delete that branch from branch_params
	# There will be two instances of the branch
	# One with a forward appended at the end
	check_br_fwd=[]
	for c3 in range(len(branch_params[c1][:-1])):
	check_br_fwd.append(branch_params[c1][c3])
	check_br_fwd.append("forward")
	# The other with a reverse appended at the end.
	check_br_rev=[]
	for c3 in range(len(branch_params[c1][:-1])):
	check_br_rev.append(branch_params[c1][c3])
	check_br_rev.append("reverse")
	# Look through the entire system_loops matrix
	for c3 in range(len(system_loops)):
	for c4 in range(len(system_loops)):
	# Check if the branch with forward is found.
	if (check_br_fwd in system_loops[c3][c4]):
	# Mark the position
	ex_br_pos=system_loops[c3][c4].index(check_br_fwd)
	# Mark the direction
	ex_br_dir=system_loops[c3][c4][ex_br_pos][-1]
	# Delete the branch
	del system_loops[c3][c4][ex_br_pos]
	# Add the earlier branch found branch_params[c2]
	# But reverse the direction of the branch just
	# deleted.
	if ex_br_dir=="forward":
	new_br=[]
	for c5 in range(len(branch_params[c2])-1):
	new_br.append(branch_params[c2][c5])
	new_br.append("forward")
	system_loops[c3][c4].append(new_br)
	else:
	new_br=[]
	for c5 in range(len(branch_params[c2])-1):
	new_br.append(branch_params[c2][c5])
	new_br.append("reverse")
	system_loops[c3][c4].append(new_br)
	# Repeat the process with the branch with reverse
	if (check_br_rev in system_loops[c3][c4]):
	ex_br_pos=system_loops[c3][c4].index(check_br_rev)
	ex_br_dir=system_loops[c3][c4][ex_br_pos][-1]
	del system_loops[c3][c4][ex_br_pos]
	if ex_br_dir=="forward":
	new_br=[]
	for c5 in range(len(branch_params[c2])-1):
	new_br.append(branch_params[c2][c5])
	new_br.append("forward")
	system_loops[c3][c4].append(new_br)
	else:
	new_br=[]
	for c5 in range(len(branch_params[c2])-1):
	new_br.append(branch_params[c2][c5])
	new_br.append("reverse")
	system_loops[c3][c4].append(new_br)
	# Delete the latest branch because it is a reverse
	del branch_params[c1]
	c2+=1

view raw branch_fed.py hosted with ❤ by GitHub

There was a problem where some branches were the reverse of the other and these were difficult to handle when loops were being manipulated. So I added the code to delete the redundant branches and also remove them from the system_loops matrix.

Another concept planned for the next stage was that each branch can have an "event" flag. That is if there is a change in the parameters like a diode starting or stopping conduction, there will be an event generated. When an event is generated on a branch, an event is generated to the entire system and only then will the system matrices A, B and E be recalculated. Otherwise, leave them as it is and just solve the equations for new inputs. Even in a power electronics circuit, this may result in significant savings as a change may happen once in 20-50 microseconds so that with a time step of 1 microsecond, the computation can be 20-50x faster if all the recalculation are left out.

The branches are updated as follows (click on "view raw" to see the code in a new window):

	# Now transfer values from the branch to the matrices A,B and E.
	# Look where each branch appears and transfer the info.
	for c1 in range(len(system_loops_copy)):
	for c2 in range(len(system_loops_copy)):
	for c3 in range(len(system_loops_copy[c1][c2])):
	for c4 in range(len(branch_params)):
	if system_loops_copy[c1][c2][c3][:-1]==branch_params[c4][:-1]:
	if c1==c2:
	sys_mat_a.data[c1][c2]+=branch_params[c4][-1][0][0]
	sys_mat_e.data[c1][c2]+=branch_params[c4][-1][0][1]
	if system_loops_copy[c1][c2][c3][-1]=="forward":
	for c5 in range(len(source_list)):
	sys_mat_b.data[c1][c5]+=branch_params[c4][-1][1][c5]
	else:
	for c5 in range(len(source_list)):
	sys_mat_b.data[c1][c5]-=branch_params[c4][-1][1][c5]
	else:
	if system_loops_copy[c1][c2][c3][-1]=="forward":
	sys_mat_a.data[c1][c2]+=branch_params[c4][-1][0][0]
	sys_mat_e.data[c1][c2]+=branch_params[c4][-1][0][1]
	else:
	sys_mat_a.data[c1][c2]-=branch_params[c4][-1][0][0]
	sys_mat_e.data[c1][c2]-=branch_params[c4][-1][0][1]

view raw branch_update.py hosted with ❤ by GitHub

Also, each class has another method called "transfer_to_branch".

The really huge change has been in the solver.py file. The basic concept is described here. The file has comments as far as possible.

1. The way to find out if a loop is stiff is to check the L/R ratio. If the L/R ratio of the diagonal element is low, the offdiagonal elements are checked. If they are also stiff, a row manipulation is done with the lower loops so that the stiff elements are removed from the lower loops.

2. Once the stiff elements have been isolated to individual loops by row operations, the loops are now recalculated.

3. Once again the system matrices A, B and E are then calculated from the new loops and now the ODE is solved.

Stiff systems - II

Stupid mistake. The algorithm wasn't totally wrong. Still is wrong but not completely wrong. The problem was in the loop interaction.

Take this sample circuit:

The large resistors are Resistor_V2 (at 4D and of 500000.0 ohm) and Resistor_V1 (at 12 J and of 10000000.0 ohm).

The matrices turned out to be:
-----------------------------------------------------------------------------------------------------------
500000.0  500000.0  0.0  500000.0  500000.0
500000.0  500010.1  0.0  -500000.1  500000.1
0.0  0.0  10000010.0  0.0  -10000000.0
500000.0  -500000.1  0.0  500020.1  -499990.1
500000.0  500000.1  -10000000.0  -499990.1  10500010.1

0.0  0.0  0.0  0.0  0.0
0.0  0.0001  0.0  -0.0001  0.0001
0.0  0.0  0.1  0.0  0.0
0.0  -0.0001  0.0  0.2001  0.0999
0.0  0.0001  0.0  0.0999  0.1001

1.0
0.0
0.0
0.0
0.0
-----------------------------------------------------------------------------------------------------------

For loops defined as:
 -----------------------------------------------------------------------------------------------------------
1D 2D 3D 4D 5D 6D 6C 6B 6A 5A 4A 3A 2A 1A 1B 1C 1D

1H 1G 1F 1E 1D 2D 3D 4D 5D 6D 6E 6F 6G 6H 5H 4H 3H 2H 1H

9L 10L 11L 12L 12K 12J 12I 12H 11H 10H 9H 9I 9J 9K 9L

1H 1G 1F 1E 1D 2D 3D 4D 5D 6D 6E 6F 6G 6H 6I 6J 6K 6L 5L 4L 3L 2L 1L 1K 1J 1I 1H

1H 1G 1F 1E 1D 2D 3D 4D 5D 6D 6E 6F 6G 6H 7H 8H 9H 10H 11H 12H 12I 12J 12K 12L 11L 10L 9L 8L 7L 6L 5L 4L 3L 2L 1L 1K 1J 1I 1H
-----------------------------------------------------------------------------------------------------------

Which is wrong. Because, the interaction between loop 2 and loop 4 is -500000.1 in the matrix A but should be positive from the sense of the loops above. The problem is in the code that defines the "forward" and "reverse" directions.

This is the new code (click on "view raw" to see the code in a new window):

	# A temporary list that stores the nodes
	# common to two loops
	nodes_in_loop=[]
	# A array of all the loops of the system
	# including common branches between loops.
	system_loops=[]
	for c1 in range(loop_count):
	row_vector=[]
	for c2 in range(loop_count):
	row_vector.append([])
	system_loops.append(row_vector)
	for c1 in range(len(loop_branches)):
	# The diagonal elements of system_loops
	# will be the loops themselves.
	for c2 in range(len(loop_branches[c1])):
	system_loops[c1][c1].append(loop_branches[c1][c2])
	# The system_loops array will be symmetric
	for c2 in range(c1+1, len(loop_branches)):
	# Find the nodes in loop1
	for c3 in range(len(node_list)):
	if node_list[c3] in loop_branches[c1]:
	nodes_in_loop.append(node_list[c3])
	# Find out the nodes common to loop1
	# and loop2.
	for c3 in range(len(nodes_in_loop)-1, -1, -1):
	if nodes_in_loop[c3] not in loop_branches[c2]:
	del nodes_in_loop[c3]
	# If there are two or more nodes common
	# between loop1 and loop2, there are
	# common elements.
	if len(nodes_in_loop)>1:
	comm_seg_in_loop=comm_elem_in_loop(loop_branches[c1], loop_branches[c2])
	# The list of common branches between
	# loop c1 and loop c2
	sys_loop_off_diag=comm_branch_in_loop(comm_seg_in_loop, loop_branches[c1])
	for c3 in range(len(sys_loop_off_diag)):
	#for c4 in range(len(sys_loop_off_diag[c3])):
	system_loops[c1][c2].append(sys_loop_off_diag[c3])
	system_loops[c2][c1].append(sys_loop_off_diag[c3])
	# Determining the direction of common
	# branches between loops c1 and c2
	for c3 in range(len(sys_loop_off_diag)):
	st_node=sys_loop_off_diag[c3][0]
	end_node=sys_loop_off_diag[c3][-1]
	# Map the start and end nodes of common
	# branch c3 to loops c1 and c2
	loop1_st_node=loop_branches[c1].index(st_node)
	loop1_end_node=loop_branches[c1].index(end_node)
	loop2_st_node=loop_branches[c2].index(st_node)
	loop2_end_node=loop_branches[c2].index(end_node)
	# This check is because the first node of a
	# loop is the same as the last node.
	# So this is to make sure, the correct start
	# and end nodes are mapped, the difference between
	# the indices is compared to the length of the common
	# branch. If not equal, this means, the last node of
	# a loop needs to be taken instead of the first node.
	if (abs(loop1_end_node-loop1_st_node)!= (len(sys_loop_off_diag[c3])-1)):
	if (len(loop_branches[c1])-1-loop1_st_node==(len(sys_loop_off_diag[c3])-1)):
	loop1_end_node=len(loop_branches[c1])-1
	if (len(loop_branches[c1])-1-loop1_end_node==(len(sys_loop_off_diag[c3])-1)):
	loop1_st_node=len(loop_branches[c1])-1
	if (abs(loop2_end_node-loop2_st_node)!= (len(sys_loop_off_diag[c3])-1)):
	if (len(loop_branches[c2])-1-loop2_st_node==(len(sys_loop_off_diag[c3])-1)):
	loop2_end_node=len(loop_branches[c2])-1
	if (len(loop_branches[c2])-1-loop2_end_node==(len(sys_loop_off_diag[c3])-1)):
	loop2_st_node=len(loop_branches[c2])-1
	if (loop1_st_node<loop1_end_node):
	loop1_dir="ahead"
	else:
	loop1_dir="back"
	if (loop2_st_node<loop2_end_node):
	loop2_dir="ahead"
	else:
	loop2_dir="back"
	if loop1_dir=="ahead" and loop2_dir=="ahead":
	sys_loop_off_diag[c3].append("forward")
	if loop1_dir=="back" and loop2_dir=="back":
	sys_loop_off_diag[c3].append("forward")
	if loop1_dir=="ahead" and loop2_dir=="back":
	sys_loop_off_diag[c3].append("reverse")
	if loop1_dir=="back" and loop2_dir=="ahead":
	sys_loop_off_diag[c3].append("reverse")
	nodes_in_loop=[]

view raw loop_interac_dir.py hosted with ❤ by GitHub

The problem is with the judgement of length of branch with respect to the start and end nodes. The length of the branch will the number of elements in the branch. Which will be (end_node_st_node+1). This is exact block where there was the error:
-----------------------------------------------------------------------------------------------------------
if (abs(loop1_end_node-loop1_st_node)!= (len(sys_loop_off_diag[c3])-1)):
    if (len(loop_branches[c1])-1-loop1_st_node==(len(sys_loop_off_diag[c3])-1)):
        loop1_end_node=len(loop_branches[c1])-1
    if (len(loop_branches[c1])-1-loop1_end_node==(len(sys_loop_off_diag[c3])-1)):
        loop1_st_node=len(loop_branches[c1])-1
if (abs(loop2_end_node-loop2_st_node)!= (len(sys_loop_off_diag[c3])-1)):
    if (len(loop_branches[c2])-1-loop2_st_node==(len(sys_loop_off_diag[c3])-1)):
        loop2_end_node=len(loop_branches[c2])-1
    if (len(loop_branches[c2])-1-loop2_end_node==(len(sys_loop_off_diag[c3])-1)):
        loop2_st_node=len(loop_branches[c2])-1
-----------------------------------------------------------------------------------------------------------


So, the row manipulations to remove the stiff elements from the matrix produce the following matrices:
-----------------------------------------------------------------------------------------------------------
a=
500000.0  0.0  0.0  0.0  0.0
0.0  10.1  0.0  0.0999999999767  0.0999999999767
0.0  0.0  10500010.0  0.0  0.0
0.0  0.0999999999767  0.0  20.1  10.1
0.0  0.0999999999767  10.0  10.1  10.0999999996

e=
0.0  0.0  0.0  0.0  0.0
0.0  0.0001  0.0  0.0001  0.0001
0.0  0.0  0.0  0.0  0.0
0.0  0.0001  0.0  0.2001  0.1001
0.0  0.0001  0.1  0.1001  0.1001

b=
1.0
-1.0
1.0
-1.0
-1.0
-----------------------------------------------------------------------------------------------------------


The isolation has taken place. Because the two large resistors have been isolated to two separate rows. But the loop resistance between the 10000000.0 ohm resistor and the source is wrong. It should be 10000010.1 instead of 10500010.0.

Well, it doesn't blow up like before. So an improvement.

Releasing this as a new patch anyway (v0.1.2). Check on the SourceForge site soon.

Stiff systems

Changing the title at least to reflect the focus of the problem.

Change in strategy. Make a collection of branches and for each branch have the entries for A, E and B matrices. So this will give an indication of the L, R and V values in every branch.

What is a stiff branch?

1. It is not a branch with negligible or zero inductance. If the resistance is small enough, it could be a load resistance or even a branch resistance.
2. It is a branch with a large resistance and negligible or zero inductance.

So, how do know this? It is relative. If all the resistances in the circuit are in a narrow range - say 0.1 to 1000, the system is not stiff. How large a resistance is again depends on the voltage level - for a 120 V system, 100 kiloohm would be large, for a 120 kV system, it would be nothing. But to avoid a per unit system and still classify a system as stiff will mean I need to arrange them in an order according to the resistances. Which is not a difficult task.

After this, I need to calculate the L/R ratio just in case though a very large inductance accompanying a large resistance is not very practical. A large resistance simply means an open circuit or a non-conducting medium but a large inductance means a huge core and a large number of turns in the winding. The worst I can think of in a huge transformer that has a large magnetising inductance but this will have a low winding resistance and a large core loss resistor across it. So it won't be a stiff system. On the contrary it will be a system with a large time constant which is actually the case because when you energize one of these monsters, the magnetizing current can take a long time to decay.

The smallest resistance and inductance would really be the measure of a circuit because they would be the parasitics. So suppose I take these as a base and try to calculate ratios of other elements with respect to it. So a parasitic resistance of 0.005 ohm for a 120 V circuit would be acceptable wire resistance. And a 10 ohm load resistor would result in  a ratio of 10/0.005=2000 which is quite OK. But a 1 megaohm resistor would result in a ratio 2.0e+8 which should raise an alarm.

Taking such a ratio is itself a form of per unit, just that the per unit is arbitrary and if a user puts ridiculous values and an equally impractical simulation time step, a circuit will classified as stiff.

Circuit Solver - IX

Too quick to celebrate. One of the reason why I thought things were working was because the system was small and it wasn't too easy to miss out branches. The row operations to get rid of the large resistances and isolate the stiff equations was correct. But the subsequent matrix manipulation to make the matrix symmetric was wrong.

The consider the diagonal element of a manipuled row to be the sum of the offdiagonal elements is no way right. Simply because the diaognal element may already contain a branch present in any of the off diagonal elements and so the effective resistance/inductance may be larger.

I was trying to do this because I didn't want to do another parameter read from the objects. But looks like that may be the only way. Or at least can't be completely avoided. Need to figure out how to minimize the object read.

Circuit Solver - VIII

Documenting what I have been doing for the past two weeks won't be easy. Anyway, the main focus of my problem has been to be able to solve any type of differential equations. When I say any type, this means a combination of differential equations that are stiff and non-stiff. Basically a stiff equation is one that has a small time constant and therefore needs a small simulation time step to capture the dynamics effectively. Something I don't want to do because reducing the time step too much will cause the simulation to be very slow.

So to describe the process from the outer layers of the code to the inner layers.

First major change. The way the current loops of the system and their interaction is decribed. A loop will have the beginning and the ending node as the same and will be a continuous list. The problem is if loop manipulations have to be done - that is differences between loops have to be found in terms of branch segments, it is a little difficult.
So all loops and common branch segments are defined in terms of branches that are elements between two nodes. This is the smallest denomination. Also, every one of them has a direction. If a branch is in a loop and is the diagonal element in system_loops, it has the default direction as "forward". If it shows the interaction between loops, it was have the necessary direction.

So before the ODE solver, a pre-processing has been done to break up all elements in system_loops into lists of branches. This is the code (click on "View Raw" below the code box to see it in a new window):

	for c1 in range(len(system_loops)):
	for c2 in range(len(system_loops)):
	if c1==c2:
	row1_branch_list=[]
	row1_node_list=[]
	for c3 in range(len(node_list)):
	if node_list[c3] in system_loops[c1][c2]:
	row1_node_list.append(system_loops[c1][c2].index(node_list[c3]))
	row1_node_list.sort()
	for c3 in range(len(row1_node_list)-1):
	seg_vector=system_loops[c1][c2][row1_node_list[c3]:row1_node_list[c3+1]+1]
	seg_vector.append("forward")
	row1_branch_list.append(seg_vector)
	seg_vector=system_loops[c1][c2][row1_node_list[c3+1]:len(system_loops[c1][c2])]
	seg_vector.append("forward")
	row1_branch_list.append(seg_vector)
	system_loops[c1][c2]=row1_branch_list
	else:
	row2_branch_list=[]
	row2_node_list=[]
	for c3 in range(len(system_loops[c1][c2])):
	for c4 in range(len(node_list)):
	if node_list[c4] in system_loops[c1][c2][c3]:
	row2_node_list.append(system_loops[c1][c2][c3].index(node_list[c4]))
	row2_node_list.sort()
	for c4 in range(len(row2_node_list)-1):
	seg_vector=system_loops[c1][c2][c3][row2_node_list[c4]:row2_node_list[c4+1]+1]
	seg_vector.append(system_loops[c1][c2][c3][-1])
	row2_branch_list.append(seg_vector)
	row2_node_list=[]
	system_loops[c1][c2]=row2_branch_list

view raw branches_break.py hosted with ❤ by GitHub

The next major change is in the ODE solver. Three steps here:

1. Check for stiff equations - L/R ratio and isolate every stiff branch to a single equation by row operations.
2. With each row operation on the matrices A, B and E, perform the same row operations on the system_loops. So remove elements in common and add new elements.
3. Since, the objective has been to isolate a stiff loop and approximate it to a static equation without a d/dt, the interactions with other loops has to be eliminated and these interactions will have to be readjusted.

Now in detail. Here is the code (click on "View Raw" below the code box to see it in a new window):

	# Getting rid of elements with small time constants
	# that appear multiple times in a circuit.
	for c1 in range(matrix_a.rows):
	if matrix_a.data[c1][c1]:
	if (matrix_e.data[c1][c1]/matrix_a.data[c1][c1])<0.1*dt:
	for c2 in range(c1+1, matrix_a.columns):
	if matrix_a.data[c1][c2]:
	# Check is an off-diagonal element has a
	# small L/R ratio.
	if (matrix_e.data[c1][c2]/matrix_a.data[c1][c2])<0.1*dt:
	# Check if the diagonal element is row c1 has
	# smaller L/R than diagonal element in row c2
	# The idea is to arrange the equations as per
	# time constants. So manipulate the larger time
	# constants with respect to the smaller time constants
	# and ignore the ones that are below a threshold.
	if (matrix_e.data[c1][c1]/matrix_a.data[c1][c1])<(matrix_e.data[c2][c2]/matrix_a.data[c2][c2]):
	# If row c2 has larger time constant,
	# so remove the common element from row c2.
	loop_manipulate(sys_loops, list_of_nodes, c2, c1)
	for c3 in range(matrix_a.columns):
	matrix_a.data[c2][c3]-=matrix_a.data[c1][c3]
	matrix_e.data[c2][c3]-=matrix_e.data[c1][c3]
	for c3 in range(matrix_b.columns):
	matrix_b.data[c2][c3]-=matrix_b.data[c1][c3]
	else:
	loop_manipulate(sys_loops, list_of_nodes, c1, c2)
	for c3 in range(matrix_a.columns):
	matrix_a.data[c1][c3]-=matrix_a.data[c2][c3]
	matrix_e.data[c1][c3]-=matrix_e.data[c2][c3]
	for c3 in range(matrix_b.columns):
	matrix_b.data[c1][c3]-=matrix_b.data[c2][c3]

view raw loop_row_op.py hosted with ❤ by GitHub

Check if a diagonal element has a small L/R ratio (time constant). Now this judgement is purely a guess and I have chosen it as 0.1*SimulationStep. But may have to be changed. If that is the case, this equation has to be isolated. So, the interaction between this loop and other loops, must be eliminated and first we start with the branch that is causing the problems. So look for off diagonal elements in the same row with small time constants.

Suppose an off diagonal element [c1, c2] has a small time constant. This means the branch between loops c1 and c2 has a small time constant. And this therefore means that loop c2 will also have this branch and will also have a small time constant. So, the way to go is to check which loop has a smaller time constant - c1 or c2 by looking at the diagonal elements c1,c1 and c2,c2. The smaller one remains as it is and the larger one is manipulated to remove this stiff branch. This is by changing row c2 to c2-c1.

Look through the entire matrix this way. The objective is then that only the stiff branches will be in their own isolated loops and the stiff elements removed from all other loops.


Next - loop manipulations by changing the elements.

	def loop_manipulate(system_loops, list_nodes, row1, row2):
	"""Does a row1=row1-row2 for the system loops."""
	# A branch segment is that between 2 nodes.
	# A loop will contain several branch segments
	# in continuity and the first and last nodes will
	# be the same. These are diagonal elements in sys_loops.
	# The off diagonal elements are interactions between
	# loops and may be branch segments without continuity.
	# First check in row2 for branches
	# not found in row1. Add those changing the direction
	# - forward becomes reverse and vice versa.
	for c1 in range(len(system_loops)):
	# Iterate through branch segments in row2, c1 element.
	for c2 in range(len(system_loops[row2][c1])):
	# Default flag is no. A single occurance changes the flag.
	branch_found="no"
	# Go through every branch segment in row1, c1 element.
	# Comparing branches in row1, row2 and same column c1
	for c3 in range(len(system_loops[row1][c1])):
	if system_loops[row2][c1][c2]==system_loops[row1][c1][c3]:
	branch_found="yes"
	# If not found, add the branch segment
	if branch_found=="no":
	# Empty segment
	br_vector=[]
	# The last element is "forward" or "reverse"
	for c3 in range(len(system_loops[row2][c1][c2])-1):
	br_vector.append(system_loops[row2][c1][c2][c3])
	# Check for direction, and reverse it.
	if system_loops[row2][c1][c2][-1]=="forward":
	br_vector.append("reverse")
	else:
	br_vector.append("forward")
	system_loops[row1][c1].append(br_vector)
	# Deletion in row 1 is done after addition.
	# The addition of elements has been done with
	# direction reversed and so they can't be found.
	for c2 in range(len(system_loops[row2][c1])):
	# Always go in opposite direction while
	# deleting elements.
	# Iterate through every branch segment
	# of row2, c1
	for c3 in range(len(system_loops[row1][c1])-1, -1, -1):
	# Iterate through every branch segment of row1, c1
	# and delete as soon as duplicate is found.
	if system_loops[row1][c1][c3]==system_loops[row2][c1][c2]:
	del system_loops[row1][c1][c3]
	return

view raw loop_elem_row.py hosted with ❤ by GitHub

The reason for doing this is that when the branch currents are measured, they are measured with respect to the branches present in the loops. So with the above row operations, the loops have changed, so the actual loop descriptions must also change. So when we do c2=c2-c1, we need to find out which elements in c1 are present in c2 and delete them from c2 and which elements are present in c1 but not in c2 and add them reversing their direction.


Last step - readjust the matrices. Here is the code (click on "View Raw" below the code box to see it in a new window):

	# The aim is to isolate the loops that
	# have low time constants and are difficult
	# to integrate. So these equations will be
	# converted to static equations and will
	# contain only the branch that is stiff
	# and a voltage source with the resitance between
	# them.
	for c1 in range(matrix_e.rows):
	# Check if there is a resistance.
	# Should be but check anyway
	if matrix_a.data[c1][c1]:
	# Check if time constant is smaller than
	# simulation time step.
	if (matrix_e.data[c1][c1]/matrix_a.data[c1][c1])<0.1*dt:
	# Check if this equation is related
	# to a source. There should be a
	# non zero element in B.
	flag_input="no"
	for c2 in range(matrix_b.columns):
	if matrix_b.data[c1][c2]:
	flag_input="yes"
	# If no connection to input,
	# perform row operation with another
	# row that has an input.
	while flag_input=="no":
	c2=0
	for c3 in range(matrix_b.columns):
	if matrix_b.data[c2][c3]:
	flag_input="yes"
	if flag_input=="yes":
	for c3 in range(matrix_a.columns):
	# Make all off diagonal
	# elements of A zero in the stiff
	# equation. So there should be only
	# one large total resistance in the
	# stiff branch.
	if not c1==c3:
	matrix_a.data[c1][c3]=0.0
	matrix_a.data[c1][c3]+=matrix_a.data[c2][c3]
	matrix_e.data[c1][c3]+=matrix_e.data[c2][c3]
	for c3 in range(matrix_b.columns):
	matrix_b.data[c1][c3]+=matrix_b.data[c2][c3]
	c2=c2+1
	for c1 in range(matrix_a.rows):
	if matrix_a.data[c1][c1]:
	# Look for the stiff loops.
	if (matrix_e.data[c1][c1]/matrix_a.data[c1][c1])<0.1*dt:
	for c2 in range(matrix_a.columns):
	# Remove all elements in E.
	# No d/dt terms.
	matrix_e.data[c1][c2]=0.0
	# Due to the row operations, to connect
	# the stiff branch to an input source,
	# Some off diagonal terms may contain
	# resitances. These will be part of the
	# total resistance between the branch and
	# the source.
	# So add all the offdiagonal elements
	# in the stiff loop row to the diagonal
	# element. And then set them to zero to
	# remove interactions with other loops.
	if not c1==c2:
	matrix_a.data[c1][c1]+=matrix_a.data[c1][c2]
	matrix_a.data[c1][c2]=0.0
	# The stiff loop would originally have been
	# interacting with other loops. After the row
	# operations, the stiff elements would have
	# disappeared from the other loops. But there
	# may still be some interaction elements
	# remaining in the off diagonal terms.
	# My assumption is to isolate the stiff loop.
	# But the interaction with other loops which
	# will be non zero elements in the same column
	# as the stiff diagonal element will need to be
	# translated into interation between non-stiff
	# loops. In simple terms, if X and Y are related
	# to Z, then they are also related to each other.
	# Make a list of all the rows that have non
	# zero elements in the same column as the stiff
	# loop.
	interac_stiff=[]
	for c2 in range(matrix_a.rows):
	if not c2==c1:
	if matrix_a.data[c2][c1]:
	interac_stiff.append(c2)
	# The interaction between the non stiff loops is
	# as follows.
	# If X is aiding Z and Y is also aiding Z,
	# X and Y are aiding each other.
	# If X is opposing Z and Y is aiding Z,
	# X and Y are opposing each other.
	if len(interac_stiff)>1:
	for c2 in range(len(interac_stiff)-1):
	elem1=matrix_a.data[interac_stiff[c2]][c1]
	elem2=matrix_a.data[interac_stiff[c2+1]][c1]
	if (elem1>0 and elem2>0):
	comm_elem=elem1
	if (elem1<0 and elem2<0):
	comm_elem=-elem1
	if (elem1>0 and elem2<0):
	comm_elem=-elem1
	if (elem1<0 and elem2>0):
	comm_elem=elem1
	matrix_a.data[interac_stiff[c2]][interac_stiff[c2+1]]=comm_elem
	matrix_a.data[interac_stiff[c2+1]][interac_stiff[c2]]=comm_elem
	matrix_a.data[interac_stiff[c2]][interac_stiff[c2]]+=abs(comm_elem)
	matrix_a.data[interac_stiff[c2+1]][interac_stiff[c2+1]]+=abs(comm_elem)

view raw matrix_re.py hosted with ❤ by GitHub

This was actually a bit tricky. The first part is the stiff equation must be connected to an input source because interactions with all other loops has been eliminated. To eliminate the interaction with other loops, the off diagonal elements in matrix A are set to zero in the stiff loop.

Then check if any of the elements in the row of matrix B is nonzero. If yes, leave it as it is. If not, add the stiff loop with another nonstiff loop that is connected to the input. This will cause one of the elements of B matrix in the stiff row as non zero. At the same time, some of the off diagonal elements in the stiff row will now be nonzero as these are the resistances in the nonstiff loop with which the addition occurred. These resistances are essentially the resistances between the source and the stiff branch. So add all those to the diagonal element in A and then get rid of them. So now the diagonal element of A contains the entire resistance as a loop between the source and the stiff branch and is also linked to the source. So the stiff dynamical equation has been approximated to a static isolated equation.

Next, remove all the elements in matrix E - eliminating all d/dt terms and making it a static equation. The last part is to account for the interaction elements that still linger between the stiff loops and non stiff loops. So if Z is the stiff loop and X and Y are nonstiff loops that interact with Z in that they have nonzero elements in the same column as Z, this means that X and Y will interact with each other. This interaction needs to be captured as we want to isolated loop Z. So look for the elements and move them to the offdiagonal entries between X and Y with the appropriate sign.

Circuit Solver - VII

I think the problem has been solved. Updated the latest code on my Source Forge site:
https://sourceforge.net/projects/pythonpowerelec/files/

Need to close my eyes now. So details tomorrow.

Circuit Solver - VI

Last post had a mistake in the logic.

By performing row operations, the solution set does not change. Also, the way the ammeter currents are calculated is dependent on the loops. And the loops are described in system_loops and have not changed.

So essentially, the current through the large resistor will be a sum of loops i1, i3 and i4. And the accuracy of this will depend on the simulation time step. Which is why it is wrong. Currently, the current through the large resistor has a peak of 0.04Amps whereas it should be in microAmps.

So now what? This means any change I make to the resistors has to be reflected back to the system_loops. And finally, when the component currents are calculated they have to know that the system has been approximated. This is going to take some time.

Circuit Solver - V

A little progress. At least the ODE is solvable now. I used the strategy of row operations to get rid of the elements with low (or zero) time constants from as many rows as possible. This is the code (click on "view raw" below the code box to see it in a new window):

	# Getting rid of elements with small time constants
	# that appear multiple times in a circuit.
	for c1 in range(matrix_a.rows):
	for c2 in range(c1+1, matrix_a.columns):
	if matrix_a.data[c1][c2]:
	# Check is an off-diagonal element has a
	# small L/R ratio.
	if (matrix_e.data[c1][c2]/matrix_a.data[c1][c2])<0.1*dt:
	# Check if the diagonal element is row c1 has
	# smaller L/R than diagonal element in row c2
	# The idea is to arrange the equations as per
	# time constants. So manipulate the larger time
	# constants with respect to the smaller time constants
	# and ignore the ones that are below a threshold.
	if (matrix_e.data[c1][c1]/matrix_a.data[c1][c1])<(matrix_e.data[c2][c2]/matrix_a.data[c2][c2]):
	for c3 in range(matrix_a.columns):
	matrix_a.data[c2][c3]-=matrix_a.data[c1][c3]
	matrix_e.data[c2][c3]-=matrix_e.data[c1][c3]
	for c3 in range(matrix_b.columns):
	matrix_b.data[c2][c3]-=matrix_b.data[c1][c3]
	else:
	for c3 in range(matrix_a.columns):
	matrix_a.data[c1][c3]-=matrix_a.data[c2][c3]
	matrix_e.data[c1][c3]-=matrix_e.data[c2][c3]
	for c3 in range(matrix_b.columns):
	matrix_b.data[c1][c3]-=matrix_b.data[c2][c3]
	# Getting rid of the time constants that
	# are too small for the simulation time
	# step. Can generate a warning in a log report.
	for c1 in range(matrix_e.rows):
	if matrix_a.data[c1][c1]:
	if (matrix_e.data[c1][c1]/matrix_a.data[c1][c1])<0.1*dt:
	if matrix_e.data[c1][c1]:
	for c2 in range(matrix_a.columns):
	matrix_a.data[c1][c2]=matrix_a.data[c1][c2]/matrix_e.data[c1][c1]
	for c2 in range(matrix_b.columns):
	matrix_b.data[c1][c2]=matrix_b.data[c1][c2]/matrix_e.data[c1][c1]
	matrix_e.data[c1][c1]=0.0

view raw stiff_solver1.py hosted with ❤ by GitHub

So for a circuit:

The matrices are transformed as follows:

Original matrices are:
------------------------------------------------------------------------------------------------------------------
e=
0.0  0.0  0.0  0.0
0.0  0.2  0.0  0.1
0.0  0.0  0.0001  0.0001
0.0  0.1  0.0001  0.2001

a=
10000000.0  0.0  10000000.0  10000000.0
0.0  20.0  0.0  10.0
10000000.0  0.0  10000010.1  10000000.1
10000000.0  10.0  10000000.1  10000020.1

b=
1.0
0.0
0.0
0.0
------------------------------------------------------------------------------------------------------------------

These are manipulated to:
------------------------------------------------------------------------------------------------------------------
e=
0.0  0.0  0.0  0.0
0.0  0.2  0.0  0.1
0.0  0.0  0.0001  0.0001
0.0  0.1  0.0001  0.2001

a=
10000000.0  0.0  10000000.0  10000000.0
0.0  20.0  0.0  10.0
0.0  0.0  10.0999999996  0.0999999996275
0.0  10.0  0.0999999996275  20.0999999996

b=
1.0
0.0
-1.0
-1.0
------------------------------------------------------------------------------------------------------------------

With this the ODE solves with a time step of 10.0e-6 seconds. However, the stiff equation still is not solved satifsfactorily because of the entire row of large resistances. The way, loop current i1 would be calculated would be:

i1=(-10000000.0*i3-10000000.0*i4)/10000000.0

This would cause i1 to be of the same order as the other loop currents as this reduces to:

i1=-i3-i4

Which is wrong.

So this makes me wonder, why are the off-diagonal terms present in that case? Why not just do:

i1=u/10000000.0

Seems like that might be the solution. Because all I need is the sum total of all the resistance between the input signal in the loop to give me the approximate current. But this is then eventually ONLY the approximate current.

Circuit Solver - IV

Spent the weekend reading on different integration techniques and got only more confused.

So need to investigate a little more. Take the simple circuit below:

These are the parameters and the loops found:
--------------------------------------------------------------------------------------------------------------------
Resistor is  R4 = 10.000000  located at  9I
Inductor is  L4 =0.100000  located at  9K
Ammeter is  A5  located at  9J  with positive polarity towards 9K
Ammeter is  A2  located at  3H  with positive polarity towards 4H
Resistor is  R3 = 10.000000  located at  6I
Ammeter is  A4  located at  6J  with positive polarity towards 6K
Inductor is  L3 =0.100000  located at  6K
Ammeter is  A1  located at  1B  with positive polarity towards 1C
Resistor is  R1 = 0.100000  located at  1E
Resistor is  C1 = 10.000000  located at  4H
Inductor is  L1 =0.000100  located at  1F
Resistor is  R2 = 10.000000  located at  1I
Inductor is  L2 =0.100000  located at  1K
Ammeter is  A3  located at  1J  with positive polarity towards 1K
Resistor is  V1 = 100000.000000  located at  4D
Voltage Source is  V1 of 120.000000 V(peak), 60.000000 Hz(frequency) and 0.000000 (degrees phase shift)  located at  4A  with positive polarity towards 3A
**************************************************
Number of nodes 5
Number of branches 8
Number of loops 4
**************************************************
1D 2D 3D 4D 5D 6D 6C 6B 6A 5A 4A 3A 2A 1A 1B 1C 1D
6H 7H 8H 9H 9I 9J 9K 9L 8L 7L 6L 6K 6J 6I 6H
1H 1G 1F 1E 1D 2D 3D 4D 5D 6D 6E 6F 6G 6H 5H 4H 3H 2H 1H
1H 1G 1F 1E 1D 2D 3D 4D 5D 6D 6E 6F 6G 6H 7H 8H 9H 9I 9J 9K 9L 8L 7L 6L 5L 4L 3L 2L 1L 1K 1J 1I 1H
**************************************************
--------------------------------------------------------------------------------------------------------------------

Which is correct. However, these are the system matrices that result:
--------------------------------------------------------------------------------------------------------------------
a=
100000.0  0.0  100000.0  100000.0
0.0  20.0  0.0  10.0
100000.0  0.0  100010.1  100000.1
100000.0  10.0  100000.1  100020.1

e=
0.0  0.0  0.0  0.0
0.0  0.2  0.0  0.1
0.0  0.0  0.0001  0.0001
0.0  0.1  0.0001  0.2001

b=
1.0
0.0
0.0
0.0
--------------------------------------------------------------------------------------------------------------------

I chose resistor V1 as a large resistor. And that has caused all the problems. It appears in three out of four loops. And the entire ODE becomes stiff. One glaring element is in row 4, column 2 of matrix a. This is 10.0 while all other elements are 100000 or greater. This can be one way of reducing the system.

The resistor V1 should appear in at least one loop. Suppose it appears in a loop and we neglect the dynamics of that loop and consider a static equation. This may be OK because if you have a ridiculously low time constant, why solve it unless you want to. So can we reduce the time constants of the other equations to values that we can integrate peacefully? In the above example, resistor V1 appears quite conveniently in a static equation. So we can get rid of it from the other equations.

Performing row operations:

R3=R3-R1
R4=R4-R1

will get rid of these small time constants.

So this makes we wonder, if I need to do a preprocessing to isolate the time constants as far as possible. And if that needs to be done, what should be logic?

Circuit Solver - III

With the SourceForge (SF from now on) project up and going, I will dedicate this blog to description rather than posting code.

One major issue. Choosing the simulation time step. The simulation time step can be chosen larger for speed but choosing a time step too large will result in instability. The concept is as follows.

Each loop has a time constant that is set by the ratio of total inductance to total resistance (L/R) in the loop. In order to simulate the system accurately, you need to choose a time step that is smaller than the smaller L/R ratio in the system. This has the potential of creating a few problems because if you choose a small parasitic inductance in series and a large resistance in parallel, a loop containing these will have a ridiculously low time constants that will need a simulation time step of nanoseconds.

So this means, maybe I need to choose the loops with the largest inductances instead. Or inform the user that the lowest time constant is "x" and a decent value of simulation time step is "y".

Circuit Solver - II

Since the number of programs is increasing and will continue to do so, I guess it is time to create a SourceForge project. Here is the link:
http://sourceforge.net/projects/pythonpowerelec/?source=directory
The programs can be found in the "Files" section.

I will keep posting program updates on the blog anyway.

Circuit Solver

I finally got a basic circuit solver going! What has been done so far:

1. Only voltage source, resistor and inductor have been included. Capacitor has not yet been tested.
2. Ammeters can be introduced in the circuit wherever needed.

So here is the code (click "view raw" below the code box to see the code in a new window):

	#! /usr/bin/env python
	import sys, math, matrix
	from network_reader import *
	from solver import *
	def csv_tuple(csv_elem):
	""" Convert a cell position from spreadsheet form
	to [row, tuple] form. """
	csv_elem.upper()
	# Create a dictionary of alphabets
	csv_col="A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
	csv_dict={}
	csv_col_list=csv_col.split(" ")
	# Make the alphabets correspond to integers
	for c1 in range(1, 27):
	csv_dict[csv_col_list[c1-1]]=c1
	# The cell position starts with a number
	flag="number"
	c1=0
	while flag=="number":
	# When conversion to int fails
	# it means the element is an alphabet
	try:
	int(csv_elem[c1])
	except ValueError:
	flag="alphabet"
	else:
	c1+=1
	# Split them up into numbers and alphabets
	pol_row=int(csv_elem[0:c1])
	pol_col=csv_elem[c1:]
	elem_tuple=[pol_row-1, 0]
	# Convert the alphabets to number
	# Similar to converting binary to decimal
	for c1 in range(len(pol_col)-1, -1, -1):
	if len(pol_col)-1-c1>0:
	elem_tuple[1]+=26*(len(pol_col)-1-c1)*csv_dict[pol_col[c1]]
	else:
	elem_tuple[1]+=csv_dict[pol_col[c1]]-1
	return elem_tuple
	def reading_params(param_file):
	""" Read a file. Ramove additional quotes and
	carriage returns. Remove leading spaces. """
	from_file=[]
	for line in param_file:
	from_file.append(line.split(","))
	for c1 in range(len(from_file)):
	for c2 in range(len(from_file[c1])-1, -1, -1):
	# Remove additional quotes and carriage returns
	if from_file[c1][c2]:
	scrub_elements(from_file, c1, c2)
	# Remove blank spaces and null elements
	if from_file[c1][c2]==" " or from_file[c1][c2]=="":
	del from_file[c1][c2]
	return from_file
	class Resistor:
	def __init__(self, res_index, res_pos, res_tag):
	self.res_number=res_index
	self.res_pos=res_pos
	self.res_tag=res_tag
	self.resistor=100.0
	self.current=0.0
	self.voltage=0.0
	def display(self):
	print "Resistor is ",
	print self.res_tag,
	print "= %f" %self.resistor,
	print " located at ",
	print self.res_pos
	def ask_values(self, x_list, ckt_mat):
	res_params=["Resistor"]
	res_params.append(self.res_tag)
	res_params.append(self.res_pos)
	res_params.append(self.resistor)
	x_list.append(res_params)
	def get_values(self, x_list, ckt_mat):
	self.resistor=float(x_list[0])
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix A in E.dx/dt=Ax+Bu will be updated by the
	resistor value."""
	for c1 in range(len(sys_loops)):
	for c2 in range(c1, len(sys_loops)):
	# Updating the diagonal element corresponding
	# to a loop.
	if c1==c2:
	if csv_tuple(self.res_pos) in sys_loops[c1][c2]:
	mat_a.data[c1][c2]+=self.resistor
	else:
	# Updating the offdiagonal element depending
	# on the sense of the loops (aiding or opposing)
	for c3 in range(len(sys_loops[c1][c2])):
	if csv_tuple(self.res_pos) in sys_loops[c1][c2][c3]:
	if sys_loops[c1][c2][c3][-1]=="forward":
	mat_a.data[c1][c2]+=self.resistor
	else:
	mat_a.data[c1][c2]-=self.resistor
	# Because the matrices are symmetric
	mat_a.data[c2][c1]=mat_a.data[c1][c2]
	return
	def generate_val(self, source_lst, sys_loops, mat_u, t, dt):
	pass
	def update_val(self, sys_loops, mat_e, mat_a, mat_b, state_vec, mat_u):
	pass
	class Inductor:
	def __init__(self, ind_index, ind_pos, ind_tag):
	self.ind_number=ind_index
	self.ind_pos=ind_pos
	self.ind_tag=ind_tag
	self.inductor=0.001
	self.current=0.0
	self.i_dbydt=0.0
	self.voltage=0.0
	def display(self):
	print "Inductor is ",
	print self.ind_tag,
	print "=%f" %self.inductor,
	print " located at ",
	print self.ind_pos
	def ask_values(self, x_list, ckt_mat):
	ind_params=["Inductor"]
	ind_params.append(self.ind_tag)
	ind_params.append(self.ind_pos)
	ind_params.append(self.inductor)
	x_list.append(ind_params)
	def get_values(self, x_list, ckt_mat):
	self.inductor=float(x_list[0])
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix E in E.dx/dt=Ax+Bu will be updated by the
	inductor value."""
	for c1 in range(len(sys_loops)):
	for c2 in range(c1, len(sys_loops)):
	# Updating the diagonal element corresponding
	# to a loop.
	if c1==c2:
	if csv_tuple(self.ind_pos) in sys_loops[c1][c2]:
	mat_e.data[c1][c2]+=self.inductor
	else:
	# Updating the offdiagonal element depending
	# on the sense of the loops (aiding or opposing)
	for c3 in range(len(sys_loops[c1][c2])):
	if csv_tuple(self.ind_pos) in sys_loops[c1][c2][c3]:
	if sys_loops[c1][c2][c3][-1]=="forward":
	mat_e.data[c1][c2]+=self.inductor
	else:
	mat_e.data[c1][c2]-=self.inductor
	# Because the matrices are symmetric
	mat_e.data[c2][c1]=mat_e.data[c1][c2]
	return
	def generate_val(self, source_lst, sys_loops, mat_u, t, dt):
	pass
	def update_val(self, sys_loops, mat_e, mat_a, mat_b, state_vec, mat_u):
	pass
	class Capacitor:
	def __init__(self, cap_index, cap_pos, cap_tag):
	self.cap_number=cap_index
	self.cap_pos=cap_pos
	self.cap_tag=cap_tag
	self.capacitor=10.0e-6
	self.current=0.0
	self.voltage=0.0
	self.v_dbydt=0.0
	def display(self):
	print "Capacitor is ",
	print self.cap_tag,
	print "= %f" %self.capacitor,
	print " located at ",
	print self.cap_pos,
	print " with positive polarity towards %s" %(csv_element(self.cap_polrty))
	def ask_values(self, x_list, ckt_mat):
	cap_params=["Capacitor"]
	cap_params.append(self.cap_tag)
	cap_params.append(self.cap_pos)
	cap_params.append(self.capacitor)
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.cap_elem=csv_tuple(self.cap_pos)
	if self.cap_elem[0]>0:
	if ckt_mat[self.cap_elem[0]-1][self.cap_elem[1]]:
	self.cap_polrty=[self.cap_elem[0]-1, self.cap_elem[1]]
	if self.cap_elem[1]>0:
	if ckt_mat[self.cap_elem[0]][self.cap_elem[1]-1]:
	self.cap_polrty=[self.cap_elem[0], self.cap_elem[1]-1]
	if self.cap_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.cap_elem[0]+1][self.cap_elem[1]]:
	self.cap_polrty=[self.cap_elem[0]+1, self.cap_elem[1]]
	if self.cap_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.cap_elem[0]][self.cap_elem[1]+1]:
	self.cap_polrty=[self.cap_elem[0], self.cap_elem[1]+1]
	cap_params.append("Positive polarity towards (cell) = %s" %csv_element(self.cap_polrty))
	x_list.append(cap_params)
	def get_values(self, x_list, ckt_mat):
	self.capacitor=float(x_list[0])
	cap_polrty=x_list[1].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while cap_polrty[0]==" ":
	cap_polrty=cap_polrty[1:]
	self.cap_polrty=csv_tuple(cap_polrty)
	if not ckt_mat[self.cap_polrty[0]][self.cap_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.cap_polrty)
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix B in E.dx/dt=Ax+Bu will be updated by the
	polarity of the capacitor."""
	for c1 in range(len(sys_loops)):
	if csv_tuple(self.cap_pos) in sys_loops[c1][c1]:
	# If the positive polarity appears before the capacitor position
	# it means as per KVL, we are moving from +ve to -ve
	# and so the capacitor voltage will be taken negative
	if sys_loops[c1][c1].index(self.cap_polrty)<sys_loops[c1][c1].index(csv_tuple(self.cap_pos)):
	mat_b.data[c1][source_list.index(self.cap_pos)]=-1.0
	else:
	mat_b.data[c1][source_list.index(self.cap_pos)]=1.0
	return
	def generate_val(self, source_lst, sys_loops, mat_u, t, dt):
	""" The capacitor voltage is updated in the matrix u in
	E.dx/dt=Ax+Bu ."""
	self.v_dbydt=self.current/self.capacitor
	self.voltage+=self.v_dbydt*dt
	mat_u.data[source_lst.index(self.cap_pos)][0]=self.voltage
	def update_val(self, sys_loops, mat_e, mat_a, mat_b, state_vec, mat_u):
	""" The capacitor current is calculated as a result of the KVL."""
	c1=0
	while c1<len(sys_loops):
	# The first occurance of the capacitor
	if csv_tuple(self.cap_pos) in sys_loops[c1][c1]:
	# Check for polarity. If positive polarity is before the capacitor
	# it means the current is entering the positive terminal and so
	# current is positive.
	if sys_loops[c1][c1].index(self.cap_polrty)<sys_loops[c1][c1].index(csv_tuple(self.cap_pos)):
	self.current=state_vec.data[c1][0]
	else:
	self.current=-state_vec.data[c1][0]
	# Check for capacitor in other loops with the capacitor
	# as common branch
	for c2 in range(c1+1, len(sys_loops)):
	# These lists are nested lists as two loops
	# may have separate branches in common
	for c3 in range(len(sys_loops[c1][c2])):
	# If capacitor is found in one of the branches.
	# Can only be in one branch at most.
	if csv_tuple(self.cap_pos) in sys_loops[c1][c2][c3]:
	# Check for polarity again
	if sys_loops[c1][c2][c3].index(self.cap_polrty)<sys_loops[c1][c2][c3].index(csv_tuple(self.cap_pos)):
	# Then check is the loop is aiding or opposing
	# the main loop.
	if sys_loops[c1][c2][c3][-1]=="forward":
	self.current+=state_vec.data[c2][0]
	else:
	self.current-=state_vec.data[c2][0]
	else:
	if sys_loops[c1][c2][c3][-1]=="forward":
	self.current-=state_vec.data[c2][0]
	else:
	self.current+=state_vec.data[c2][0]
	# This is to jump out of the while
	# because looking along a row of the
	# time capacitor is found is enough.
	c1=len(sys_loops)
	# Increment the counter if capacitor
	# is not found.
	c1+=1
	class Voltage_Source:
	def __init__(self, volt_index, volt_pos, volt_tag):
	self.volt_number=volt_index
	self.volt_pos=volt_pos
	self.volt_tag=volt_tag
	self.v_peak=120.0
	self.v_freq=60.0
	self.v_phase=0.0
	self.voltage=0.0
	self.current=0.0
	self.op_value=0.0
	self.v_polrty=[-1, -1]
	def display(self):
	print "Voltage Source is ",
	print self.volt_tag,
	print "of %f V(peak), %f Hz(frequency) and %f (degrees phase shift)" %(self.v_peak, self.v_freq, self.v_phase),
	print " located at ",
	print self.volt_pos,
	print " with positive polarity towards %s" %(csv_element(self.v_polrty))
	def ask_values(self, x_list, ckt_mat):
	volt_params=["VoltageSource"]
	volt_params.append(self.volt_tag)
	volt_params.append(self.volt_pos)
	volt_params.append("Peak (Volts) = %f" %self.v_peak)
	volt_params.append("Frequency (Hertz) = %f" %self.v_freq)
	volt_params.append("Phase (degrees) = %f" %self.v_phase)
	if self.v_polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.volt_elem=csv_tuple(self.volt_pos)
	if self.volt_elem[0]>0:
	if ckt_mat[self.volt_elem[0]-1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]-1, self.volt_elem[1]]
	if self.volt_elem[1]>0:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]-1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]-1]
	if self.volt_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]+1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]+1, self.volt_elem[1]]
	if self.volt_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]+1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]+1]
	volt_params.append("Positive polarity towards (cell) = %s" %csv_element(self.v_polrty))
	x_list.append(volt_params)
	def get_values(self, x_list, ckt_mat):
	self.v_peak=float(x_list[0].split("=")[1])
	self.v_freq=float(x_list[1].split("=")[1])
	self.v_phase=float(x_list[2].split("=")[1])
	volt_polrty=x_list[3].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while volt_polrty[0]==" ":
	volt_polrty=volt_polrty[1:]
	self.v_polrty=csv_tuple(volt_polrty)
	if not ckt_mat[self.v_polrty[0]][self.v_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.v_polrty)
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	""" The matrix B in E.dx/dt=Ax+Bu will be updated by the
	polarity of the voltage source."""
	for c1 in range(len(sys_loops)):
	if csv_tuple(self.volt_pos) in sys_loops[c1][c1]:
	# If the positive polarity appears before the voltage position
	# it means as per KVL, we are moving from +ve to -ve
	# and so the voltage will be taken negative
	if sys_loops[c1][c1].index(self.v_polrty)<sys_loops[c1][c1].index(csv_tuple(self.volt_pos)):
	mat_b.data[c1][source_list.index(self.volt_pos)]=-1.0
	else:
	mat_b.data[c1][source_list.index(self.volt_pos)]=1.0
	return
	def generate_val(self, source_lst, sys_loops, mat_u, t, dt):
	""" The source voltage is updated in the matrix u in
	E.dx/dt=Ax+Bu ."""
	self.voltage=self.v_peak*math.sin(2*math.pi*self.v_freq*t+self.v_phase)
	mat_u.data[source_lst.index(self.volt_pos)][0]=self.voltage
	self.op_value=self.voltage
	def update_val(self, sys_loops, mat_e, mat_a, mat_b, state_vec, mat_u):
	pass
	class Ammeter:
	def __init__(self, amm_index, amm_pos, amm_tag):
	self.amm_number=amm_index
	self.amm_pos=amm_pos
	self.amm_tag=amm_tag
	self.current=0.0
	self.op_value=0.0
	self.amm_polrty=[-1, -1]
	def display(self):
	print "Ammeter is ",
	print self.amm_tag,
	print " located at ",
	print self.amm_pos,
	print " with positive polarity towards %s" %(csv_element(self.amm_polrty))
	def ask_values(self, x_list, ckt_mat):
	amm_params=["Ammeter"]
	amm_params.append(self.amm_tag)
	amm_params.append(self.amm_pos)
	if self.amm_polrty==[-1, -1]:
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.amm_elem=csv_tuple(self.amm_pos)
	if self.amm_elem[0]>0:
	if ckt_mat[self.amm_elem[0]-1][self.amm_elem[1]]:
	self.amm_polrty=[self.amm_elem[0]-1, self.amm_elem[1]]
	if self.amm_elem[1]>0:
	if ckt_mat[self.amm_elem[0]][self.amm_elem[1]-1]:
	self.amm_polrty=[self.amm_elem[0], self.amm_elem[1]-1]
	if self.amm_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.amm_elem[0]+1][self.amm_elem[1]]:
	self.amm_polrty=[self.amm_elem[0]+1, self.amm_elem[1]]
	if self.amm_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.amm_elem[0]][self.amm_elem[1]+1]:
	self.amm_polrty=[self.amm_elem[0], self.amm_elem[1]+1]
	amm_params.append("Positive polarity towards (cell) = %s" %csv_element(self.amm_polrty))
	x_list.append(amm_params)
	def get_values(self, x_list, ckt_mat):
	amm_polrty=x_list[0].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while amm_polrty[0]==" ":
	amm_polrty=amm_polrty[1:]
	self.amm_polrty=csv_tuple(amm_polrty)
	if not ckt_mat[self.amm_polrty[0]][self.amm_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.amm_polrty)
	def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list):
	pass
	def generate_val(self, source_lst, sys_loops, mat_u, t, dt):
	pass
	def update_val(self, sys_loops, mat_e, mat_a, mat_b, state_vec, mat_u):
	""" The ammeter current is calculated as a result of the KVL."""
	c1=0
	while c1<len(sys_loops):
	# The first occurance of the ammeter
	if csv_tuple(self.amm_pos) in sys_loops[c1][c1]:
	# Check for polarity. If positive polarity is after the ammeter
	# it means the current is in the direction of ammeter current and so
	# current is positive.
	if sys_loops[c1][c1].index(self.amm_polrty)>sys_loops[c1][c1].index(csv_tuple(self.amm_pos)):
	self.current=state_vec.data[c1][0]
	else:
	self.current=-state_vec.data[c1][0]
	# Check for ammeter in other loops with the ammeter
	# as common branch
	for c2 in range(c1+1, len(sys_loops)):
	# These lists are nested lists as two loops
	# may have separate branches in common
	for c3 in range(len(sys_loops[c1][c2])):
	if csv_tuple(self.amm_pos) in sys_loops[c1][c2][c3]:
	# Check for polarity again
	if sys_loops[c1][c2][c3].index(self.amm_polrty)>sys_loops[c1][c2][c3].index(csv_tuple(self.amm_pos)):
	# Then check is the loop is aiding or opposing
	# the main loop.
	if sys_loops[c1][c2][c3][-1]=="forward":
	self.current+=state_vec.data[c2][0]
	else:
	self.current-=state_vec.data[c2][0]
	else:
	if sys_loops[c1][c2][c3][-1]=="forward":
	self.current-=state_vec.data[c2][0]
	else:
	self.current+=state_vec.data[c2][0]
	# This is to jump out of the while
	# because looking along a row of the
	# time ammeter is found is enough.
	c1=len(sys_loops)
	# Increment the counter if ammeter
	# is not found.
	c1+=1
	# Since it is a meter, this is its output value
	self.op_value=self.current
	component_list={"resistor":Resistor, "inductor":Inductor, "capacitor":Capacitor, "voltagesource":Voltage_Source, "ammeter":Ammeter}
	nw_input=raw_input("CSV file containing the network layout --> ")
	nw_layout=nw_input+".csv"
	test_ckt=open(nw_layout,"r")
	# Read the circuit into tst_mat
	# Also performs a scrubbing of tst_mat
	tst_mat=csv_reader(test_ckt)
	components_found={}
	for c1 in range(len(tst_mat)):
	for c2 in range(len(tst_mat[0])):
	elem=tst_mat[c1][c2]
	if elem:
	# wire is a zero resistance connection
	if elem.lower()!="wire":
	if len(elem.split("_"))==1:
	jump_det=elem.split("_")[0]
	if len(jump_det)>3:
	if jump_det.lower()[0:4]=="jump":
	pass
	else:
	print "Error! Component at %s does not have a unique name/tag." %csv_element([c1, c2])
	else:
	print "Error! Component at %s does not have a unique name/tag." %csv_element([c1, c2])
	else:
	[elem_name, elem_tag]=elem.split("_")
	elem_type=elem_name.lower()
	if elem_type[0]==" ":
	elem_type=elem_type[1:]
	if elem_tag[0]==" ":
	elem_tag=elem_tag[1:]
	# Check if component exists
	if elem_type in component_list.keys():
	# If found for the first time
	# Create that dictionary element with key
	# as component type
	if elem_type not in components_found:
	components_found[elem_type]=[[csv_element([c1, c2]), elem_tag]]
	else:
	# If already found, append it to
	# dictionary item with that key.
	components_found[elem_type].append([csv_element([c1, c2]), elem_tag])
	else:
	print "Error! Component at %s doesn't exist." %csv_element([c1, c2])
	# Check if a component of the same type has the same tag.
	for items in components_found.keys():
	for c1 in range(len(components_found[items])):
	for c2 in range(len(components_found[items])):
	if c1!=c2:
	if components_found[items][c1][1]==components_found[items][c2][1]:
	print "Duplicate labels found for components of type %s at %s and %s" %(items, components_found[items][c1][0], components_found[items][c2][0])
	component_objects={}
	for items in components_found.keys():
	# Take every type of component found
	# item -> resistor, inductor etc
	for c1 in range(len(components_found[items])):
	# Each component type will be occurring
	# multiple times. Iterate through every find.
	# The list corresponding to each component is
	# the unique cell position in the spreadsheet
	component_objects[components_found[items][c1][0]] = \
	component_list[items](c1+1, components_found[items][c1][0], components_found[items][c1][1])
	parameters_file=nw_input+"_params.csv"
	# Check if the *_params.csv file exists.
	try:
	csv_check_values=open(parameters_file,"r")
	# If not, it has to be created and filled
	# with default values.
	except:
	#param_flag="no"
	pass
	# Check if any of the components with the same
	# tags are present in nw_params.csv. If so, take
	# those parameters from nw_params.csv and replace
	# the default parameters in the component objects.
	else:
	params_from_file=reading_params(csv_check_values)
	for c1 in range(len(params_from_file)):
	# Remove leading spaces if any
	# The first column is the type of element
	if params_from_file[c1][0][0]==" ":
	params_from_file[c1][0]=params_from_file[c1][0][1:]
	name_from_file=params_from_file[c1][0].lower()
	# Check if the component type
	# exists in the new circuit
	try:
	components_found[name_from_file]
	except:
	# If the component doesn't exist, just don't
	# try to read the parameters.
	pass
	else:
	# If it exists, check for the tag.
	for c2 in range(len(components_found[name_from_file])):
	# Remove leading spaces if any
	if params_from_file[c1][1][0]==" ":
	params_from_file[c1][1]=params_from_file[c1][1][1:]
	# Check if the component tag exists in
	# components found so far
	if params_from_file[c1][1]==components_found[name_from_file][c2][1]:
	# If so take the parameters and move them into the object
	# having of that type and having the new cell position
	component_objects[components_found[name_from_file][c2][0]].get_values(params_from_file[c1][3:], tst_mat)
	csv_check_values.close()
	values_to_file=[]
	for items in component_objects.keys():
	# Each component object has a method
	# ask_values that prints in the csv file
	# default values for parameters.
	component_objects[items].ask_values(values_to_file, tst_mat)
	csv_ask_values=open(parameters_file,"w")
	for c1 in range(len(values_to_file)):
	for c2 in range(len(values_to_file[c1])):
	csv_ask_values.write("%s" %values_to_file[c1][c2])
	csv_ask_values.write(", ")
	csv_ask_values.write("\n")
	csv_ask_values.close()
	# Wait for the user to enter parameters before
	# reading the nw_params.csv file.
	cont_ans="n"
	while cont_ans.lower()!="y":
	cont_ans=raw_input("Enter parameters in file %s. When ready press y and enter to continue -> " %parameters_file)
	print
	csv_get_values=open(parameters_file,"r")
	params_from_file=reading_params(csv_get_values)
	csv_get_values.close()
	for c1 in range(len(params_from_file)):
	# Getting rid of the beginning spaces
	# in the component keys
	if params_from_file[c1][2][0]==" ":
	params_from_file[c1][2]=params_from_file[c1][2][1:]
	component_objects[params_from_file[c1][2]].get_values(params_from_file[c1][3:], tst_mat)
	# Just checking the objects
	for items in component_objects.keys():
	component_objects[items].display()
	node_list, branch_map, loop_list, loop_branches, conn_matrix, \
	[number_of_nodes, number_of_branches, loop_count] = network_solver(nw_layout)
	loop_count=len(loop_branches)
	print "*"*50
	print "Number of nodes",
	print number_of_nodes
	print "Number of branches",
	print number_of_branches
	print "Number of loops",
	print loop_count
	print "*"*50
	def human_loop(loop):
	""" Takes a loop as a list of tupes.
	And prints a series of elements in spreadsheet format. """
	for c1 in range(len(loop)):
	print csv_element(loop[c1]),
	return
	for c1 in range(len(loop_branches)):
	human_loop(loop_branches[c1])
	print
	print "*"*50
	def comm_elem_in_loop(loop1, loop2):
	""" Takes two loops and returns a list
	which has all the elements (tuples) that are
	common between the loops. """
	loop_comm=[]
	# Check every element of loop1
	# w.r.t to every element of loop2
	for c1 in range(len(loop1)):
	for c2 in range(len(loop2)):
	# Check if elements are equal
	if loop1[c1]==loop2[c2]:
	# Check if either of the elements
	# are the last of the loops
	if c1<len(loop1)-1 and c2<len(loop2)-1:
	# Check if they have already been
	# identified as common elements
	if loop1[c1] not in loop_comm:
	loop_comm.append(loop1[c1])
	elif loop2[c2-1]==loop_comm[-1]:
	# This is a special condition.
	# The first and last element of
	# every loop are the same.
	# Therefore, it will fail the condition that
	# the element should not be found before.
	# But, it may be possible that the segment of the
	# loops that is common does not contain the last
	# element. So, the check is:
	# If the latest element to be found is loop2[c2-1]
	# i.e is the second last element of loop2, in that
	# case, the last element i.e loop2[c2] should
	# also be appended to the common segment
	loop_comm.append(loop2[c2])
	return loop_comm
	def comm_branch_in_loop(loop1, loop2):
	""" Takes the common elements (loop1) found between
	two loops (out of which one is loop2) and break these
	elements up into separate branches."""
	# The collection of branches
	loop_comm=[]
	# Each branch
	loop_segment=[]
	# starting element
	prev_elem=loop1[0]
	# Iterate from second to last element
	for c1 in range(1, len(loop1)):
	# Check if the index between this current element
	# and the previous element is less than or equal to 1
	# This means it is a continuation of a branch
	if abs(loop2.index(loop1[c1])-loop2.index(prev_elem))<=1:
	loop_segment.append(prev_elem)
	# If not, it means it is a new branch
	else:
	# Complete the branch with the previous element
	loop_segment.append(prev_elem)
	# If it is the final element of the loop
	# Don't leave it out but add that too
	if c1==len(loop1)-1:
	loop_segment.append(loop1[c1])
	# Add that to the collection of branches
	loop_comm.append(loop_segment)
	loop_segment=[]
	# Refresh the previous element
	prev_elem=loop1[c1]
	# This is a special condition.
	# If there is only one common branch, the main
	# condition will fail because a new branch will not be found
	# In that case, the addition function needs to be repeated.
	if not loop_comm:
	loop_segment.append(prev_elem)
	loop_comm.append(loop_segment)
	return loop_comm
	# A temporary list that stores the nodes
	# common to two loops
	nodes_in_loop=[]
	# A array of all the loops of the system
	# including common branches between loops.
	system_loops=[]
	for c1 in range(loop_count):
	row_vector=[]
	for c2 in range(loop_count):
	row_vector.append([])
	system_loops.append(row_vector)
	for c1 in range(len(loop_branches)):
	# The diagonal elements of system_loops
	# will be the loops themselves.
	for c2 in range(len(loop_branches[c1])):
	system_loops[c1][c1].append(loop_branches[c1][c2])
	# The system_loops array will be symmetric
	for c2 in range(c1+1, len(loop_branches)):
	# Find the nodes in loop1
	for c3 in range(len(node_list)):
	if node_list[c3] in loop_branches[c1]:
	nodes_in_loop.append(node_list[c3])
	# Find out the nodes common to loop1
	# and loop2.
	for c3 in range(len(nodes_in_loop)-1, -1, -1):
	if nodes_in_loop[c3] not in loop_branches[c2]:
	del nodes_in_loop[c3]
	# If there are two or more nodes common
	# between loop1 and loop2, there are
	# common elements.
	if len(nodes_in_loop)>1:
	comm_seg_in_loop=comm_elem_in_loop(loop_branches[c1], loop_branches[c2])
	# The list of common branches between
	# loop c1 and loop c2
	sys_loop_off_diag=comm_branch_in_loop(comm_seg_in_loop, loop_branches[c1])
	for c3 in range(len(sys_loop_off_diag)):
	#for c4 in range(len(sys_loop_off_diag[c3])):
	system_loops[c1][c2].append(sys_loop_off_diag[c3])
	system_loops[c2][c1].append(sys_loop_off_diag[c3])
	# Determining the direction of common
	# branches between loops c1 and c2
	for c3 in range(len(sys_loop_off_diag)):
	st_node=sys_loop_off_diag[c3][0]
	end_node=sys_loop_off_diag[c3][-1]
	# Map the start and end nodes of common
	# branch c3 to loops c1 and c2
	loop1_st_node=loop_branches[c1].index(st_node)
	loop1_end_node=loop_branches[c1].index(end_node)
	loop2_st_node=loop_branches[c2].index(st_node)
	loop2_end_node=loop_branches[c2].index(end_node)
	# This check is because the first node of a
	# loop is the same as the last node.
	# So this is to make sure, the correct start
	# and end nodes are mapped, the difference between
	# the indices is compared to the length of the common
	# branch. If not equal, this means, the last node of
	# a loop needs to be taken instead of the first node.
	if (abs(loop1_end_node-loop1_st_node)!= len(sys_loop_off_diag[c3])):
	if (len(loop_branches[c1])-loop1_st_node==len(sys_loop_off_diag[c3])):
	loop1_end_node=len(loop_branches[c1])-1
	if (len(loop_branches[c1])-loop1_end_node==len(sys_loop_off_diag[c3])):
	loop1_st_node=len(loop_branches[c1])-1
	if (abs(loop2_end_node-loop2_st_node)!= len(sys_loop_off_diag[c3])):
	if (len(loop_branches[c2])-loop2_st_node==len(sys_loop_off_diag[c3])):
	loop2_end_node=len(loop_branches[c2])-1
	if (len(loop_branches[c2])-loop2_end_node==len(sys_loop_off_diag[c3])):
	loop2_st_node=len(loop_branches[c2])-1
	if (loop1_st_node<loop1_end_node):
	loop1_dir="ahead"
	else:
	loop1_dir="back"
	if (loop2_st_node<loop2_end_node):
	loop2_dir="ahead"
	else:
	loop2_dir="back"
	if loop1_dir=="ahead" and loop2_dir=="ahead":
	sys_loop_off_diag[c3].append("forward")
	if loop1_dir=="back" and loop2_dir=="back":
	sys_loop_off_diag[c3].append("forward")
	if loop1_dir=="ahead" and loop2_dir=="back":
	sys_loop_off_diag[c3].append("reverse")
	if loop1_dir=="back" and loop2_dir=="ahead":
	sys_loop_off_diag[c3].append("reverse")
	#print c1, c2
	#human_loop(comm_seg_in_loop)
	#print
	#for item in sys_loop_off_diag:
	#print "[",
	#human_loop(item[:-1]),
	#print item[-1],
	#print "]",
	#print
	nodes_in_loop=[]
	system_size=len(loop_branches)
	sys_mat_a=matrix.Matrix(system_size, system_size)
	sys_mat_e=matrix.Matrix(system_size, system_size)
	curr_state_vec=matrix.Matrix(system_size)
	next_state_vec=matrix.Matrix(system_size)
	source_list=[]
	try:
	components_found["voltagesource"]
	except:
	pass
	else:
	for c1 in range(len(components_found["voltagesource"])):
	source_list.append(components_found["voltagesource"][c1][0])
	try:
	components_found["capacitor"]
	except:
	pass
	else:
	for c1 in range(len(components_found["capacitor"])):
	source_list.append(components_found["capacitor"][c1][0])
	if source_list:
	sys_mat_b=matrix.Matrix(system_size, len(source_list))
	sys_mat_u=matrix.Matrix(len(source_list))
	else:
	sys_mat_b=matrix.Matrix(system_size)
	sys_mat_u=0.0
	meter_list=[]
	try:
	components_found["ammeter"]
	except:
	pass
	else:
	for c1 in range(len(components_found["ammeter"])):
	meter_list.append(components_found["ammeter"][c1][0])
	for comps in components_found.keys():
	for c1 in range(len(components_found[comps])):
	comp_pos=components_found[comps][c1][0]
	component_objects[comp_pos].transfer_to_sys(system_loops, sys_mat_e, sys_mat_a, sys_mat_b, sys_mat_u, source_list)
	##mat_ode_reduce(e, a, b)
	validity_flag="no"
	while validity_flag=="no":
	dt=raw_input("Simulation time step in seconds --> ")
	dt=float(dt)
	if dt>0.0:
	validity_flag="yes"
	else:
	print "Error. Invalid time step."
	validity_flag="no"
	validity_flag="no"
	while validity_flag=="no":
	t_limit=raw_input("Duration of simulation in seconds --> ")
	t_limit=float(t_limit)
	if t_limit>0.0:
	validity_flag="yes"
	else:
	print "Error. Invalid time duration."
	validity_flag="no"
	op_dat_file=raw_input("Output data file name (.dat extension will be added) --> ")
	op_dat_file=op_dat_file+".dat"
	f=open(op_dat_file,"w")
	ode_k1=matrix.Matrix(system_size)
	ode_k2=matrix.Matrix(system_size)
	ode_k3=matrix.Matrix(system_size)
	ode_k4=matrix.Matrix(system_size)
	ode_dbydt=matrix.Matrix(system_size)
	ode_var=[ode_k1, ode_k2, ode_k3, ode_k4, ode_dbydt]
	t=0.0
	while t<t_limit:
	for c1 in range(len(source_list)):
	component_objects[source_list[c1]].generate_val(source_list, system_loops, sys_mat_u, t, dt)
	mat_ode(sys_mat_e, sys_mat_a, sys_mat_b, [curr_state_vec, next_state_vec], sys_mat_u, dt, ode_var)
	for comps in component_objects.keys():
	component_objects[comps].update_val(system_loops, sys_mat_e, sys_mat_a, sys_mat_b, next_state_vec, sys_mat_u)
	curr_state_vec=next_state_vec
	#f.write("%s \t %s \t %s \t %s \n" %(str(t), str(sys_mat_u.data[0][0]), str(next_state_vec.data[0][0]), str(next_state_vec.data[1][0])))
	f.write("%s " %str(t),)
	for c1 in range(len(source_list)):
	f.write("%s " %component_objects[source_list[c1]].op_value,)
	for c1 in range(len(meter_list)):
	f.write("%s " %component_objects[meter_list[c1]].op_value,)
	f.write("\n")
	t=t+dt
	print sys_mat_a
	print sys_mat_e
	print sys_mat_b
	f.close()

view raw circuit_solver.py hosted with ❤ by GitHub

The main comments are:

1. The loop currents are calculated at every simulation time step. Currents in every branch and every element will not be calculated unless necessary. For example, at a later stage, saturation in the inductor or heating in the resistor can be included. So then, current will be calculated and used.

2. If you want to know the currents, you connect an ammeter. Voltmeters need to be coded. Ammeter was simple as I need to manipulate the loop currents. But voltmeters, I need to think how to use them. If I connect a voltmeter across two nodes, it will be seen as a branch. So it will appear in loop equations. This means, to make sure the currents don't change a large resistance will have to be chosen. However, a simpler method will be to look for the voltmeter tag and exclude that branch from the system matrix. I can then back calculate later.

A sample circuit:

Circuit Parameters - VII

A few changes to the code for taking circuit parameters.

1. I forgot completely "jump" labels. They do not need an object, but the code should ignore them while reading the cells or they will generate "Component not found" errors.
2. Take the circuit layour file name as input from the user and generate the parameters files uniquely for the circuit.

The next stage is to generate the loop matrix for the circuit. The loops have been identified. However, every loop will interact with other loops. So, this has been coded.

Next stage is to read the parameters of every component and generate the ODE for solving the circuit KVL laws.

Anyway, here is the code (click on "view raw" below the code box for code in a new window)

	#! /usr/bin/env python
	import sys, math
	from network_reader import *
	def csv_tuple(csv_elem):
	""" Convert a cell position from spreadsheet form
	to [row, tuple] form. """
	csv_elem.upper()
	# Create a dictionary of alphabets
	csv_col="A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
	csv_dict={}
	csv_col_list=csv_col.split(" ")
	# Make the alphabets correspond to integers
	for c1 in range(1, 27):
	csv_dict[csv_col_list[c1-1]]=c1
	# The cell position starts with a number
	flag="number"
	c1=0
	while flag=="number":
	# When conversion to int fails
	# it means the element is an alphabet
	try:
	int(csv_elem[c1])
	except ValueError:
	flag="alphabet"
	else:
	c1+=1
	# Split them up into numbers and alphabets
	pol_row=int(csv_elem[0:c1])
	pol_col=csv_elem[c1:]
	elem_tuple=[pol_row-1, 0]
	# Convert the alphabets to number
	# Similar to converting binary to decimal
	for c1 in range(len(pol_col)-1, -1, -1):
	if len(pol_col)-1-c1>0:
	elem_tuple[1]+=26*(len(pol_col)-1-c1)*csv_dict[pol_col[c1]]
	else:
	elem_tuple[1]+=csv_dict[pol_col[c1]]-1
	return elem_tuple
	def reading_params(param_file):
	""" Read a file. Ramove additional quotes and
	carriage returns. Remove leading spaces. """
	from_file=[]
	for line in param_file:
	from_file.append(line.split(","))
	for c1 in range(len(from_file)):
	for c2 in range(len(from_file[c1])-1, -1, -1):
	# Remove additional quotes and carriage returns
	if from_file[c1][c2]:
	scrub_elements(from_file, c1, c2)
	# Remove blank spaces and null elements
	if from_file[c1][c2]==" " or from_file[c1][c2]=="":
	del from_file[c1][c2]
	return from_file
	class Resistor:
	def __init__(self, res_index, res_pos, res_tag):
	self.res_number=res_index
	self.res_pos=res_pos
	self.res_tag=res_tag
	self.resistor=100.0
	def display(self):
	print "Resistor is ",
	print self.res_tag,
	print "= %f" %self.resistor,
	print " located at ",
	print self.res_pos
	def ask_values(self, x_list, ckt_mat):
	res_params=["Resistor"]
	res_params.append(self.res_tag)
	res_params.append(self.res_pos)
	res_params.append(self.resistor)
	x_list.append(res_params)
	def get_values(self, x_list, ckt_mat):
	self.resistor=float(x_list[0])
	class Inductor:
	def __init__(self, ind_index, ind_pos, ind_tag):
	self.ind_number=ind_index
	self.ind_pos=ind_pos
	self.ind_tag=ind_tag
	self.inductor=0.001
	def display(self):
	print "Inductor is ",
	print self.ind_tag,
	print "=%f" %self.inductor,
	print " located at ",
	print self.ind_pos
	def ask_values(self, x_list, ckt_mat):
	ind_params=["Inductor"]
	ind_params.append(self.ind_tag)
	ind_params.append(self.ind_pos)
	ind_params.append(self.inductor)
	x_list.append(ind_params)
	def get_values(self, x_list, ckt_mat):
	self.inductor=float(x_list[0])
	class Capacitor:
	def __init__(self, cap_index, cap_pos, cap_tag):
	self.cap_number=cap_index
	self.cap_pos=cap_pos
	self.cap_tag=cap_tag
	self.capacitor=10.0e-6
	def display(self):
	print "Capacitor is ",
	print self.cap_tag,
	print "= %f" %self.capacitor,
	print " located at ",
	print self.cap_pos
	def ask_values(self, x_list, ckt_mat):
	cap_params=["Capacitor"]
	cap_params.append(self.cap_tag)
	cap_params.append(self.cap_pos)
	cap_params.append(self.capacitor)
	x_list.append(cap_params)
	def get_values(self, x_list, ckt_mat):
	self.capacitor=float(x_list[0])
	class Voltage_Source:
	def __init__(self, volt_index, volt_pos, volt_tag):
	self.volt_number=volt_index
	self.volt_pos=volt_pos
	self.volt_tag=volt_tag
	self.v_peak=120.0
	self.v_freq=60.0
	self.v_phase=0.0
	def display(self):
	print "Voltage Source is ",
	print self.volt_tag,
	print "of %f V(peak), %f Hz(frequency) and %f (degrees phase shift)" %(self.v_peak, self.v_freq, self.v_phase),
	print " located at ",
	print self.volt_pos,
	print " with positive polarity towards %s %s" %(csv_element(self.v_polrty), self.v_polrty)
	def ask_values(self, x_list, ckt_mat):
	volt_params=["VoltageSource"]
	volt_params.append(self.volt_tag)
	volt_params.append(self.volt_pos)
	volt_params.append("Peak (Volts) = %f" %self.v_peak)
	volt_params.append("Frequency (Hertz) = %f" %self.v_freq)
	volt_params.append("Phase (degrees) = %f" %self.v_phase)
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.volt_elem=csv_tuple(self.volt_pos)
	if self.volt_elem[0]>0:
	if ckt_mat[self.volt_elem[0]-1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]-1, self.volt_elem[1]]
	if self.volt_elem[1]>0:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]-1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]-1]
	if self.volt_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]+1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]+1, self.volt_elem[1]]
	if self.volt_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]+1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]+1]
	volt_params.append("Positive polarity towards (cell) = %s" %csv_element(self.v_polrty))
	x_list.append(volt_params)
	def get_values(self, x_list, ckt_mat):
	self.v_peak=float(x_list[0].split("=")[1])
	self.v_freq=float(x_list[1].split("=")[1])
	self.v_phase=float(x_list[2].split("=")[1])
	volt_polrty=x_list[3].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while volt_polrty[0]==" ":
	volt_polrty=volt_polrty[1:]
	self.v_polrty=csv_tuple(volt_polrty)
	if not ckt_mat[self.v_polrty[0]][self.v_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.v_polrty)
	component_list={"resistor":Resistor, "inductor":Inductor, "capacitor":Capacitor, "voltagesource":Voltage_Source}
	nw_input=raw_input("CSV file containing the network layout --> ")
	nw_layout=nw_input+".csv"
	test_ckt=open(nw_layout,"r")
	# Read the circuit into tst_mat
	# Also performs a scrubbing of tst_mat
	tst_mat=csv_reader(test_ckt)
	components_found={}
	for c1 in range(len(tst_mat)):
	for c2 in range(len(tst_mat[0])):
	elem=tst_mat[c1][c2]
	if elem:
	# wire is a zero resistance connection
	if elem.lower()!="wire":
	if len(elem.split("_"))==1:
	jump_det=elem.split("_")[0]
	if len(jump_det)>3:
	if jump_det.lower()[0:4]=="jump":
	pass
	else:
	print "Error! Component at %s does not have a unique name/tag." %csv_element([c1, c2])
	else:
	print "Error! Component at %s does not have a unique name/tag." %csv_element([c1, c2])
	else:
	[elem_name, elem_tag]=elem.split("_")
	elem_type=elem_name.lower()
	if elem_type[0]==" ":
	elem_type=elem_type[1:]
	if elem_tag[0]==" ":
	elem_tag=elem_tag[1:]
	# Check if component exists
	if elem_type in component_list.keys():
	# If found for the first time
	# Create that dictionary element with key
	# as component type
	if elem_type not in components_found:
	components_found[elem_type]=[[csv_element([c1, c2]), elem_tag]]
	else:
	# If already found, append it to
	# dictionary item with that key.
	components_found[elem_type].append([csv_element([c1, c2]), elem_tag])
	else:
	print "Error! Component at %s doesn't exist." %csv_element([c1, c2])
	# Check if a component of the same type has the same tag.
	for items in components_found.keys():
	for c1 in range(len(components_found[items])):
	for c2 in range(len(components_found[items])):
	if c1!=c2:
	if components_found[items][c1][1]==components_found[items][c2][1]:
	print "Duplicate labels found for components of type %s at %s and %s" %(items, components_found[items][c1][0], components_found[items][c2][0])
	component_objects={}
	for items in components_found.keys():
	# Take every type of component found
	# item -> resistor, inductor etc
	for c1 in range(len(components_found[items])):
	# Each component type will be occurring
	# multiple times. Iterate through every find.
	# The list corresponding to each component is
	# the unique cell position in the spreadsheet
	component_objects[components_found[items][c1][0]] = \
	component_list[items](c1+1, components_found[items][c1][0], components_found[items][c1][1])
	parameters_file=nw_input+"_params.csv"
	# Check if the *_params.csv file exists.
	try:
	csv_check_values=open(parameters_file,"r")
	# If not, it has to be created and filled
	# with default values.
	except:
	#param_flag="no"
	pass
	# Check if any of the components with the same
	# tags are present in nw_params.csv. If so, take
	# those parameters from nw_params.csv and replace
	# the default parameters in the component objects.
	else:
	params_from_file=reading_params(csv_check_values)
	for c1 in range(len(params_from_file)):
	# Remove leading spaces if any
	# The first column is the type of element
	if params_from_file[c1][0][0]==" ":
	params_from_file[c1][0]=params_from_file[c1][0][1:]
	name_from_file=params_from_file[c1][0].lower()
	for c2 in range(len(components_found[name_from_file])):
	# Remove leading spaces if any
	if params_from_file[c1][1][0]==" ":
	params_from_file[c1][1]=params_from_file[c1][1][1:]
	# Check if the component tag exists in
	# components found so far
	if params_from_file[c1][1]==components_found[name_from_file][c2][1]:
	# If so take the parameters and move them into the object
	# having of that type and having the new cell position
	component_objects[components_found[name_from_file][c2][0]].get_values(params_from_file[c1][3:], tst_mat)
	csv_check_values.close()
	values_to_file=[]
	for items in component_objects.keys():
	# Each component object has a method
	# ask_values that prints in the csv file
	# default values for parameters.
	component_objects[items].ask_values(values_to_file, tst_mat)
	csv_ask_values=open(parameters_file,"w")
	for c1 in range(len(values_to_file)):
	for c2 in range(len(values_to_file[c1])):
	csv_ask_values.write("%s" %values_to_file[c1][c2])
	csv_ask_values.write(", ")
	csv_ask_values.write("\n")
	csv_ask_values.close()
	# Wait for the user to enter parameters before
	# reading the nw_params.csv file.
	cont_ans="n"
	while cont_ans.lower()!="y":
	cont_ans=raw_input("Enter parameters in file %s. When ready press y and enter to continue -> " %parameters_file)
	print
	csv_get_values=open(parameters_file,"r")
	params_from_file=reading_params(csv_get_values)
	csv_get_values.close()
	for c1 in range(len(params_from_file)):
	# Getting rid of the beginning spaces
	# in the component keys
	if params_from_file[c1][2][0]==" ":
	params_from_file[c1][2]=params_from_file[c1][2][1:]
	component_objects[params_from_file[c1][2]].get_values(params_from_file[c1][3:], tst_mat)
	# Just checking the objects
	for items in component_objects.keys():
	component_objects[items].display()
	node_list, branch_map, loop_list, loop_branches, conn_matrix, \
	[number_of_nodes, number_of_branches, loop_count] = network_solver(nw_layout)
	loop_count=len(loop_branches)
	print "*"*50
	print "Number of nodes",
	print number_of_nodes
	print "Number of branches",
	print number_of_branches
	print "Number of loops",
	print loop_count
	print "*"*50
	def human_loop(loop):
	""" Takes a loop as a list of tupes.
	And prints a series of elements in spreadsheet format. """
	for c1 in range(len(loop)):
	print csv_element(loop[c1]),
	return
	for c1 in range(len(loop_branches)):
	human_loop(loop_branches[c1])
	print
	print "*"*50
	def comm_elem_in_loop(loop1, loop2):
	""" Takes two loops and returns a list
	which has all the elements (tuples) that are
	common between the loops. """
	loop_comm=[]
	# Check every element of loop1
	# w.r.t to every element of loop2
	for c1 in range(len(loop1)):
	for c2 in range(len(loop2)):
	# Check if elements are equal
	if loop1[c1]==loop2[c2]:
	# Check if either of the elements
	# are the last of the loops
	if c1<len(loop1)-1 and c2<len(loop2)-1:
	# Check if they have already been
	# identified as common elements
	if loop1[c1] not in loop_comm:
	loop_comm.append(loop1[c1])
	elif loop2[c2-1]==loop_comm[-1]:
	# This is a special condition.
	# The first and last element of
	# every loop are the same.
	# Therefore, it will fail the condition that
	# the element should not be found before.
	# But, it may be possible that the segment of the
	# loops that is common does not contain the last
	# element. So, the check is:
	# If the latest element to be found is loop2[c2-1]
	# i.e is the second last element of loop2, in that
	# case, the last element i.e loop2[c2] should
	# also be appended to the common segment
	loop_comm.append(loop2[c2])
	return loop_comm
	def comm_branch_in_loop(loop1, loop2):
	""" Takes the common elements (loop1) found between
	two loops (out of which one is loop2) and break these
	elements up into separate branches."""
	# The collection of branches
	loop_comm=[]
	# Each branch
	loop_segment=[]
	# starting element
	prev_elem=loop1[0]
	# Iterate from second to last element
	for c1 in range(1, len(loop1)):
	# Check if the index between this current element
	# and the previous element is less than or equal to 1
	# This means it is a continuation of a branch
	if abs(loop2.index(loop1[c1])-loop2.index(prev_elem))<=1:
	loop_segment.append(prev_elem)
	# If not, it means it is a new branch
	else:
	# Complete the branch with the previous element
	loop_segment.append(prev_elem)
	# If it is the final element of the loop
	# Don't leave it out but add that too
	if c1==len(loop1)-1:
	loop_segment.append(loop1[c1])
	# Add that to the collection of branches
	loop_comm.append(loop_segment)
	loop_segment=[]
	# Refresh the previous element
	prev_elem=loop1[c1]
	# This is a special condition.
	# If there is only one common branch, the main
	# condition will fail because a new branch will not be found
	# In that case, the addition function needs to be repeated.
	if not loop_comm:
	loop_segment.append(prev_elem)
	loop_comm.append(loop_segment)
	return loop_comm
	# A temporary list that stores the nodes
	# common to two loops
	nodes_in_loop=[]
	# A array of all the loops of the system
	# including common branches between loops.
	system_loops=[]
	for c1 in range(loop_count):
	row_vector=[]
	for c2 in range(loop_count):
	row_vector.append([])
	system_loops.append(row_vector)
	for c1 in range(len(loop_branches)):
	# The diagonal elements of system_loops
	# will be the loops themselves.
	for c2 in range(len(loop_branches[c1])):
	system_loops[c1][c1].append(loop_branches[c1][c2])
	# The system_loops array will be symmetric
	for c2 in range(c1+1, len(loop_branches)):
	# Find the nodes in loop1
	for c3 in range(len(node_list)):
	if node_list[c3] in loop_branches[c1]:
	nodes_in_loop.append(node_list[c3])
	# Find out the nodes common to loop1
	# and loop2.
	for c3 in range(len(nodes_in_loop)-1, -1, -1):
	if nodes_in_loop[c3] not in loop_branches[c2]:
	del nodes_in_loop[c3]
	# If there are two or more nodes common
	# between loop1 and loop2, there are
	# common elements.
	if len(nodes_in_loop)>1:
	comm_seg_in_loop=comm_elem_in_loop(loop_branches[c1], loop_branches[c2])
	print c1, c2
	#human_loop(comm_seg_in_loop)
	#print
	sys_loop_off_diag=comm_branch_in_loop(comm_seg_in_loop, loop_branches[c1])
	for item in sys_loop_off_diag:
	print "[",
	human_loop(item),
	print "]",
	print
	system_loops[c1][c2].append(sys_loop_off_diag)
	system_loops[c2][c1].append(sys_loop_off_diag)
	nodes_in_loop=[]

view raw csv_element4.py hosted with ❤ by GitHub

Circuit Parameters - VI

There is a couple of major design flaw in the previous approach.

1. The component names are automatically generated. It is always better to let the user name the components as they may correspond to PCB designs etc.
2. Any change in the circuit topology, even an extension of a branch would be seen a new circuit with default values. Better to check if any of the components in the new circuit have parameters in the parameter file and start with those parameters.

So, a change in the code. The components will now be names followed by an underscore ("_") and then the name of the component. Example: Resistor_R1, voltagesource_v1. Case is not important in the component names though it is in the tags.

The unique identifier continues to be cell position. However, for a particular component type, the same tag can't be used. For example: resistor_r1 and resistor_r1 would be illegal. However, two different components could have the same tag. For example: Resistor_br and inductor_br are OK. If the user want to name the components according to function, this might be a good option.

Here is the code (click on "view raw" below the box to see the entire code):

	#! /usr/bin/env python
	import sys, math
	import network_reader as nw_rd
	def csv_tuple(csv_elem):
	""" Convert a cell position from spreadsheet form
	to [row, tuple] form. """
	csv_elem.upper()
	# Create a dictionary of alphabets
	csv_col="A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
	csv_dict={}
	csv_col_list=csv_col.split(" ")
	# Make the alphabets correspond to integers
	for c1 in range(1, 27):
	csv_dict[csv_col_list[c1-1]]=c1
	# The cell position starts with a number
	flag="number"
	c1=0
	while flag=="number":
	# When conversion to int fails
	# it means the element is an alphabet
	try:
	int(csv_elem[c1])
	except ValueError:
	flag="alphabet"
	else:
	c1+=1
	# Split them up into numbers and alphabets
	pol_row=int(csv_elem[0:c1])
	pol_col=csv_elem[c1:]
	elem_tuple=[pol_row-1, 0]
	# Convert the alphabets to number
	# Similar to converting binary to decimal
	for c1 in range(len(pol_col)-1, -1, -1):
	if len(pol_col)-1-c1>0:
	elem_tuple[1]+=26*(len(pol_col)-1-c1)*csv_dict[pol_col[c1]]
	else:
	elem_tuple[1]+=csv_dict[pol_col[c1]]-1
	return elem_tuple
	def reading_params(param_file):
	""" Read a file. Ramove additional quotes and
	carriage returns. Remove leading spaces. """
	from_file=[]
	for line in param_file:
	from_file.append(line.split(","))
	for c1 in range(len(from_file)):
	for c2 in range(len(from_file[c1])-1, -1, -1):
	# Remove additional quotes and carriage returns
	if from_file[c1][c2]:
	nw_rd.scrub_elements(from_file, c1, c2)
	# Remove blank spaces and null elements
	if from_file[c1][c2]==" " or from_file[c1][c2]=="":
	del from_file[c1][c2]
	return from_file
	class Resistor:
	def __init__(self, res_index, res_pos, res_tag):
	self.res_number=res_index
	self.res_pos=res_pos
	self.res_tag=res_tag
	self.resistor=100.0
	def display(self):
	print "Resistor is ",
	print self.res_tag,
	print "= %f" %self.resistor,
	print " located at ",
	print self.res_pos
	def ask_values(self, x_list, ckt_mat):
	res_params=["Resistor"]
	res_params.append(self.res_tag)
	res_params.append(self.res_pos)
	res_params.append(self.resistor)
	x_list.append(res_params)
	def get_values(self, x_list, ckt_mat):
	self.resistor=float(x_list[0])
	class Inductor:
	def __init__(self, ind_index, ind_pos, ind_tag):
	self.ind_number=ind_index
	self.ind_pos=ind_pos
	self.ind_tag=ind_tag
	self.inductor=0.001
	def display(self):
	print "Inductor is ",
	print self.ind_tag,
	print "=%f" %self.inductor,
	print " located at ",
	print self.ind_pos
	def ask_values(self, x_list, ckt_mat):
	ind_params=["Inductor"]
	ind_params.append(self.ind_tag)
	ind_params.append(self.ind_pos)
	ind_params.append(self.inductor)
	x_list.append(ind_params)
	def get_values(self, x_list, ckt_mat):
	self.inductor=float(x_list[0])
	class Capacitor:
	def __init__(self, cap_index, cap_pos, cap_tag):
	self.cap_number=cap_index
	self.cap_pos=cap_pos
	self.cap_tag=cap_tag
	self.capacitor=10.0e-6
	def display(self):
	print "Capacitor is ",
	print self.cap_tag,
	print "= %f" %self.capacitor,
	print " located at ",
	print self.cap_pos
	def ask_values(self, x_list, ckt_mat):
	cap_params=["Capacitor"]
	cap_params.append(self.cap_tag)
	cap_params.append(self.cap_pos)
	cap_params.append(self.capacitor)
	x_list.append(cap_params)
	def get_values(self, x_list, ckt_mat):
	self.capacitor=float(x_list[0])
	class Voltage_Source:
	def __init__(self, volt_index, volt_pos, volt_tag):
	self.volt_number=volt_index
	self.volt_pos=volt_pos
	self.volt_tag=volt_tag
	self.v_peak=120.0
	self.v_freq=60.0
	self.v_phase=0.0
	def display(self):
	print "Voltage Source is ",
	print self.volt_tag,
	print "of %f V(peak), %f Hz(frequency) and %f (degrees phase shift)" %(self.v_peak, self.v_freq, self.v_phase),
	print " located at ",
	print self.volt_pos,
	print " with positive polarity towards %s %s" %(nw_rd.csv_element(self.v_polrty), self.v_polrty)
	def ask_values(self, x_list, ckt_mat):
	volt_params=["VoltageSource"]
	volt_params.append(self.volt_tag)
	volt_params.append(self.volt_pos)
	volt_params.append("Peak (Volts) = %f" %self.v_peak)
	volt_params.append("Frequency (Hertz) = %f" %self.v_freq)
	volt_params.append("Phase (degrees) = %f" %self.v_phase)
	# Looking for a default value of polarity
	# in the neighbouring cells
	self.volt_elem=csv_tuple(self.volt_pos)
	if self.volt_elem[0]>0:
	if ckt_mat[self.volt_elem[0]-1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]-1, self.volt_elem[1]]
	elif self.volt_elem[1]>0:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]-1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]-1]
	elif self.volt_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]+1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]+1, self.volt_elem[1]]
	elif self.volt_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]+1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]+1]
	volt_params.append("Positive polarity towards (cell) = %s" %nw_rd.csv_element(self.v_polrty))
	x_list.append(volt_params)
	def get_values(self, x_list, ckt_mat):
	self.v_peak=float(x_list[0].split("=")[1])
	self.v_freq=float(x_list[1].split("=")[1])
	self.v_phase=float(x_list[2].split("=")[1])
	volt_polrty=x_list[3].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while volt_polrty[0]==" ":
	volt_polrty=volt_polrty[1:]
	self.v_polrty=csv_tuple(volt_polrty)
	if not ckt_mat[self.v_polrty[0]][self.v_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %nw_rd.csv_element(self.v_polrty)
	component_list={"resistor":Resistor, "inductor":Inductor, "capacitor":Capacitor, "voltagesource":Voltage_Source}
	test_ckt=open("testckt1.csv","r")
	# Read the circuit into tst_mat
	# Also performs a scrubbing of tst_mat
	tst_mat=nw_rd.csv_reader(test_ckt)
	components_found={}
	for c1 in range(len(tst_mat)):
	for c2 in range(len(tst_mat[0])):
	elem=tst_mat[c1][c2]
	if elem:
	# wire is a zero resistance connection
	if elem.lower()!="wire":
	if len(elem.split("_"))==1:
	print "Error! Component at %s does not have a unique name/tag." %nw_rd.csv_element([c1, c2])
	else:
	[elem_name, elem_tag]=elem.split("_")
	elem_type=elem_name.lower()
	if elem_type[0]==" ":
	elem_type=elem_type[1:]
	if elem_tag[0]==" ":
	elem_tag=elem_tag[1:]
	# Check if component exists
	if elem_type in component_list.keys():
	# If found for the first time
	# Create that dictionary element with key
	# as component type
	if elem_type not in components_found:
	components_found[elem_type]=[[nw_rd.csv_element([c1, c2]), elem_tag]]
	else:
	# If already found, append it to
	# dictionary item with that key.
	components_found[elem_type].append([nw_rd.csv_element([c1, c2]), elem_tag])
	else:
	print "Error! Component at %s doesn't exist." %nw_rd.csv_element([c1, c2])
	# Check if a component of the same type has the same tag.
	for items in components_found.keys():
	for c1 in range(len(components_found[items])):
	for c2 in range(len(components_found[items])):
	if c1!=c2:
	if components_found[items][c1][1]==components_found[items][c2][1]:
	print "Duplicate labels found for components of type %s at %s and %s" %(items, components_found[items][c1][0], components_found[items][c2][0])
	component_objects={}
	for items in components_found.keys():
	# Take every type of component found
	# item -> resistor, inductor etc
	for c1 in range(len(components_found[items])):
	# Each component type will be occurring
	# multiple times. Iterate through every find.
	# The list corresponding to each component is
	# the unique cell position in the spreadsheet
	component_objects[components_found[items][c1][0]] = \
	component_list[items](c1+1, components_found[items][c1][0], components_found[items][c1][1])
	# Check if the nw_params.csv file exists.
	try:
	csv_check_values=open("nw_params.csv","r")
	# If not, it has to be created and filled
	# with default values.
	except:
	#param_flag="no"
	pass
	# Check if any of the components with the same
	# tags are present in nw_params.csv. If so, take
	# those parameters from nw_params.csv and replace
	# the default parameters in the component objects.
	else:
	params_from_file=reading_params(csv_check_values)
	for c1 in range(len(params_from_file)):
	# Remove leading spaces if any
	# The first column is the type of element
	if params_from_file[c1][0][0]==" ":
	params_from_file[c1][0]=params_from_file[c1][0][1:]
	name_from_file=params_from_file[c1][0].lower()
	for c2 in range(len(components_found[name_from_file])):
	# Remove leading spaces if any
	if params_from_file[c1][1][0]==" ":
	params_from_file[c1][1]=params_from_file[c1][1][1:]
	# Check if the component tag exists in
	# components found so far
	if params_from_file[c1][1]==components_found[name_from_file][c2][1]:
	# If so take the parameters and move them into the object
	# having of that type and having the new cell position
	component_objects[components_found[name_from_file][c2][0]].get_values(params_from_file[c1][3:], tst_mat)
	csv_check_values.close()
	values_to_file=[]
	for items in component_objects.keys():
	# Each component object has a method
	# ask_values that prints in the csv file
	# default values for parameters.
	component_objects[items].ask_values(values_to_file, tst_mat)
	csv_ask_values=open("nw_params.csv","w")
	for c1 in range(len(values_to_file)):
	for c2 in range(len(values_to_file[c1])):
	csv_ask_values.write("%s" %values_to_file[c1][c2])
	csv_ask_values.write(", ")
	csv_ask_values.write("\n")
	csv_ask_values.close()
	# Wait for the user to enter parameters before
	# reading the nw_params.csv file.
	cont_ans="n"
	while cont_ans.lower()!="y":
	cont_ans=raw_input("Enter parameters in file nw_params.csv. When ready press y and enter to continue -> ")
	print
	csv_get_values=open("nw_params.csv","r")
	params_from_file=reading_params(csv_get_values)
	csv_get_values.close()
	for c1 in range(len(params_from_file)):
	# Getting rid of the beginning spaces
	# in the component keys
	if params_from_file[c1][2][0]==" ":
	params_from_file[c1][2]=params_from_file[c1][2][1:]
	component_objects[params_from_file[c1][2]].get_values(params_from_file[c1][3:], tst_mat)
	# Just checking the objects
	for items in component_objects.keys():
	component_objects[items].display()

view raw csv_element3.py hosted with ❤ by GitHub

Circuit Parameters - V

Couple of updates to the previous code:

1. Some elements will also have a polarity. In this case, the voltage source definitely will have one. The capacitor could also have but I'll consider an ac capacitor for now.

2. There will have to be provision to check if everytime the program is run, whether the circuit has changed. If the circuit is the same but the parameters need to be updated, then nw_params.csv should not be filled with default values as the user will have to update everything all over again or will have to remember to copy nw_params.csv to another backup file. A more elaborate method can be thought of later where the actual topology can be read - nodes, branches, loops etc and if that remains the same along with elements in every branch, then circuit can be considered the same. Because otherwise a small change to a branch such as lengthening with more "wire" elements will be seen as a new circuit. For that matter, even if major changes are to be made, only the changed elements can be considered. All this is user interface and will come later.


So anyway, here is the updated code (click on "view raw" below the code box for code going out of the window):

	#! /usr/bin/env python
	import sys, math
	import network_reader as nw_rd
	def reading_params(param_file):
	""" Read a file. Ramove additional quotes and
	carriage returns. Remove leading spaces. """
	from_file=[]
	for line in param_file:
	from_file.append(line.split(","))
	for c1 in range(len(from_file)):
	for c2 in range(len(from_file[c1])-1, -1, -1):
	# Remove additional quotes and carriage returns
	if from_file[c1][c2]:
	nw_rd.scrub_elements(from_file, c1, c2)
	# Remove blank spaces and null elements
	if from_file[c1][c2]==" " or from_file[c1][c2]=="":
	del from_file[c1][c2]
	return from_file
	class Resistor:
	def __init__(self, res_index, res_pos, res_elem):
	self.res_number=res_index
	self.res_pos=res_pos
	self.res_elem=res_elem
	def display(self):
	print "Resistor is ",
	print "R"+str(self.res_number),
	print "= %f" %self.resistor,
	print " located at ",
	print self.res_pos, self.res_elem
	def ask_values(self, x_list, ckt_mat):
	res_params=["Resistor"]
	res_params.append("R"+str(self.res_number))
	res_params.append(self.res_pos)
	res_params.append(100.0)
	x_list.append(res_params)
	def get_values(self, x_list, ckt_mat):
	self.resistor=float(x_list[0])
	class Inductor:
	def __init__(self, ind_index, ind_pos, ind_elem):
	self.ind_number=ind_index
	self.ind_pos=ind_pos
	self.ind_elem=ind_elem
	def display(self):
	print "Inductor is ",
	print "L"+str(self.ind_number),
	print "=%f" %self.inductor,
	print " located at ",
	print self.ind_pos, self.ind_elem
	def ask_values(self, x_list, ckt_mat):
	ind_params=["Inductor"]
	ind_params.append("L"+str(self.ind_number))
	ind_params.append(self.ind_pos)
	ind_params.append(0.001)
	x_list.append(ind_params)
	def get_values(self, x_list, ckt_mat):
	self.inductor=float(x_list[0])
	class Capacitor:
	def __init__(self, cap_index, cap_pos, cap_elem):
	self.cap_number=cap_index
	self.cap_pos=cap_pos
	self.cap_elem=cap_elem
	def display(self):
	print "Capacitor is ",
	print "C"+str(self.cap_number),
	print "= %f" %self.capacitor,
	print " located at ",
	print self.cap_pos, self.cap_elem
	def ask_values(self, x_list, ckt_mat):
	cap_params=["Capacitor"]
	cap_params.append("C"+str(self.cap_number))
	cap_params.append(self.cap_pos)
	cap_params.append(10.0e-6)
	x_list.append(cap_params)
	def get_values(self, x_list, ckt_mat):
	self.capacitor=float(x_list[0])
	class Voltage_Source:
	def __init__(self, volt_index, volt_pos, volt_elem):
	self.volt_number=volt_index
	self.volt_pos=volt_pos
	self.volt_elem=volt_elem
	def display(self):
	print "Voltage Source is ",
	print "V"+str(self.volt_number),
	print "of %f V(peak), %f Hz(frequency) and %f (degrees phase shift)" %(self.v_peak, self.v_freq, self.v_phase),
	print " located at ",
	print self.volt_pos, self.volt_elem,
	print " with positive polarity towards %s %s" %(nw_rd.csv_element(self.v_polrty), self.v_polrty)
	def ask_values(self, x_list, ckt_mat):
	volt_params=["Voltage_Source"]
	volt_params.append("V"+str(self.volt_number))
	volt_params.append(self.volt_pos)
	volt_params.append("Peak (Volts) = 120.0")
	volt_params.append("Frequency (Hertz) = 60")
	volt_params.append("Phase (degrees) = 0")
	# Looking for a default value of polarity
	# in the neighbouring cells
	if self.volt_elem[0]>0:
	if ckt_mat[self.volt_elem[0]-1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]-1, self.volt_elem[1]]
	elif self.volt_elem[1]>0:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]-1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]-1]
	elif self.volt_elem[0]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]+1][self.volt_elem[1]]:
	self.v_polrty=[self.volt_elem[0]+1, self.volt_elem[1]]
	elif self.volt_elem[1]<len(ckt_mat)-1:
	if ckt_mat[self.volt_elem[0]][self.volt_elem[1]+1]:
	self.v_polrty=[self.volt_elem[0], self.volt_elem[1]+1]
	volt_params.append("Positive polarity towards (cell) = %s" %nw_rd.csv_element(self.v_polrty))
	x_list.append(volt_params)
	def get_values(self, x_list, ckt_mat):
	self.v_peak=float(x_list[0].split("=")[1])
	self.v_freq=float(x_list[1].split("=")[1])
	self.v_phase=float(x_list[2].split("=")[1])
	volt_polrty=x_list[3].split("=")[1]
	# Convert the human readable form of cell
	# to [row, column] form
	while volt_polrty[0]==" ":
	volt_polrty=volt_polrty[1:]
	volt_polrty.upper()
	# Create a dictionary of alphabets
	csv_col="A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
	csv_dict={}
	csv_col_list=csv_col.split(" ")
	# Make the alphabets correspond to integers
	for c1 in range(1, 27):
	csv_dict[csv_col_list[c1-1]]=c1
	# The cell position starts with a number
	flag="number"
	c1=0
	while flag=="number":
	# When conversion to int fails
	# it means the element is an alphabet
	try:
	int(volt_polrty[c1])
	except ValueError:
	flag="alphabet"
	else:
	c1+=1
	# Split them up into numbers and alphabets
	pol_row=int(volt_polrty[0:c1])
	pol_col=volt_polrty[c1:]
	self.v_polrty=[pol_row-1, 0]
	# Convert the alphabets to number
	# Similar to converting binary to decimal
	for c1 in range(len(pol_col)-1, -1, -1):
	if len(pol_col)-1-c1>0:
	self.v_polrty[1]+=26*(len(pol_col)-1-c1)*csv_dict[pol_col[c1]]
	else:
	self.v_polrty[1]+=csv_dict[pol_col[c1]]-1
	if not ckt_mat[self.v_polrty[0]][self.v_polrty[1]]:
	print "Polarity incorrect. Branch does not exist at %s" %nw_rd.csv_element(self.v_polrty)
	component_list={"Resistor":Resistor, "Inductor":Inductor, "Capacitor":Capacitor, "Voltage_Source":Voltage_Source}
	test_ckt=open("testckt1.csv","r")
	# Read the circuit into tst_mat
	# Also performs a scrubbing of tst_mat
	tst_mat=nw_rd.csv_reader(test_ckt)
	components_found={}
	for c1 in range(len(tst_mat)):
	for c2 in range(len(tst_mat[0])):
	elem=tst_mat[c1][c2]
	if elem:
	# wire is a zero resistance connection
	if elem.lower()!="wire":
	# Check if component exists
	if elem in component_list.keys():
	# If found for the first time
	# Create that dictionary element with key
	# as component type
	if elem not in components_found:
	components_found[elem]=[[nw_rd.csv_element([c1, c2]), [c1, c2]]]
	else:
	# If already found, append it to
	# dictionary item with that key.
	components_found[elem].append([nw_rd.csv_element([c1, c2]), [c1, c2]])
	else:
	print "Error! Component at %s doesn't exist." %nw_rd.csv_element([c1, c2])
	component_objects={}
	for items in components_found.keys():
	# Take every type of component found
	# item -> resistor, inductor etc
	for c1 in range(len(components_found[items])):
	# Each component type will be occurring
	# multiple times. Iterate through every find.
	# The list corresponding to each component is
	# the unique cell position in the spreadsheet
	component_objects[components_found[items][c1][0]] = \
	component_list[items](c1+1, components_found[items][c1][0], components_found[items][c1][1])
	# Check if the nw_params.csv file exists.
	try:
	csv_check_values=open("nw_params.csv","r")
	# If not, it has to be created and filled
	# with default values.
	except:
	param_flag="no"
	# If it exists, check if the circuit
	# is the same and only parameters need to change
	else:
	params_from_file=reading_params(csv_check_values)
	# A single change in the circuit topology
	# will mean a new circuit.
	same_ckt="yes"
	for c1 in range(len(params_from_file)):
	# Remove leading spaces if any
	# The first column is the type of element
	if params_from_file[c1][0][0]==" ":
	params_from_file[c1][0]=params_from_file[c1][0][1:]
	# Check if the type of element is
	# in the same cell position as before
	# Here a single occurance of the type of element
	# in components_found and in the same position
	# means it is the same.
	element_same="no"
	for c2 in range(len(components_found[params_from_file[c1][0]])):
	if params_from_file[c1][2][0]==" ":
	params_from_file[c1][2]=params_from_file[c1][2][1:]
	if params_from_file[c1][2]==components_found[params_from_file[c1][0]][c2][0]:
	element_same="yes"
	# If a single element has changed,
	# the circuit is new
	if element_same=="no":
	same_ckt="no"
	csv_check_values.close()
	# If the circuit is the same, the parameters
	# can remain as they are
	if same_ckt=="yes":
	param_flag="yes"
	# If not, default parameters need to be entered
	# for a new circuit.
	else:
	param_flag="no"
	# Enter default values into nw_params.csv
	# or create it if its a new cicuit
	if param_flag=="no":
	values_to_file=[]
	for items in component_objects.keys():
	# Each component object has a method
	# ask_values that prints in the csv file
	# default values for parameters.
	component_objects[items].ask_values(values_to_file, tst_mat)
	csv_ask_values=open("nw_params.csv","w")
	for c1 in range(len(values_to_file)):
	for c2 in range(len(values_to_file[c1])):
	csv_ask_values.write("%s" %values_to_file[c1][c2])
	csv_ask_values.write(", ")
	csv_ask_values.write("\n")
	csv_ask_values.close()
	# Wait for the user to enter parameters before
	# reading the nw_params.csv file.
	cont_ans="n"
	while cont_ans.lower()!="y":
	cont_ans=raw_input("Enter parameters in file nw_params.csv. When ready press y and enter to continue -> ")
	csv_get_values=open("nw_params.csv","r")
	params_from_file=reading_params(csv_get_values)
	csv_get_values.close()
	for c1 in range(len(params_from_file)):
	# Getting rid of the beginning spaces
	# in the component keys
	if params_from_file[c1][2][0]==" ":
	params_from_file[c1][2]=params_from_file[c1][2][1:]
	component_objects[params_from_file[c1][2]].get_values(params_from_file[c1][3:], tst_mat)
	# Just checking the objects
	for items in component_objects.keys():
	component_objects[items].display()

view raw csv_element2.py hosted with ❤ by GitHub

Circuit Paramaters - IV

Now that the basic concept of entering parameters is established, this is the code for it.

Depending on the components found from the circuit spreadsheet, another spreadsheet is created with rows corresponding to every device found. Each device will have default parameters. So the user will have to change those. After all changes, the user can save it as another CSV file.

Each row in the spreadsheet will have the first three elements as - Component type (Resistor, Inductor etc), Component Reference (R1, L2 etc), Cell Position.

As before, the Cell position can be used to access the component object from the component object dictionary. The component classes will have a function to take the parameters which will be column 4 onwards.

Here is the code (click on "view raw" to see the part going out of the box):

	#! /usr/bin/env python
	import sys, math
	import network_reader as nw_rd
	class Resistor:
	def __init__(self, res_index, res_pos):
	self.res_number=res_index
	self.res_pos=res_pos
	def display(self):
	print "Resistor is ",
	print "R"+str(self.res_number),
	print "= %f" %self.resistor,
	print " located at ",
	print self.res_pos
	def ask_values(self, x_list):
	res_params=["Resistor"]
	res_params.append("R"+str(self.res_number))
	res_params.append(self.res_pos)
	res_params.append(100.0)
	x_list.append(res_params)
	def get_values(self, x_list):
	self.resistor=float(x_list[0])
	class Inductor:
	def __init__(self, ind_index, ind_pos):
	self.ind_number=ind_index
	self.ind_pos=ind_pos
	def display(self):
	print "Inductor is ",
	print "L"+str(self.ind_number),
	print "=%f" %self.inductor,
	print " located at ",
	print self.ind_pos
	def ask_values(self, x_list):
	ind_params=["Inductor"]
	ind_params.append("L"+str(self.ind_number))
	ind_params.append(self.ind_pos)
	ind_params.append(0.001)
	x_list.append(ind_params)
	def get_values(self, x_list):
	self.inductor=float(x_list[0])
	class Capacitor:
	def __init__(self, cap_index, cap_pos):
	self.cap_number=cap_index
	self.cap_pos=cap_pos
	def display(self):
	print "Capacitor is ",
	print "C"+str(self.cap_number),
	print "= %f" %self.capacitor,
	print " located at ",
	print self.cap_pos
	def ask_values(self, x_list):
	cap_params=["Capacitor"]
	cap_params.append("C"+str(self.cap_number))
	cap_params.append(self.cap_pos)
	cap_params.append(10.0e-6)
	x_list.append(cap_params)
	def get_values(self, x_list):
	self.capacitor=float(x_list[0])
	class Voltage_Source:
	def __init__(self, volt_index, volt_pos):
	self.volt_number=volt_index
	self.volt_pos=volt_pos
	def display(self):
	print "Voltage Source is ",
	print "V"+str(self.volt_number),
	print "of %f V(peak), %f Hz(frequency) and %f (degrees phase shift)" %(self.v_peak, self.v_freq, self.v_phase),
	print " located at ",
	print self.volt_pos
	def ask_values(self, x_list):
	volt_params=["Voltage Source"]
	volt_params.append("V"+str(self.volt_number))
	volt_params.append(self.volt_pos)
	volt_params.append("Peak (Volts) = 120.0")
	volt_params.append("Frequency (Hertz) = 60")
	volt_params.append("Phase (degrees) = 0")
	x_list.append(volt_params)
	def get_values(self, x_list):
	self.v_peak=float(x_list[0].split("=")[1])
	self.v_freq=float(x_list[1].split("=")[1])
	self.v_phase=float(x_list[2].split("=")[1])
	component_list={"Resistor":Resistor, "Inductor":Inductor, "Capacitor":Capacitor, "Voltage_Source":Voltage_Source}
	test_ckt=open("testckt1.csv","r")
	# Read the circuit into tst_mat
	# Also performs a scrubbing of tst_mat
	tst_mat=nw_rd.csv_reader(test_ckt)
	components_found={}
	for c1 in range(len(tst_mat)):
	for c2 in range(len(tst_mat[0])):
	elem=tst_mat[c1][c2]
	if elem:
	# wire is a zero resistance connection
	if elem.lower()!="wire":
	# Check if component exists
	if elem in component_list.keys():
	# If found for the first time
	# Create that dictionary element with key
	# as component type
	if elem not in components_found:
	components_found[elem]=[nw_rd.csv_element([c1, c2])]
	else:
	# If already found, append it to
	# dictionary item with that key.
	components_found[elem].append(nw_rd.csv_element([c1, c2]))
	else:
	print "Error! Component at %s doesn't exist." %nw_rd.csv_element([c1, c2])
	component_objects={}
	for items in components_found.keys():
	# Take every type of component found
	# item -> resistor, inductor etc
	for c1 in range(len(components_found[items])):
	# Each component type will be occurring
	# multiple times. Iterate through every find.
	# The list corresponding to each component is
	# the unique cell position in the spreadsheet
	component_objects[components_found[items][c1]] = \
	component_list[items](c1+1, components_found[items][c1])
	values_to_file=[]
	for items in component_objects.keys():
	# Each component object has a method
	# ask_values that prints in the csv file
	# default values for parameters.
	component_objects[items].ask_values(values_to_file)
	csv_ask_values=open("nw_params.csv","w")
	for c1 in range(len(values_to_file)):
	for c2 in range(len(values_to_file[c1])):
	csv_ask_values.write("%s" %values_to_file[c1][c2])
	csv_ask_values.write(", ")
	csv_ask_values.write("\n")
	csv_ask_values.close()
	csv_get_values=open("nw_paramsdone.csv","r")
	params_from_file=[]
	for line in csv_get_values:
	params_from_file.append(line.split(","))
	csv_get_values.close()
	for c1 in range(len(params_from_file)):
	for c2 in range(len(params_from_file[c1])-1, -1, -1):
	# Remove additional quotes and carriage returns
	if params_from_file[c1][c2]:
	nw_rd.scrub_elements(params_from_file, c1, c2)
	# Remove blank spaces and null elements
	if params_from_file[c1][c2]==" " or params_from_file[c1][c2]=="":
	del params_from_file[c1][c2]
	for c1 in range(len(params_from_file)):
	# Getting rid of the beginning spaces
	# in the component keys
	if params_from_file[c1][2][0]==" ":
	params_from_file[c1][2]=params_from_file[c1][2][1:]
	component_objects[params_from_file[c1][2]].get_values(params_from_file[c1][3:])
	# Just checking the objects
	for items in component_objects.keys():
	component_objects[items].display()

view raw csv_element1.py hosted with ❤ by GitHub

Circuit Parameters - III

The next step is to take a sample circuit with a voltage source, resistors, inductors and capacitors and to automate the naming of the elements.

The unique  identification all these elements have is their position in the spreadsheet - only one element can occupy a cell. So the first part is to write a small function that will translate the cell information from [row, column] form to the form that can be read of from the spreadsheet.

That function is here:

	def csv_element(elem):
	""" Takes the [row, column] input for a csv file
	and given a human readable spreadsheet position. """
	# Convert column numbers to alphabets
	csv_col="A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
	csv_dict={}
	csv_col_list=csv_col.split(" ")
	for c1 in range(26):
	csv_dict[c1]=csv_col_list[c1]
	# Because row 0 doesn't exist on a
	# spreadsheet
	row=elem[0]+1
	col=elem[1]
	# Create a list of all the alphabets
	# that a column will have
	col_nos=[-1]
	# On the run, an alphabet will
	# have a remainder and a prefix
	# This is essentially the first and
	# second alphabet
	prefix=0
	remdr=col
	# The alphabet that is to be found
	col_count=0
	while remdr-25>0:
	# If the column>26, the first
	# alphabet increments by 1
	prefix+=1
	remdr=remdr-26
	if remdr<25:
	if prefix>25:
	# More than 2 alphabets
	col_nos[col_count]=remdr
	# The remainder takes the prefix
	remdr=prefix-1
	# The prefix is the third/next alphabet
	prefix=0
	# Add another element to the list
	col_nos.append(-1)
	col_count+=1
	else:
	# 2 alphabets only
	col_nos.append(-1)
	col_nos[-1]=prefix-1
	col_nos[col_count]=remdr
	col_letters=""
	# The alphabets are backwards
	for c1 in range(len(col_nos)-1, -1, -1):
	col_letters=col_letters+csv_dict[col_nos[c1]]
	csv_format=str(row)+col_letters
	return csv_format

view raw csv_element.py hosted with ❤ by GitHub

So the string that marks the cell position being an immutable element can be the key in a dictionary. A dictionary can be made of all elements found in the circuit and these can be accessed at any time by the position.

Now an identification is chosen, what will be the value of this dictionary item? Ideally, it would be great if it could be the object itself. Then every element will be an object uniquely identified by its position and with the same methods for transferring data to and from the main solver.

This program seems to do this (click on "View Raw" below the code box to see the code going out of the window):

	#! /usr/bin/env python
	import sys, math
	import network_reader as nw_rd
	class Resistor:
	def __init__(self, res_index, res_pos):
	self.res_number=res_index
	self.res_pos=res_pos
	def display(self):
	print "Resistor is ",
	print "R"+str(self.res_number),
	print " located at ",
	print self.res_pos
	class Inductor:
	def __init__(self, ind_index, ind_pos):
	self.ind_number=ind_index
	self.ind_pos=ind_pos
	def display(self):
	print "Inductor is ",
	print "L"+str(self.ind_number),
	print " located at ",
	print self.ind_pos
	class Capacitor:
	def __init__(self, cap_index, cap_pos):
	self.cap_number=cap_index
	self.cap_pos=cap_pos
	def display(self):
	print "Capacitor is ",
	print "C"+str(self.cap_number),
	print " located at ",
	print self.cap_pos
	class Voltage_Source:
	def __init__(self, volt_index, volt_pos):
	self.volt_number=volt_index
	self.volt_pos=volt_pos
	def display(self):
	print "Voltage Source is ",
	print "V"+str(self.volt_number),
	print " located at ",
	print self.volt_pos
	component_list={"Resistor":Resistor, "Inductor":Inductor, "Capacitor":Capacitor, "Voltage_Source":Voltage_Source}
	test_ckt=open("testckt1.csv","r")
	tst_mat=nw_rd.csv_reader(test_ckt)
	components_found={}
	for c1 in range(len(tst_mat)):
	for c2 in range(len(tst_mat[0])):
	if tst_mat[c1][c2]:
	if tst_mat[c1][c2].lower()!="wire":
	if tst_mat[c1][c2] in component_list.keys():
	if tst_mat[c1][c2] not in components_found:
	components_found[tst_mat[c1][c2]]=[nw_rd.csv_element([c1, c2])]
	else:
	components_found[tst_mat[c1][c2]].append(nw_rd.csv_element([c1, c2]))
	else:
	print "Error! Component at %s doesn't exist." %nw_rd.csv_element([c1, c2])
	component_objects={}
	for items in components_found.keys():
	for c1 in range(len(components_found[items])):
	component_objects[components_found[items][c1]]=component_list[items](c1+1, components_found[items][c1])
	for items in component_objects.keys():
	component_objects[items].display()

view raw circuit_elements.py hosted with ❤ by GitHub

In this file, network_reader is the Python code that contains the circuit interpreter done so far. Each class so far contains only the information of its index (or serial number) and the position in the spreadsheet.
--------------------------------------------------------------------------------------
class Resistor:
    def __init__(self, res_index, res_pos):
        self.res_number=res_index
        self.res_pos=res_pos
    def display(self):
        print "Resistor is ",
        print "R"+str(self.res_number),
        print " located at ",
        print self.res_pos
--------------------------------------------------------------------------------------

All the class references are added to the dictionary:
--------------------------------------------------------------------------------------
component_list={"Resistor":Resistor, "Inductor":Inductor, "Capacitor":Capacitor, "Voltage_Source":Voltage_Source}
--------------------------------------------------------------------------------------

This is what component list looks like:
--------------------------------------------------------------------------------------
>>> component_list
{'Voltage_Source': <class __main__.Voltage_Source at 0x02C9F810>, 'Resistor': <class __main__.Resistor at 0x02C9F768>, 'Inductor': <class __main__.Inductor at 0x02C9F7A0>, 'Capacitor': <class __main__.Capacitor at 0x02C9F7D8>}
--------------------------------------------------------------------------------------


The next step is to generate a dictionary of all the components found in the spreadsheet:
--------------------------------------------------------------------------------------
components_found={}
for c1 in range(len(tst_mat)):
    for c2 in range(len(tst_mat[0])):
        if tst_mat[c1][c2]:
            if tst_mat[c1][c2].lower()!="wire":
                if tst_mat[c1][c2] in component_list.keys():
                    if tst_mat[c1][c2] not in components_found:
                        components_found[tst_mat[c1][c2]]=[nw_rd.csv_element([c1, c2])]
                    else:
                        components_found[tst_mat[c1][c2]].append(nw_rd.csv_element([c1, c2]))
                else:
                    print "Error! Component at %s doesn't exist." %nw_rd.csv_element([c1, c2])
--------------------------------------------------------------------------------------

And this is what the dictionary looks like:
--------------------------------------------------------------------------------------
>>> components_found
{'Voltage_Source': ['4A'], 'Resistor': ['1B', '1F'], 'Inductor': ['1C', '1H'], 'Capacitor': ['4E']}
--------------------------------------------------------------------------------------

From this list, each component can be given a name as they have a specific index in a list.

Finally, to create a dictionary of all the components found. Here the unique identification will be the position in the spreadsheet:
--------------------------------------------------------------------------------------
component_objects={}
for items in components_found.keys():
    for c1 in range(len(components_found[items])):
        component_objects[components_found[items][c1]]=component_list[items](c1+1, components_found[items][c1])
--------------------------------------------------------------------------------------

A quick explanation to what I have done:

1. components_found[items] are the different types of components - voltage source, resistors etc.
2. components_found[items][c1] are the positions of each of these components. So these are the keys of the dictionary component_objects.
3. component_list[items] is the value of the dictionary item corresponding to the component type - and this is a class constructor. This contructor takes the values of the index and the position.
This is the final result:
--------------------------------------------------------------------------------------
>>>
Inductor is  L1  located at  1C
Resistor is  R1  located at  1B
Resistor is  R2  located at  1F
Inductor is  L2  located at  1H
Capacitor is  C1  located at  4E
Voltage Source is  V1  located at  4A
--------------------------------------------------------------------------------------

For the circuit below

Circuit Parameters - II

The next step is to write the code such that all elements are identified and parameters are obtained. In C++ the concept that I followed was that every element was an object - a resistor, an inverter etc. There was three levels of data transfer to these objects. The first was when they were initialized. The second was when the parameters and initial conditions they contained was transferred to the system matrices for solving the ODEs and third was when the results of the ODE was transferred back to the objects to update the values of voltage/current etc.

In C++, the objects were created manually. In Python, I would like the objects to be created automatically from the network layout in the CSV file.

So, testing how to do this first step. A little piece of code to see how automatically the objects can be created and stored. This code is too ridiculously simple to put on Git, so this is it:

-----------------------------------------------------------------------------------------------------------------
#! /usr/bin/env python
import sys, math

class Resistor:
    def __init__(self, res_index):
        self.res_number=res_index
    def display(self):
        print "Resistor is ",
        print "R"+str(self.res_number)

res_list=[]
for c1 in range(1, 5):
    res_name="R"+str(c1)
    res_name=Resistor(c1)
    res_list.append(res_name)

print res_list
for res in res_list:
    res.display()
-----------------------------------------------------------------------------------------------------------------

Here, I am creating a class "Resistor" which has only one data element - its index. So the resistors will be called R1, R2, etc.

I create a list of resistors res_list and create resistors R1 to R4. Also, objects are created with that tag and added to res_list.

Here is the output:
-----------------------------------------------------------------------------------------------------------------
>>>
[<__main__.Resistor instance at 0x02A1F4E0>, <__main__.Resistor instance at 0x02A1F508>, <__main__.Resistor instance at 0x02A1F530>, <__main__.Resistor instance at 0x02A1F558>]
Resistor is  R1
Resistor is  R2
Resistor is  R3
Resistor is  R4
-----------------------------------------------------------------------------------------------------------------

res_list is a list with instances of the class Resistor. But importantly, when I access the method display of the class Resistor by res.display(), it does give me the correct resistor labels.

So now let me put everything in the spreadsheet into objects.

Circuit Parameters

After loop identification, now comes the time to input the parameters of the circuit.

One very nice thing about most circuit simulators is the dialog box that opens up with each element with all the parameters. So essentially, I need to put these features into my circuit simulator:

1. The user should only indicate the element at a given position.
2. We need to then generate a list of all the elements found, names for them, their positions in the spreadsheet and finally their parameters with some to be defaults.
3. With the case of elements like diodes, IGBTs and others that have polarities or certain ways in which they are connected, the polarity can be specified in the separate dialog.

For multiport elements like machines, transformers, there will have to be more than one tag and these will have to be translated. Things would have been much more convenient with a GUI.

This will be my first approach:

1. Create an index of names - "Resistor", "Inductor", "Capacitor", "Voltage_Source" etc.
2. The network interpreter will divide the circuit into three types of elements - "wire", "jump" and elements such as the above.
3. Each time an element is found, it will be assigned a name that creates an object of it - like R1, R2, C1, etc.
4. The program will create another spreadsheet with all the element names, their positions and parameter values in separate columns.
5. The user has to modify these values and continue with the simulation.

For passive circuits with only resistors, inductors, capacitors and voltage sources, I don't see much of a problem. However, there would be a problem with machines for example, a three-phase synchronous generator. So the stator will have three connections and the rotor will have two. How do I map these connections on a spreadsheet?

Loop identification - XIV

Time for some testing.

Circuit 1 - Single phase diode rectifier

Result:

>>>
Number of nodes 6
Number of branches 9
Number of loops 5
**************************************************
1K 2K 3K 4K 5K 6K 7K 8K 9K 10K 11K 11L 11M 10M 9M 8M 7M 6M 5M 4M 3M 2M 1M 1L 1K
1K 1J 1I 2I 3I 4I 5I 6I 7I 8I 9I 10I 11I 11J 11K 10K 9K 8K 7K 6K 5K 4K 3K 2K 1K
1K 1J 1I 1H 1G 1F 1E 2E 3E 4E 5E 6E 7E 8E 9E 10E 11E 11F 11G 11H 11I 11J 11K 10K 9K 8K 7K 6K 5K 4K 3K 2K 1K
1K 1J 1I 2I 3I 4I 5I 6I 6H 7B 7A 6A 5A 5B 5C 5D 5E 6E 7E 8E 9E 10E 11E 11F 11G 11H 11I 11J 11K 11L 11M 10M 9M 8M 7M 6M 5M 4M 3M 2M 1M 1L 1K
1K 1J 1I 1H 1G 1F 1E 2E 3E 4E 5E 5D 5C 5B 5A 6A 7A 7B 6H 6I 7I 8I 9I 10I 11I 11J 11K 11L 11M 10M 9M 8M 7M 6M 5M 4M 3M 2M 1M 1L 1K


One additional loop generated but result is OK.


Circuit 2 - Three phase diode rectifier

Result:

>>>
Number of nodes 10
Number of branches 15
Number of loops 9
**************************************************
1M 1L 1K 1J 1I 2I 3I 4I 5I 6I 6H 7B 7A 8A 9A 9B 6L 6M 5M 4M 3M 2M 1M
1M 1L 1K 1J 1I 1H 1G 1F 1E 2E 3E 4E 5E 5D 5C 5B 5A 6A 7A 8A 9A 9B 6L 6M 5M 4M 3M 2M 1M
11O 11P 11Q 10Q 9Q 8Q 7Q 6Q 5Q 4Q 3Q 2Q 1Q 1P 1O 2O 3O 4O 5O 6O 7O 8O 9O 10O 11O
1M 1L 1K 1J 1I 2I 3I 4I 5I 6I 7I 8I 9I 10I 11I 11J 11K 11L 11M 10M 9M 8M 7M 6M 5M 4M 3M 2M 1M
1M 1L 1K 1J 1I 1H 1G 1F 1E 2E 3E 4E 5E 6E 7E 8E 9E 10E 11E 11F 11G 11H 11I 11J 11K 11L 11M 10M 9M 8M 7M 6M 5M 4M 3M 2M 1M
1M 1L 1K 1J 1I 2I 3I 4I 5I 6I 7I 8I 9I 10I 11I 11J 11K 11L 11M 11N 11O 11P 11Q 10Q 9Q 8Q 7Q 6Q 5Q 4Q 3Q 2Q 1Q 1P 1O 1N 1M
1M 1L 1K 1J 1I 2I 3I 4I 5I 6I 7I 8I 9I 10I 11I 11H 11G 11F 11E 10E 9E 8E 7E 6E 5E 5D 5C 5B 5A 6A 7A 8A 9A 9B 6L 6M 5M 4M 3M 2M 1M
1M 1L 1K 1J 1I 1H 1G 1F 1E 2E 3E 4E 5E 6E 7E 8E 9E 10E 11E 11F 11G 11H 11I 11J 11K 11L 11M 11N 11O 11P 11Q 10Q 9Q 8Q 7Q 6Q 5Q 4Q 3Q 2Q 1Q 1P 1O 1N 1M
1M 1L 1K 1J 1I 1H 1G 1F 1E 2E 3E 4E 5E 6E 7E 8E 9E 10E 11E 11F 11G 11H 11I 10I 9I 8I 7I 6I 6H 7B 7A 8A 9A 9B 6L 6M 5M 4M 3M 2M 1M


Additional 3 loops generated but result is OK.



Circuit 3 - Dc-dc boost converter

Result:

>>>
Number of nodes 4
Number of branches 6
Number of loops 3
**************************************************
1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11C 11B 11A 10A 9A 8A 7A 6A 5A 4A 3A 2A 1A 1B 1C 1D
11F 11G 11H 10H 9H 8H 7H 6H 5H 4H 3H 2H 1H 1G 1F 2F 3F 4F 5F 6F 7F 8F 9F 10F 11F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 10H 9H 8H 7H 6H 5H 4H 3H 2H 1H 1G 1F


The exact number of loops! This happens quite rarely though.


Circuit 4 - Dc-dc boost converter feeding a single-phase converter without FWDs

Result:
>>>
Number of nodes 14
Number of branches 21
Number of loops 12
**************************************************
1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11C 11B 11A 10A 9A 8A 7A 6A 5A 4A 3A 2A 1A 1B 1C 1D
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 10H 9H 8H 7H 6H 5H 4H 3H 2H 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 10J 9J 8J 7J 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 11K 11L 11M 11N 10N 9N 8N 7N 6N 5N 4N 3N 2N 1N 1M 1L 1K 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 11K 11L 11M 11N 11O 11P 11Q 11R 10R 9R 8R 7R 6R 5R 4R 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 11K 11L 11M 11N 10N 9N 8N 7N 6N 6O 7U 7V 8V 9V 9U 6K 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 11K 11L 11M 11N 11O 11P 11Q 11R 10R 9R 8R 7R 6R 5R 5S 5T 5U 5V 6V 7V 8V 9V 9U 6K 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 10J 9J 8J 7J 6J 6K 9U 9V 8V 7V 7U 6O 6N 5N 4N 3N 2N 1N 1M 1L 1K 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 10J 9J 8J 7J 6J 6K 9U 9V 8V 7V 6V 5V 5U 5T 5S 5R 4R 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 11K 11L 11M 11N 10N 9N 8N 7N 6N 6O 7U 7V 6V 5V 5U 5T 5S 5R 4R 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F
1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 11E 11F 11G 11H 11I 11J 11K 11L 11M 11N 11O 11P 11Q 11R 10R 9R 8R 7R 6R 5R 5S 5T 5U 5V 6V 7V 7U 6O 6N 5N 4N 3N 2N 1N 1M 1L 1K 1J 1I 1H 1G 1F


Three additional loops generated but result is OK.



Circuit 5 - Dc-dc boost converter feeding a three phase three level diode clamped inverter connected to grid

Result (I am not going to check this!):

>>>

Number of nodes 48

Number of branches 72

Number of loops 70

**************************************************

1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25C 25B 25A 24A 23A 22A 21A 20A 19A 18A 17A 16A 15A 14A 13A 12A 11A 10A 9A 8A 7A 6A 5A 4A 3A 2A 1A 1B 1C 1D

23J 23K 23L 22L 21L 21K 21J 22J 23J

21R 22R 23R 23S 23T 22T 21T 21S 21R

21Z 22Z 23Z 23AA 23AB 22AB 21AB 21AA 21Z

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

5J 5K 5L 4L 3L 3K 3J 4J 5J

9J 10J 11J 11K 11L 10L 9L 9K 9J

17J 17K 17L 16L 15L 15K 15J 16J 17J

3R 4R 5R 5S 5T 4T 3T 3S 3R

11R 11S 11T 10T 9T 9S 9R 10R 11R

15R 16R 17R 17S 17T 16T 15T 15S 15R

5Z 5AA 5AB 4AB 3AB 3AA 3Z 4Z 5Z

9Z 10Z 11Z 11AA 11AB 10AB 9AB 9AA 9Z

17Z 17AA 17AB 16AB 15AB 15AA 15Z 16Z 17Z

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 6J 5J 5K 5L 4L 3L 3K 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 22Z 21Z 20Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 19K 19L 19M 19N 18N 17N 16N 15N 14N 13N 13O 15G 15F 14F 13F 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 6R 5R 4R 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 19K 19L 19M 19N 18N 17N 16N 15N 14N 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 11F 10F 9F 9G 11AE 11AD 10AD 9AD 8AD 7AD 7AC 7AB 7AA 7Z 6Z 5Z 5AA 5AB 4AB 3AB 3AA 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 22Z 21Z 20Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 10AD 9AD 8AD 7AD 7AC 7AB 7AA 7Z 6Z 5Z 5AA 5AB 4AB 3AB 3AA 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 6R 5R 5S 5T 4T 3T 3S 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 20J 21J 22J 23J 24J 25J 25K 25L 25M 25N 25O 25P 25Q 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 23AA 23AB 22AB 21AB 21AA 21Z 20Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 18J 17J 17K 17L 16L 15L 15K 15J 14J 13J 12J 11J 10J 9J 8J 7J 6J 5J 5K 5L 4L 3L 3K 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 6J 5J 5K 5L 4L 3L 3K 3J 2J 1J 1K 1L 1M 1N 1O 1P 1Q 1R 1S 1T 1U 1V 1W 1X 1Y 1Z 2Z 3Z 4Z 5Z 6Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 14V 15V 16V 17V 18V 19V 19U 19T 19S 19R 20R 21R 21S 21T 22T 23T 23S 23R 24R 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 23AA 23AB 22AB 21AB 21AA 21Z 20Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 6R 5R 4R 3R 2R 1R 1S 1T 1U 1V 1W 1X 1Y 1Z 2Z 3Z 4Z 5Z 6Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 22Z 21Z 20Z 19Z 18Z 17Z 17AA 17AB 16AB 15AB 15AA 15Z 14Z 13Z 12Z 11Z 10Z 9Z 8Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 13W 12G 12F 13F 14F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 18J 17J 16J 15J 14J 13J 12J 11J 11K 11L 10L 9L 9K 9J 8J 7J 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 19K 19L 19M 19N 18N 17N 16N 15N 14N 13N 13O 15G 15F 14F 13F 12F 12G 13W 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 6R 5R 5S 5T 4T 3T 3S 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 20J 21J 22J 23J 24J 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 23S 23T 22T 21T 21S 21R 20R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 18J 17J 17K 17L 16L 15L 15K 15J 14J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 14Z 15Z 15AA 15AB 16AB 17AB 17AA 17Z 18Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 18J 17J 17K 17L 16L 15L 15K 15J 14J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 10Z 9Z 8Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 8J 9J 10J 11J 12J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 14Z 15Z 15AA 15AB 16AB 17AB 17AA 17Z 18Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 8J 9J 10J 11J 12J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 10Z 9Z 8Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 6J 5J 5K 5L 4L 3L 3K 3J 2J 1J 1K 1L 1M 1N 1O 1P 1Q 1R 2R 3R 4R 5R 6R 7R 7S 7T 7U 7V 8V 9V 10V 11V 12V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 22Z 21Z 20Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 10F 11F 12F 13F 14F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 6J 5J 5K 5L 4L 3L 3K 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 22Z 21Z 20Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 10F 11F 12F 12G 13W 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 6R 5R 4R 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 18R 17R 17S 17T 16T 15T 15S 15R 14R 13R 12R 11R 10R 9R 8R 7R 7S 7T 7U 7V 8V 9V 10V 11V 12V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 13W 12G 12F 11F 10F 9F 9G 11AE 11AD 10AD 9AD 8AD 7AD 7AC 7AB 7AA 7Z 6Z 5Z 4Z 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 18J 17J 16J 15J 14J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 14Z 15Z 16Z 17Z 18Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 18J 17J 16J 15J 14J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 11AA 11AB 10AB 9AB 9AA 9Z 8Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 18J 17J 16J 15J 14J 13J 12J 11J 11K 11L 10L 9L 9K 9J 8J 7J 7K 7L 7M 7N 8N 9N 10N 11N 12N 13N 13O 15G 15F 14F 13F 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 19K 19L 19M 19N 18N 17N 16N 15N 14N 13N 13O 15G 15F 14F 13F 12F 11F 10F 9F 9G 11AE 11AD 10AD 9AD 8AD 7AD 7AC 7AB 7AA 7Z 6Z 5Z 4Z 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 18J 17J 17K 17L 16L 15L 15K 15J 14J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 14R 15R 15S 15T 16T 17T 17S 17R 18R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 18J 17J 17K 17L 16L 15L 15K 15J 14J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 12R 11R 10R 9R 8R 7R 7S 7T 7U 7V 8V 9V 10V 11V 12V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 8J 9J 10J 11J 12J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 14R 15R 15S 15T 16T 17T 17S 17R 18R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 8J 9J 10J 11J 12J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 12R 11R 10R 9R 8R 7R 7S 7T 7U 7V 8V 9V 10V 11V 12V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 14V 15V 16V 17V 18V 19V 19U 19T 19S 19R 18R 17R 16R 15R 14R 13R 13S 15AH 15AI 14AI 13AI 13AH 13AA 13Z 14Z 15Z 16Z 17Z 18Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 14V 15V 16V 17V 18V 19V 19U 19T 19S 19R 18R 17R 16R 15R 14R 13R 13S 15AH 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 11AA 11AB 10AB 9AB 9AA 9Z 8Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 14V 15V 16V 17V 18V 19V 19U 19T 19S 19R 18R 17R 16R 15R 14R 13R 12R 11R 11S 11T 10T 9T 9S 9R 8R 7R 6R 5R 4R 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 8R 9R 9S 9T 10T 11T 11S 11R 12R 13R 13S 15AH 15AI 14AI 13AI 13AH 13AA 13Z 14Z 15Z 16Z 17Z 18Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 8R 9R 9S 9T 10T 11T 11S 11R 12R 13R 13S 15AH 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 11AA 11AB 10AB 9AB 9AA 9Z 8Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 25S 25T 25U 25V 25W 25X 25Y 25Z 24Z 23Z 22Z 21Z 20Z 19Z 18Z 17Z 17AA 17AB 16AB 15AB 15AA 15Z 14Z 13Z 12Z 11Z 10Z 9Z 8Z 7Z 6Z 5Z 5AA 5AB 4AB 3AB 3AA 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 18R 17R 17S 17T 16T 15T 15S 15R 14R 13R 13S 15AH 15AI 14AI 13AI 13AH 13AA 13Z 14Z 15Z 15AA 15AB 16AB 17AB 17AA 17Z 18Z 19Z 19AA 19AB 19AC 19AD 18AD 17AD 16AD 15AD 14AD 13AD 12AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 18R 17R 17S 17T 16T 15T 15S 15R 14R 13R 13S 15AH 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 10Z 9Z 8Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 18R 17R 17S 17T 16T 15T 15S 15R 14R 13R 12R 11R 10R 9R 8R 7R 6R 5R 5S 5T 4T 3T 3S 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 25K 25L 25M 25N 25O 25P 25Q 25R 24R 23R 22R 21R 20R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 6R 5R 5S 5T 4T 3T 3S 3R 2R 1R 1S 1T 1U 1V 1W 1X 1Y 1Z 2Z 3Z 3AA 3AB 4AB 5AB 5AA 5Z 6Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 18J 17J 16J 15J 14J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 14R 15R 16R 17R 18R 19R 19S 19T 19U 19V 18V 17V 16V 15V 14V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 18J 17J 16J 15J 14J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 12R 11R 11S 11T 10T 9T 9S 9R 8R 7R 7S 7T 7U 7V 8V 9V 10V 11V 12V 13V 13W 12G 12F 11F 10F 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 25G 25H 25I 25J 24J 23J 23K 23L 22L 21L 21K 21J 20J 19J 19K 19L 19M 19N 18N 17N 16N 15N 14N 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 6J 5J 4J 3J 2J 1J 1K 1L 1M 1N 1O 1P 1Q 1R 1S 1T 1U 1V 1W 1X 1Y 1Z 2Z 3Z 3AA 3AB 4AB 5AB 5AA 5Z 6Z 7Z 7AA 7AB 7AC 7AD 8AD 9AD 10AD 11AD 11AE 9G 9F 8F 7F 6F 5F 4F 3F 2F 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 18J 17J 17K 17L 16L 15L 15K 15J 14J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 10Z 9Z 8Z 7Z 6Z 5Z 5AA 5AB 4AB 3AB 3AA 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 14N 15N 16N 17N 18N 19N 19M 19L 19K 19J 18J 17J 17K 17L 16L 15L 15K 15J 14J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 12R 11R 10R 9R 8R 7R 6R 5R 5S 5T 4T 3T 3S 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 8J 9J 10J 11J 12J 13J 13K 17AH 17AI 16AI 15AI 14AI 13AI 13AH 13AA 13Z 12Z 11Z 10Z 9Z 8Z 7Z 6Z 5Z 5AA 5AB 4AB 3AB 3AA 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 15G 13O 13N 12N 11N 10N 9N 8N 7N 7M 7L 7K 7J 8J 9J 10J 11J 12J 13J 13K 17AH 17AI 16AI 15AI 15AH 13S 13R 12R 11R 10R 9R 8R 7R 6R 5R 5S 5T 4T 3T 3S 3R 2R 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 14V 15V 16V 17V 18V 19V 19U 19T 19S 19R 18R 17R 16R 15R 14R 13R 13S 15AH 15AI 16AI 17AI 17AH 13K 13J 12J 11J 11K 11L 10L 9L 9K 9J 8J 7J 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 12G 13W 13V 12V 11V 10V 9V 8V 7V 7U 7T 7S 7R 8R 9R 9S 9T 10T 11T 11S 11R 12R 13R 13S 15AH 15AI 16AI 17AI 17AH 13K 13J 12J 11J 11K 11L 10L 9L 9K 9J 8J 7J 6J 5J 4J 3J 2J 1J 1I 1H 1G 1F

1F 1E 1D 2D 3D 4D 5D 6D 7D 8D 9D 10D 11D 12D 13D 14D 15D 16D 17D 18D 19D 20D 21D 22D 23D 24D 25D 25E 25F 24F 23F 22F 21F 20F 19F 18F 17F 16F 15F 14F 13F 12F 11F 10F 9F 9G 11AE 11AD 12AD 13AD 14AD 15AD 16AD 17AD 18AD 19AD 19AC 19AB 19AA 19Z 18Z 17Z 17AA 17AB 16AB 15AB 15AA 15Z 14Z 13Z 12Z 11Z 10Z 9Z 8Z 7Z 6Z 5Z 5AA 5AB 4AB 3AB 3AA 3Z 2Z 1Z 1Y 1X 1W 1V 1U 1T 1S 1R 1Q 1P 1O 1N 1M 1L 1K 1J 1I 1H 1G 1F