Utopia is a comprehensive modeling framework for complex adaptive systems, specifically cellular automata models (CAs), agent-based models (ABMs), and network models. It provides tools to implement new models, configure and perform simulation runs, and evaluate resulting data. Additionally, Utopia ships with several readily implemented models.
Utopia aims to make the model researcher’s everyday workflow more convenient, efficient, and reproducible. Key strengths are:
- Written in modern C++ and Python to exploit the full potential of both
- Facilitates parameter sweeps and efficient high-dimensional data analysis
- Provides a multithreading interface and concurrent simulation execution on cluster architectures
- Incorporates and encourages software engineering workflows like version control, testing, and code review.
For a deeper look into Utopia’s capabilities, make sure to visit the features page.
The main goals of Utopia can be summarized as follows:
- Attempt to cover all “everyday aspects” of studying computer models.
- Adhere to software engineering best practices in order to produce reliable and reproducible results.
- Foster collaboration, e.g. by developing and using the framework throughout a research group; that way synergies can develop more rapidly and friction can be reduced.
Utopia was built with the following design philosophy in mind:
- Everything should be configurable — but with good defaults.
- Provide a wide set of tools, but don’t force them on the framework user.
- Prevent lock-in by using open data formats.
- Be computationally efficient, yet sufficiently customizable.
Utopia’s core capability is that it can bring together many (if not all) of the tools that you are using to study computer models and integrate them in a way that makes your workflow more efficient.
Utopia is for you, if
- You are interested in working with one of the many pre-implemented models for your own purposes, or
- You are a researcher looking for a comprehensive modeling tool to investigate complex processes, using e.g. network-based or grid-based models.
- You have knowledge both of C++ and Python.
On the other hand, you should not use Utopia, if
- Programming and using the command line is not your thing; Utopia embraces flexibility for programmers.
- You want a library with a simple and concise feature set; Utopia is feature-rich and extensive.
- You want a very quick solution: Utopia has a learning curve.
2016: The idea of the Utopia framework emerged in 2016 among members of the TS-CCEES research group at the Institute of Environmental Physics at the University of Heidelberg, Germany. To quote Kurt Roth, the group supervisor:
We embark on creating a C++ framework for simulating the coupled dynamics of geomorphology, diverse vegetation, and interacting, developing, and evolving populations of different species. The focus is on fundamental studies of such coupled complex and evolving systems.
The framework is to consist of coupled CA and ABMs (cellular automata and agent-based models) that operate on flexible discretizations in order to optimally represent the various process chains. Design goals are (i) versatility and expandability of the framework, (ii) computational efficiency, and (iii) usability by non-experts, in this order. It is first developed and demonstrated for a minimally complete set of species and processes.
At the same time, Lukas Riedel created citcat, a generic C++ template library for the efficient simulation of cellular automata, based on DUNE. Later on, citcat became the basis for the Utopia framework.
2017: Development on citcat continued and first experiences were gained in collaboratively working on software projects.
During this time, many of the first Utopia contributors built their own domain-specific simulation frameworks as part of their MSc or BSc projects. The experience gained and ideas developed during that time had a big influence on the philosophy and goals of Utopia. For instance, it was observed that re-implementing models over and over again was not only inefficient, but also error-prone. On the other hand, by collaboratively working on a framework, these difficulties could be circumvented and synergies could develop.
2018: The structure and scope of Utopia was planned in more detail: it was to consist of a C++ backend (for computationally efficient model implementations, based on citcat) and a Python frontend (for model configuration, simulation management, and evaluation).
In a group effort, the foundations of Utopia were laid in a week-long hackathon. Similar events were organized a few more times to boost development of the framework.
Henceforth, new projects in the research group preferentially used Utopia for model implementations and evaluations. Alongside these developments, the feature set of Utopia evolved further.
2019: To gain flexibility and control, the DUNE framework was removed as a dependency of Utopia. This entailed a restructuring of the build system and a custom implementation for cellular automata.
In the summer of 2019, Utopia was first used in postgraduate teaching as part of the Chaotic, Complex, and Evolving Environmental Systems lecture by Prof. Kurt Roth. In the accompanying exercises, students used Utopia to run simulations of different models and understand the effect of the chosen parameters on the system dynamics. Furthermore, Utopia was used in a postgraduate physics seminar, where groups of students implemented models using Utopia and investigated their behavior.
In August 2019, Utopia went public under the LGPLv3+ open-source license.
2020: Three research articles about Utopia, its frontend, and collaboratively developing and working with this modeling framework were published in 2020.
Building on the experience from previous teaching events, Utopia was used in two further postgraduate courses: the next iteration of the aforementioned lecture, as well as another seminar on complex and evolving systems.
Furthermore, 2020 was the year in which the number of total projects carried out using Utopia surpassed 25. As part of these projects, more than 45 models have been implemented so far (mostly in private repositories).