[TerminalIPythonApp] Unrecognized flag: '-wthread'

Without this flag, the Mayavi plots lock up the UI and hangs. If you want to get the possibility back to rotate and play around with the plots, just start IPython the following way from now on:

ipython --pylab=qt

This will launch IPython with the Qt backend and threading. Using only –pylab does not include threading. For easy and quick access, add the following to a file named .bashrc in your home folder:

alias pylab='ipython --pylab=qt'

From now on you can launch IPython just by typing

pylab

in a terminal.

ImportError: No module named enthought.mayavi.mlab

Now, to avoid switching the import statement every time you switch systems, you can make Python check if one of the versions is installed during import. If it is not, we’ll tell it to try the other. This is done in this simple command:

try:
    from enthought.mayavi.mlab import *
except ImportError:
    from mayavi.mlab import *

Just replace any other similar import statements the same way and your code should once again be working across all your installations.

So here you go. A pendulum on a cart.

I won’t go into details about deriving and solving the Lagrange equation for this system now, but I might get back to that at a later time. And of course there will be some added controls to this so you could set the initial positions, velocities and stuff. Sometime later, I hope.

The first thing I noticed is that there is no problem using Qt Creator as an editor while compiling the MPI executable and running it from the command line. However, for the quick and easy testing of minor changes, running by pressing Ctrl + R in Qt Creator quickly came to a high place on my wish list.

After a quick search around the Internet, I found the necessary adjustments to make this exact thing happen. The steps are as follows:

Make Qt Creator use mpicxx instead of g++

To change the compiler in Qt Creator, you simply have to edit the .pro file of your project. Add the following lines, and Qt Creator will call mpicxx instead of g++:

# MPI Settings
QMAKE_CXX = mpicxx
QMAKE_CXX_RELEASE = $$QMAKE_CXX
QMAKE_CXX_DEBUG = $$QMAKE_CXX
QMAKE_LINK = $$QMAKE_CXX
QMAKE_CC = mpicc

QMAKE_CFLAGS = $$system(mpicc --showme:compile)
QMAKE_LFLAGS = $$system(mpicxx --showme:link)
QMAKE_CXXFLAGS = $$system(mpicxx --showme:compile) -DMPICH_IGNORE_CXX_SEEK
QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CXXFLAGS

This also sets the correct compile and link flags in addition to changing the linker to mpicxx as well. The DMPICH_IGNORE_CXX_SEEK flag is added to avoid some errors I experienced on Red Hat Linux 5.

Running the application with mpirun

Usually Qt Creator will simply run the generated executable after compiling, but to make use of multiple processors (which kind of is the whole point with MPI), you have to change the run settings of your project to a custom executable. This is done in the project configuration in Qt Creator under the Run tab for your project.

Add a Custom Executable run configuration and set the executable to /usr/bin/mpirun or any other path where mpirun resides on your system (run ‘which mpirun’ in a terminal to find it if you don’t know where it is). Then, set the arguments to

-n 2 yourexecutable

to run yourexecutable with 2 processors. Of course you’ll have to change yourexecutable to whatever your executable is named.

Adding a GUI to your MPI program

I advice you to not use MPI together with Qt GUI libraries. The reasons for this is that Qt has its own threading classes that are easier to use together with GUI elements in your application if you need them and the fact that if you want to run your app on any large scale cluster you might not be able to use Qt at all, depending on what packages are available on this cluster. A much better solution is to load config settings from a file in the INI format, using for instance the lightweight inih library and make this settings file writable from a Qt GUI application using QSettings to write this file.

The downside of this approach is that you won’t be able to implement any communication directly with the MPI process, but this could be worked around by for instance reading and writing to a progress status file if this is what you need.

However, it is not impossible to make Qt GUI applications play along with MPI, even though you might have to juggle a bit around with stuff to make it work flawlessly. Passing MPI broadcasts and such to all the other processes is definitely possible, and a relatively small example of how to do this is shown in this post by Tiffany Chong and Valencia Hare.

That’s why you can download Nanoparticles from Android market right now:

Download Nanoparticles from Android Market

In addition, I have been working on a Mac OS X port. This is still somewhat in an early stage, but should work on most machines. You can download the Mac OS X port for free here.

Both these version include the new party mode with new particles and new game rules. This should give you many more hours of fun particle-based gameplay.

