Friday, April 28, 2017

Command line versus web application

The development of the web application for the circuit simulator is under way and can be found on my GitHub account:

For a while, both command line and the web app will be available simultaneously for those who would prefer command line. The main disadvantage of the web application is the need to have Django installed. Though not a significant task, for someone who doesn't want a server running on their computer, it may not be the best option. I am still thinking of ways to automate the setup of the Django server so that maybe a single script could have everything up and going.

The first few steps in this direction seem promising. For example, so far, I have been able to replace the circuit_inputs.csv file. When a new simulation is created, the first form is the one that contains the fields similar to circuit_inputs.csv. Django provides features where error messages can be automatically generated when the user enters wrong data. For example, the user needs to specify the working directory that will contain the circuit schematic spreadsheets and other files. This working directory will be used also to write the output data file and therefore needs to have write permission to it. Since this Django app should be preferably run as user rather than root or Administrator, the working directory chosen should be writable by a user. This check is performed at the model level where a validation method has been written. This validation method writes a dummy file just to check if the app can write into the directory and failure to do so results in an error which shows up in the form. So the user can't submit a form without choosing an appropriate directory.

The user interface is divided into several segments. The first form above will only ask for basic parameters like time duration, time step, data storage interval, working directory etc. Once done, these parameters will appear as a table and the next form will ask for the user to choose the circuit spreadsheets from a file browser form. The user can still go back and edit the simulation parameters with an Edit parameter option. The file browser button makes life easier in choosing files rather than write them in circuit_inputs.csv. It would also be possible to check if the files are .csv files an also if they actually exist in the working directory.

The same goes for control files. They will have similar file browser buttons that can allow the user to choose Python control code.

As compared to the command line, the major advantage is that errors are pointed out right away and in a little more friendlier manner. The command line does provide error messages and I will try to bring it close to the web app in terms of how immediately the errors are pointed out. This might save the user progressing to the last stage and then seeing the simulator point out an error in the schematic which should have been picked up right away after the circuit_inputs.csv file was provided.

In the web app, errors in the circuit file and also errors in parameters can be generated by processing all these files. The same checks could be imposed - paired jump labels, closed branches etc. Since, a circuit can only really be checked after all circuit spreadsheets have been read and processed, this error generation will need to take place at a higher level.

What will be challenging is to generate parameters for all the circuit spreadsheets. The simplest way to do this will be create models for every component and add them to the circuit files as ManyToMany objects. This also allows a ModelForm to be created to every component model and further to connect each component to the circuit spreadsheet. Eventually, the parameters obtained from the ModelForms will need to be returned to the classes in circuit_elements. Which means the read_parameter methods of every class will need to be changed or overloaded for an interface to the web app.

Django seems to provide a fairly convenient and hierarchical structure.

Simulation Case  ---> Circuit files ---> Component objects
                            ---> Control files ---> Control objects

Monday, April 17, 2017

User interface

One of the biggest drawbacks of the circuit simulator has been the lack of a graphical user interface. For a Linux user, running a software from a command line is not too much of a hassle, but for users of other operating systems, it usually is. A graphical user interface where one or a few windows gives you everything you need is what everyone wants. Something like that may be too much to build at this point of time, but I have been considering options that can provide a consolidated interface without a full-scale graphical component.

Since the time I have been using Django for web development, I have been thinking of using it to create a user interface for the simulator. Django is fairly easy to install in any operating system. It is fairly easy to setup particularly as a standalone server with the SQLite database good enough for development applications and also easy to configure. The database setup scripts are not too hard. And once the server is running, you could access the app through a web browser.

