# Recent Posts

• ## Structure of Mercurial: a crowd simulation framework

To support my research in crowd dynamics models, I am developing a simulation framework: Mercurial. The aim is to simplify the testing of new models and see how they perform in different scenarios. At this stage, the framework is still a prototype, but I try to keep it as accessible and maintainable as possible.

Mercurial is written in Python 3. This makes for rapid prototyping, but can become a computational burden if not designed with caution. Therefore, almost all intensive computations are vectorised using the NumPy library or are deferred to a lower level implementation in Fortran.

In the rest of this post I describe the structure of the simulation. Information on how to install and use it can be found here.

• ## What is crowd dynamics?

This is the first post in a series of entries on the modelling of crowd dynamics.

In this post I give a short introduction into a topic of my research: crowd dynamics. Crowd dynamics is a very multidisciplinary field of research; contributions come from a great many fields in social science and natural science. I will be sticking to my background and focus mainly on mathematical, physical and computer-science aspects. For the interested reader I have included links to Wikipedia pages of related concepts.

## Definition

Crowd dynamics is the term used for describing the behaviour and interaction of groups of people moving in a certain environment. The main goal of crowd dynamics research is to identify the factors that control these dynamics (analysis), and to be able to predict crowd motion in new scenarios (simulation).

As you can imagine, crowd simulation serves many purposes, like

• Preventing crowd disasters at a large public event.
• Optimizing the layout of a supermarket.
• Designing evacuation strategies for a building.
• Creating realistic animations in a game.

The dynamics of crowds vary from situation to situation. Pedestrians in traffic have different goals and therefore different patterns than people in shopping malls. Compare across cultures, and you will find even more diversity. This makes the modelling and simulation of crowds a challenge that requires more than just a mathematical understanding of how people move from A to B.

• ## IPython - an improved shell for Python

IPython is an alternative to the default Python interpreter. It was created to make scripting and prototyping in the programs in the Python language more easy and has gradually developed new technologies to improve Python, as well as other programming languages. Some of its key features are syntax highlighting and tab completion for variables, modules and files in an interactive Python session, and notebooks that allow a mixture of code, output, and descriptions (see for instance this one).

You can install IPython through your package manager (e.g. pip or conda). IPython has loads of options. Although it is well documented, the manual is so long I postponed reading it for years. Now that I did, I decided it was time to share the highlights that improved my workflow.

• ## Implementation of a weighted distance transform

I recently finished a Python module for computing weighted or generalized distance transforms (available here. I needed it for the motion planner in my crowd simulation Mercurial and I couldn’t find it online, so I implemented it in Fortran so F2PY could wrap it for me. This post goes into details of the algorithm and how to use the module.

• ## Getting started with scientific Python on Mac and Linux

This post elaborates on a couple of ways to install Python libraries Numpy/Scipy/Matplotlib for Linux and Mac. This is something I seem to have to do every so often, and although the process should be straightforward, the details elude me each time. May this serve as a reminder to future me (and others).

Note: For all platforms (including Windows) it is possible to install compiled binaries as well. I won’t go into this here, because I prefer the use of package managers. They take care of compiling the software, putting it in the right place and updating so you don’t have to worry about it.

• ## Crowds and populations: a visual exploration

No formulas or commands in this post. Instead, I uploaded a couple of video clips I recorded in various places, showcasing dynamics in different kinds of populations. They are a bit amateurish, but they should be able to demonstrate the complexity present in population dynamics. Each scenario has a bit of context describing a mathematical model associated with it.

## 1. Crossing pedestrians

The first clip was shot in the Shibuya crossing in Tokyo, Japan. It is known for being one of the most crowded intersections in the world. Two special features of the crossing: it has more than 4 lanes, and the traffic lights give way to pedestrians from all directions at the same time.

Looking at the video, the pedestrians barely seem to be hindered by the multitude of conflicting directions.

• ## A practical introduction to the Finite Element Method

This notebook provides a demonstration of the Finite Element Method, a technique to obtain a numerical solution of a partial differential equation. This is by no means a complete introduction, but serves more as a numerical example of how the technique works in practice. For more detail on the mathematics behind it, there are numerous books and resources online; for open-source implementations, you can check out FEniCS, DUNE, deal.II and many others.

## Description

We are looking for the solution to the partial differential equation

on a domain $\Omega$. Here, $\Delta$ is the Laplace operator and $f$ is a known function. We assume that on the boundary of our domain $\partial \Omega$, $u$ takes value $0$.

• ## Open-source command-line tools for images and movies

A while back, I discovered a couple of command-line image manipulation tools: ImageMagick and FFmpeg. They fit nicely in my simulation development workflow, and take a lot of pain out of reproducing graphic output. Put the commands in a script, and it’s easy to re-obtain images and movies after running simulations with different parameters.

To use convert, install the ImageMagick toolbox. For ffmpeg, install the FFmpeg library. On Ubuntu:

sudo apt-get install imagemagick
sudo apt-get install ffmpeg


Binaries are also available for Windows and Mac.

Below follows a list of examples I find useful. All commands are valid bash/zsh.

• ## How to communicate data between Fortran and Python

In a previous post, I discussed extending: how to build custom Fortran modules you can run in a Python script. If you just want to post-process or plot your Fortran results, you can opt to simply output your data in a readable format, so that you can read it in other languages (e.g. Python, Matlab, C++).

This post lists three ways to output Fortran data: the quick way, the classic way, and the sustainable way.

• ## Extending Python with Fortran

If you use Python for scientific programming you’ll probably find that as long as you can use NumPy, SciPy, and other optimized libraries, scripts can be developed and executed swiftly.

The routines from these libraries are often composed in low-level programming languages (like C or assembly), avoiding the overhead from the dynamic and interpreted nature of Python.

However, it can happen that some of the algorithms you are implementing require operations not supported in these libraries. For example: if you use NumPy, but run into an algorithm that is difficult to expressed in a vectorized form, you might have to resort to pure Python. This can become a huge bottleneck in the execution of your script.

It is possible to create your own Python module from a lower-level programming language. This is called extending Python. This means you write the bottleneck algorithm in the low-level language, compile it in a Python-friendly way and use it in your script like any other module. This post shows how to use the tool F2PY from SciPy to create an extension from Fortran.

• ## Mercurial: simulation framework for crowd dynamics

Recently, I wrote something about my graduation project. Part of this project was the development of a simulation framework, Mercurial. The goal of Mercurial is to facilitate the implementation of different hybrid particle simulation methods, and to test them on simple but existing use cases with different environments. You can find the code on GitHub here, together with instructions on how to use it.

This simulation was also used in my research internship at LOC7000, to evaluate evacuation scenarios on Dutch music festival Lowlands and see if the safety measures could be analyzed in a quantitative manner.

The framework is built in Python. The simulation creates an environment from a scene file and reads in the parameters from a configuration file. Alternatively, a simple drawing tool is included to create new environments.