After this I wanted to create a nice .dmg file for easy deployment on Mac OS X. Thankfully, this process is not hard either. I found this through the Qt Documentation, but it is actually simpler than it seems thanks to the macdeployqt tool. This is mentioned on the page, but I decided to give a more thorough walk through on how to use the tool here:

1. Build your application
2. In the build directory, run

   macdeployqt yourappname.app -dmg

   macdeployqt is found in the ~/Library/QtSDK/Desktop/Qt/474/gcc/bin folder (if that is where you installed Qt)

3. You should now have a nice yourappname.dmg file in the build directory. Open this up and check that your application runs from there.
4. If everything is working fine, you can do some prettifying of your .dmg file by opening it up using the Disk Utility and converting it to a Read/Write disk image.
5. Open your Read/Write disk image and create a shortcut to your Applications folder. This could either be done by dragging the Applications folder while holding the command key or by creating a symbolic link in terminal:

   ln -s /Applications ./Applications

6. Edit the icon size, background image, etc. by clicking Command + J to open the View Options. Also, use View -> Hide Toolbar and Hide Sidebar to hide the excessive toolbars from the disk image.
7. Close the image and use Disk Utility to convert it back to a compressed disk image.
8. Distribute your .dmg file.

If you need more details about the process and how deployment is performed, have a look in the Qt Docs.

I’ve only had a HTC Magic with no OpenGL capabilities available for testing, but still the game is running pretty good. This is giving me perhaps too high hopes about how it will perform on a stronger device, such as a Samsung Galaxy SII. I’ll try to get hold of a device like that soon.

In addition I’ve moved almost all the UI code in Nanoparticles over to QML. This finally makes the menus and game logic separated and also has made it a lot easier to add some transitions and user feedback to the UI elements.

I’ve only got a early alpha version ready at the moment, but I’ll probably need a lot of help testing how the game runs on different devices and setups. I will post back here as soon as I’ve got something for you to play with. Maybe I’ll even push it to Android Market in a not so distant future for early testing.

curl --head --header "User-Agent: blablabla" http://dragly.org/

I have no idea why this happens, but I was pointed to this solution in a forum which I forgot to bookmark. I hope this might help you out if you should run into the same problem.

Download Nanoparticles

You can read more about Nanoparticles and download it for other platforms on this page.

What solved my problem: Todo.txt. Why?

The solution for me has always been to have a todo list that I can look up whenever I’m wondering about what to do next. It is way too hard to stay focused on a task if I have to remind myself about what’s next all the time. Leaving later tasks in an organized list makes it possible for me to avoid these constant reminders and let me focus peacefully on one task at a time, knowing that I won’t forget the next important task.

However, keeping such a list can introduce another problem to solve: How can I store the list in an easily accessible place that makes it easy to review it, cross things off it, list only one project at a time and maybe only the top priorities?

The best option for availability is to have the list on a whiteboard next to my computer, but that reveals several problems. The whiteboard will be way too small no matter how large a whiteboard I buy, and it will not be easily synchronized. In other words, I will most likely need something that runs on my computer.

Several applications are available for this purpose, but I have yet to find one that works well on all my systems with synchronization. I’ve tried to set up manual synchronization of folders using services like Dropbox, Ubuntu One and SpiderOak, but after Getting Things Gnome on my laptop wrote over all my changes from my desktop and Tasque failed on me while syncing via Remember The Milk, I decided to go back to the good old “todo.txt” file in a folder on my computer.

This works fine, but it lacks some options to sort tasks after priority or project. However, there is a beautiful script application that has come to the rescue for me. Visit todo.txt to see what I’m talking about.

It’s basically a simple script that lets you keep your todo-list in a file for compatibility and availability between systems, while giving you the options to view, add and delete tasks via the command line.

This solves all problems with syncing and availability. Now I can leave the syncing to a system such as Ubuntu One without worrying about compatibility between my phone and my computer, and even be able to view, add and delete tasks without ever leaving the terminal.

And should I ever be on a system without the todo.txt script, I can always open the file in vim or view it with cat.

Task lists from code comments

What about task lists from code comments? I often leave comments in LaTeX-files, code files and Python scripts like this:

// TODO: Make a cup of coffee

Well, as I said, I’ve often got a terminal open when working on anything, so the best solution for me would be never to leave the terminal:

cat <<anyfileyoulike>> | grep TODO

This simply lists all the TODO-comments in my code or text file, so that I can easily review the ones that are not yet done. Simple as that.