There are aspects of the simulator that are good the way they are. For example, designing circuits through spreadsheets. That will remain for a long time as it is fairly convenient and also spreadsheet software are available for any operating system. So trying to replace the design of the circuit at the current moment is not really necessary. However, many other aspects are. For example, entering the circuit parameters. This could be made much more interactive through a web app. Once the circuit design is processed, instead of asking the user to change the parameters in the spreadsheet, an interactive form can be designed to help the user out with entering circuit data. The next is in designing controllers. Right now, every controller has a descriptor spreadsheet which lists the inputs, outputs and also special variables. This process can be made interactive as the user can be allowed to choose meters from any spreadsheet or outputs from any sheet. The last and the most important is the plotting of circuit data. Using Gnuplot is extremely convenient but for most this just isn't interactive enough. If a plotting interface can be built into the web app where a user can choose the x and y axis of every plot and simply click a button to get the plot either embedded in the web browser or as a separate window, it would be much simpler. Eventually, the result is what is most important to the user, and I need to make the viewing of results a little easier.

Since this simulator is for large circuits with a large amount of data being generated, trying to run the simulator remotely over a server is not a feasible option. It may be for smaller circuits that do not require much data being transmitted over the network but for larger circuits, it wouldn't work. So the purpose of using Django is merely to build an interface that is almost graphical but without using something like Tkinter or PyQt that would take me a lot of time.

Django allows the user to enter data in forms similar to any web form. The only additional layer is to make the forms relevant to the circuit by creating a model layer. Moreover, this model layer will have to be dynamic as every circuit is unique. Therefore, Django will merely replace the cells in a spreadsheet with HTML forms that hook up to a database.

Sunday, February 5, 2017

Releasing the book

I am happy to announce the release of my book "Simulating non-linear circuits with Python Power Electronics: an open source simulator based on Python". The book has been self-published and released on Gumroad. The link is:
To read a sample chapter, I have released Chapter 4 of the book on my website:
Follow my Facebook page for continuous updates:

The outline of the book is below:

Chapter 1 introduces the concept of simulation and describes the challenges in circuit simulation. Python Power Electronics as an open source circuit simulator is proposed with its objectives and target audience.

Chapter 2 provides an overview of the Python programming language. For a detailed tutorial, a reader is recommended to either read a book on Python programming or follow an online tutorial on the internet. The purpose of the chapter is to enable the reader to understand the code segments that will be provided in the subsequent chapters that deal with user-defined control functions and the case study.

Chapter 3 describes the interface that the simulator uses to interact with the user. The chapter describes the philosophy behind choosing spreadsheets as the mode of extracting information from the user. Spreadsheets are used by the user to enter simulation parameters,circuit schematics, parameters of the components in the circuit schematics and also the structure of control functions. The chapter describes how the structure of every component class in the simulator library and how the data entered by the user is processed by each component class. The chapter also describes the concept of how classes are instantiated for every component found resulting in objects and how these objects are referenced by the simulator. The chapter describes the execution flow in the simulator and how the simulator processes the data provided by the user and makes it available to the core simulation engine. The chapter does not describe how user-defined control functions are processed as the whole of Chapter 4 is dedicated for this purpose.

Chapter 4 describes how a user can write control functions for a simulation. Chapter 3 has described which of the circuit components can be controlled externally. Besides these controllable components, a control function need not perform a control action, but can instead be used to process simulation data or perform calculations. The chapter describes how the control functions have to be written as Python 2 files and specified in the simulation parameter spreadsheet. Every control function will have an interface to the simulation in terms of inputs and outputs and this interface is described by a spreadsheet called a descriptor. Besides inputs and outputs, every control function can use certain types of variables that perform special functions. The chapter describes the importance of each type of control variable and how they are implemented in the simulator. The chapter describes how control functions are scheduled by the simulator using time events and with an example, it is described how the simulator ensures that the control functions execute at the desired time instant. A simple example has been provided to describe how control functions can be interfaced with the simulation and also with each other.

Chapter 5 describes how a user can simulate a circuit with a power electronic converter. The example chosen has been a shunt connected three-phase VAR compensator realized using a two-level voltage source converter in a three-phase system. The voltage source converter consists of controllable ideal switches that are turned on and turned off by pulse width modulation. The chapter describes how the user can build this simulation in stages such that every new subsystem added to the circuit can be verified. The chapter also describes how the user can write control functions with detailed examples of each control function in the simulation and also design the control interfaces through descriptors. Every stage of the chapter contains simulation results to show how the project develops. Through this example, every feature of the simulator has been described with details so that users can develop their own simulations.

