## [eispice] General Questions.

• From: Cyril Giraudon <cyril.giraudon@xxxxxxx>
• To: eispice@xxxxxxxxxxxxx
• Date: Sat, 18 Nov 2006 13:59:10 +0100

```Hi,

I like the idea I can simulate electrical circuits from a python shell.
I think you start a very useful job.

I work on scientific platforms for electromagnetism simulation and
python becomes my preferred language.
I have also began two wrappers around gnucap / ngspice with pyrex, but
by lack of time, those projects sleep :-( ....

I'd like to ask some questions about eispice :

1 -
Have you ever think of writing eispice entirely in python ? It could
seem ridiculous, but ...
I think there are several python packages very important in the python
scientific world :
- numpy (scientific array handling, http://numpy.scipy.org/);
- matplotlib (2D scientific plotting capabilities,
http://matplotlib.sourceforge.net/);
- scipy (general scientific tools based on numpy,
http://www.scipy.org/SciPy);
- pytables (hdf5 wrapper, hdf5 is a general file format for large data
writing, http://www.pytables.org/moin);

scipy (end perhaps numpy) comes with blas/lapack libraries (standard
c/fortran library for matrices).
You can invert matrices with scipy as if you work with matlab
(http://www.scipy.org/NumPy_for_Matlab_Users).
At the end of the linked page, you can read :

[V,D]=eig(a)

linalg.eig(a)

linalg.eig(a)

eigenvalues and eigenvectors of a

[V,D]=eigs(a,k)

find the k largest eigenvalues and eigenvectors of a

[Q,R,P]=qr(a,0)

(Q,R)=Sci.linalg.qr(a)

mat(...)

QR decomposition

[L,U,P]=lu(a)

(L,U)=Sci.linalg.lu(a) or
(LU,P)=Sci.linalg.lu_factor(a)

mat(...)

LU decomposition

Sci.linalg.cg

mat(...)

fft(a)

fft(a)

mat(...)

Fourier transform of a

I haven't benchmarked the LU decomposition, but it's fortran behind the
stage.
Apparently, you can use sparseLU from scipy :
http://svn.scipy.org/svn/scipy/tags/0.4.2/Lib/sandbox/pysparse/tests/test_superlu.py

Where does a circuit simulator need to be fast except for matrices
operations ?

The consequences are :
- development easier (scripting language);
- No compiled code;
- Cross platform;
- All devices models are written in python;
- no plug-in mechanism (only a good interface);
- Add a models on the fly;
- Perfect integration with python shells, development environments;
...

You probably know already a lot of what i've just said, but what are
your motivations for using C language ?
Does Eispice  must be very fast, flexible, modular ?

2-
I have taken a look at the following example

from eispice import *
d = deck("Tline Test")
d.Vs = V('vs', gnd, 0, pulse(0, 1, 15*nano, 1*nano))
d.Rs = R('vs', 'vi', 30)
d.Tg = T('vi', gnd, "vo", "0", 50, 5*nano, 0.5)
d.Rl = R('vo', gnd, 10*kilo)
d.Cl = C('vo', gnd, 5*pico)
d.tran(0.1*nano, 100*nano)
plot(d)
taken from http://www.thedigitalmachine.net/eispice.manual.html.

and I have read the sentence :
"Added a Tk based plotter that should run a lot faster than the old
gnuplot interface."

Do you really think Eispice must provide graphics capabilities ?
I have already discussed this point with al davis, gnucap developer,
(http://archives.seul.org/geda/dev/May-2006/msg00011.html).

I think, the circuit simulator itself, must do the minimum amount of the
task, furthermore in a python environment.
When the example demands a d.tran(0.1*nano, 100*nano), are you sure
Eispice must control the step of returned values ?
Has Eispice have to plot results ?

Imagine Eispice knows only simulate a [start, end] transient analysis
and return the last calculated value (it doesn't stock result in
memory). The python user would write the following code snippet :

import numpy

from pylab import *

import eispice

d = eispice.deck("Tline Test");
d.Vs = V('vs', gnd, 0, pulse(0, 1, 15*nano, 1*nano))
d.Rs = R('vs', 'vi', 30)
d.Tg = T('vi', gnd, "vo", "0", 50, 5*nano, 0.5)
d.Rl = R('vo', gnd, 10*kilo)
d.Cl = C('vo', gnd, 5*pico)

step = 0.1*nano
voArray = numpy.array(1000)
tArray = numpy.array(1000)
i = 0
# Run the simulation
for t in numpy.arange(0.1*nano, 100*nano, step):
d.tran(t, t+step)
tArray[i] = t
voArray[i] = d.getValue("vo")
# Why not change Rs value in function of vo values (linked elements) ?
i = i +1

# Plot the result
# http://matplotlib.sourceforge.net/screenshots.html
matplotlib.plot(tArray, voArray)
xlabel('time')
ylabel('Voltage (mV)')
grid('True')
show()

Yes, It's much longer, but Eispice code is "simpler" and the interaction
with the user is strong.

The questions are :
What does the core of the simulator have to perform ?
How the user can interact with a running simulation ?
How implement circuit linked elements (linked sources)?
External module : wave form creation, Eispice would accept only
discretized curves (array) ... ?

I wish I ask useful questions.

regards,

Cyril.

------------------------------------------------------------------
To unsubscribe from the eispice list send an email to:
eispice-request@xxxxxxxxxxxxx with 'unsubscribe' in the Subject field
```