I am trying to move whatever I can to python. The main reason being that I want it to be free, and not require expensive commercial software. So recently I took the time to revisit my Mathematica code for the tune diagram and port it to Python. Basically I rewrote the whole thing and it has the nice feature that you can overlay it on top of whatever you want to plot.here you find my python code for plotting a resonance line diagram as the one found above.

The code should be self-explanatory, when you run the script directly with the option -o shows an example plot. When you import it, you can use the function plotTuneDiagram(maxOrder,xlim=[0,1],ylim=[0,1],tickOrders=False,tuneLineColor="black")

Parameters are

• maxOrder the maximum order of resonance line to be displayed
• xlim,ylim the intervals in horizontal and vertical tune in which to plot
• tickOrders whether or not to place x- and y labels on full fractions up to selected order
• tuneLineColor color for the tune lines, sensible when plotting on top of measurement or simulation data.

I work a lot on MacOS where I write code that I want to use on linux later. Unfortunately some of the normal timing functions are missing on MacOS. I don’t quite remember which. So I have some crude platform independent code for timing c++ code. I am aware it does not really count the CPU usage, but putting it around code you want to time you can still get a feeling for how much time is spent in that part of your code.

class pTimer {
 timeval t1, t2;

public:
 double t;
 pTimer(): t(0){};
 void start() {gettimeofday(&t1, NULL);};
 void stop() {gettimeofday(&t2, NULL);
 t +=
 (t2.tv_sec -
 t1.tv_sec) * 1000.0 + (t2.tv_usec - t1.tv_usec) / 1000.0;};
 void reset() {t=0;};
 void restart() {t=0;gettimeofday(&t1, NULL);};
};

it is used like this:

pTimer t1;
t1.start();
<computationally intensive part of the code>
t1.stop();
printf("took %f miliseconds", t1.t);

restart(); sets the timer to zero and starts it at the same time, using start(); again will add to the time already on the counter (useful if you want to accumulate time from different parts of your source in one timer).

I tend to forget how to recover a frequency spectrum from a series of data points using the FourierSeries (read as: I forget how to compute the frequency corresponding to a specific channel in the fourier series). To stop me from forgetting I came up with the following quick and dirty module. It takes a one-dimensional list of data points that were taken over a time interval of timelength and returns a list containing pairs of {Frequency, complex amplitude}. As you can see the frequency is simply (number of data point – 1) divided by the time interval covered by the data. A quick plausibility check confirms this result: Data point 0 corresponds to the offset of the fourier series (frequency 0). The maximum observable frequency (found at position (number of data points / 2)) is (number of data points / 2) per timelength and in agreement with the Nyquist frequency.

FourierFreqs[data_, timelength_] :=
Module[{},
Transpose[
{((Range[Length[data]] - 1))/timelength,
Fourier[data]}
]
]

For several years now I am frustrated with how Mathematica plots look. They are sufficient to get an impression of what your data might look like, but they are as far from publication quality as a plot can get. While it is relatively easy to change how a plot looks, the PlotLegends package that comes with Mathematica is not at all nice and can virtually not be customized to give a nice legend. The default look is similar to the following example, which somehow reminds you of excel.

After playing around with Mathematica a bit, I came up with a code that produces the following style of plots:

The code does not do much apart from putting a Grid with plot styles and example icons above the plot. Still I consider the result a major improvement in comparison with the standard Mathematica plot legend.

You can find a copy of my code which also produces the sample plot above at my dropbox.

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.