Chapter 6 describes how the simulator processes the circuit schematics that the user enters in spreadsheets. The connectivity information is extracted from the circuit schematics in the form of nodes, branches and loops. Nodes, branches and loops are used to perform circuit analysis through loop analysis and nodal analysis which are described in the next chapters. The chapter describes through sample circuits, the algorithms used to determine the nodes, branches and loops. The chapter introduces the concept of the LoopMap which is used for performing loop analysis in Chapter 7 and the concept of KCLBranchMap which is used for performing nodal analysis in Chapter 8.

Chapter 7 describes how loop analysis is performed in the simulator. The chapter describes how the matrix equation for performing loop analysis is generated from the LoopMap described in Chapter 6. A brief description is provided about how the matrices in this equation are transformed using row operations such that they can be solved by using numerical integration techniques. The chapter describes how loop currents and branch currents in the circuit can be mapped which allows for calculation of branch currents from loop currents and vice versa. The chapter describes with an example how time constants of branches of the circuit can make the simulation unstable and introduces the concept of a stiff loop. By providing a sample circuit and its corresponding LoopMap, the chapter describes the need to isolate stiff loops so as to be able to simulate a circuit. With this example, the concept of loop manipulations is described and with advanced examples, the effectiveness of the procedure is described. The chapter describes the limitation of loop analysis with another set of examples and therefore the need for nodal analysis.

Chapter 8 describes how nodal analysis can be used to determine the currents through stiff branches (that have a very low time constant) in the circuit. With the example of a simple buck converter, the chapter describes how loop analysis is insufficient in determining the conduction of power devices during switching events. The chapter then describes how nodal analysis can be used effectively in determining how power devices conduct and the transfer of current from one device to another. The chapter introduces the concept of events and how the matrix equations for the circuit will be constant until an event occurs. The chapter finally describes the logical flow of processes in the simulator as it performs loop analysis and nodal analysis one after the other.

Chapter 9 will conclude the book by highlighting the advantages of the simulator and the future development intended in this project.

Saturday, January 7, 2017

The book

Hope everyone had a good new year celebration.

This January, my goal is to complete the book for publication in February. So that means simulation of new circuits will come to a temporary stop. The first revision of the book is ready and for the table of contents check out:

A rigorous proof read is currently in progress and should be complete in two weeks. After that, another two weeks will be spent in editing the book, arranging the layout and ensuring a printable camera ready format.

The book will be self-published on Amazon using CreateSpace where they will print copies of the book on demand. Besides this I am also looking at other avenues where a simple PDF can be made available for those not wanting to buy a printed book but wanting simulation tutorials and code along with the pdf of the book. Still need to work out the details of that but that will probably follow only after the book has been released.

As for the book, I will be providing one chapter of the book on my site for download so that anyone can get a flavour of the book. In the meantime, check out the short papers that have been uploaded on the above link. For regular updates, follow my facebook page:

Let's hope for a good 2017!

Saturday, November 26, 2016

Nonstiff loops

There was an issue that I partly solved and didn't rigorously check before and this was related to how non-stiff loops are solved. Nonstiff loops are those loops that have only non-stiff branches and therefore these loop currents will be those that have non-negligible values. Their solution is therefore critical to the simulation stability and accuracy.

This is the problem. Let us suppose there are four branches in parallel. One of the branches is the load resistor and is therefore small in value. The others are parasitic resistances that may be significantly large. These parallel branches may be connected to a larger circuit with inductances. If loops are to be written having only one of these parallel branches but with the rest of the circuit, each branch will have a different time constant which is the sum total of the inductance of the loop divided by the sum total of the resistance. A loop can only be solved as a differential equation if the time constant of the loop is smaller than around ten times the simulation time step. Theoretically, by Nyquist's criterion this would be twice, but in practice we need a margin of ten. If the time constant if less than ten times the simulation time step, the equation should be converted to a static equation and the inductance should be ignored as solving this as a differential equation will cause instability.

Now when there are parallel branches with different resistances but none of these resistances are large enough for the branches to be considered stiff (like voltmeter branches), any of these branches can appear in loops with the external circuit. Loops are completely random and therefore it is possible that a nonstiff loop containing inductance is formulated with a branch with high resistance. Such a loop will be approximated to a static equation. If care is not taken in formulating the loops, it might so happen that none of these parallel branches will appear with the external circuit in a differential equation. This means that a dynamic of the circuit has disappeared.

To ensure this doesn't happen, we use the concept that any loop in a circuit must follow the path of least resistance. Also, we need to ensure that every branch appears in at least one loop. To do this, divide loops into two types - those with more than two branches and those with only two branches. For loops with more than two branches, these play an important part in linking a circuit together. These therefore capture the dynamics of a circuit. It is extremely important that as far as possible, they have a time constant that can be solved as a differential equation. It may be possible that this may not happen, time constant is too low and the equation is solved as a static equation. If this happens, it means it is a bad selection of parameters and simulation time step. But, to minimize this occurrence, go through every branch in these loops and check if the branch is one of parallel connected branches between nodes. If so, check if the branch has minimum resistance. If not, exchange the branch with the branch that has minimum resistance. By doing so, as far as possible, loops with more than two branches will always follow the path of least resistance and therefore will be solvable as differential equations.

For the loops with only two branches. These are loops between branches connected in parallel between two nodes. If a number of branches are connected in parallel, the branch with the minimum resistance should be found. All loops between the parallel branches should be so chosen that they are between this branch with minimum resistance and all other branches. The reason, this branch with minimum resistance will be present in loops which link the circuit together and described above and therefore will introduce their dynamics into the parallel connected branches.

Now, by arranging the loops according to their time constants, it can be ensured that the circuit is always stable and dynamics are always captured when possible.

Thursday, November 17, 2016

Python 3 compatibility

Last weekend I gave a ten minute talk in PyCon Canada 2016. As usual met some wonderful people and attended some interesting talks. The video will not be online for a few weeks.

As usual a lot of items on the agenda. The simplest is continue building for larger systems. The next is something I have been putting off for quite a while but think I should get down to pretty soon - compatibility with Python 3. So far the simulator used Python 2 but this is now legacy software. All Linux OS ship with Python 3 and even my IDE complains of syntax errors when there is nothing wrong with the syntax except that it looks for Python 3. Will need to read into the differences between Python 2 and 3 to make sure this transition is smooth.

The next thing is a little more complicated. I have been trying to speed the simulator up. One simple way to do so is to try to store as many of the loops and computations in a dictionary so that they can be looked up rather than calculated every time. The only question is what is the limit of this storage and will I ever run out of memory? I am assuming that a dictionary will be stored in the heap which is limited by the RAM which nowadays is good enough. If however, this dictionary gets stored in the stack, it would be a serious problem as the stack is limited and running out of memory is possible. I will need to look into some analytic tools that can tell me how my simulator is performing with respect to memory - which functions use the most?

As always, follow me on LinkedIn or my Facebook page for regular updates:

Saturday, October 15, 2016


Been a while since I posted. To begin with, I am almost done writing a book on the circuit simulator. I put up the table of contents of the first draft on my site:

It will take me another 2-4 weeks to complete the first draft with all chapters. I hope the book will be published by February next year.

I released several versions of the software:

As of now the simulator works with three inverters. I will continue expanding the system with an increasing number of inverters to push the simulator to its limits.

I am scheduled to give a 10 minute talk on the simulator in PyCon Canada next month. My talk is on November 12 at 2:05pm. So if you are attending PyCon Canada, it would be great to meet up anyone interested in the circuit simulator. The schedule for PyCon Canada is:

The talk will be recorded and a video will be put up online.

Follow my Facebook page for regular updates on the simulator: