FluidDyn: a Python open-source framework for research and teaching in fluid dynamics
1. AUGIER Pierre
2. MOHANAN Ashwin Vishnu
3. BONAMY Cyrille
Univ. Grenoble Alpes, CNRS, Grenoble INP111Institute of Engineering
Univ. Grenoble Alpes, LEGI, 38000 Grenoble, France.
Linné Flow Centre, Department of Mechanics, KTH, 10044 Stockholm, Sweden.
Paper Author Roles and Affiliations
1. Researcher, LEGI, Université Grenoble Alpes, CNRS, France
2. Ph.D. student, Linné Flow Centre, KTH Royal Institute of Technology, Sweden;
3. Research Engineer, LEGI, Université Grenoble Alpes, CNRS, France;
FluidDyn is a project to foster open-science and open-source in the fluid dynamics community. It is thought of as a research project to channel open-source dynamics, methods and tools to do science. We propose a set of Python packages forming a framework to study fluid dynamics with different methods, in particular laboratory experiments (package lab), simulations (packages fft, sim and foam) and data processing (package image). In the present article, we give an overview of the specialized packages of the project and then focus on the base package called dyn, which contains common code used in the specialized packages. Packages fft and sim are described with greater detail in two companion papers, Mohanan et al. (2018a, b). With the project FluidDyn, we demonstrate that specialized scientific code can be written with methods and good practices of the open-source community. The Mercurial repositories are available in Bitbucket (https://bitbucket.org/fluiddyn/). All codes are documented using Sphinx and Read the Docs, and tested with continuous integration run on Bitbucket Pipelines and Travis. To improve the reuse potential, the codes are as modular as possible, leveraging the simple object-oriented programming model of Python. All codes are also written to be highly efficient, using C++, Cython and Pythran to speedup the performance of critical functions.
Fluid dynamics research with Python. Free and open-source software, modular, object-oriented, collaborative, efficient, tested, documented.
Science is mainly a collective activity. We can go further only by “standing on the shoulders of giants” (and of a huge number of technicians and scientists). Science is a lot about how to build new knowledge from the work of others and hence, the exchange of ideas is a fundamental aspect. In the last decades, we have lived through a revolution on how people exchange ideas. Computers of all kinds (from smartphones to HPC clusters) connected by a world wide web are used for human communication and also for many other applications. It has become nearly effortless to reproduce and exchange ideas and data. The set of intangibles that grows when shared and degrades when hoarded, such as knowledge and love, has been somehow extended. The information technology revolution open doors to fantastic opportunities for human collaboration, and of course, for science.
Web related activities alone account for at least 5% of GDP in the USA and the European Union222See the report by Internet Association titled “Refreshing Our Understanding of the Internet Economy”. A huge amount of money (and work) is invested on the related technologies. We are familiar with the most prominent companies involved in this dynamics (Google, Facebook, etc.), but there are also several smaller and sometimes lesser known organizations. Most of these companies base part of their work on the open-source paradigm contributing to open-source languages, libraries, software and operating systems, while also using them — a win-win situation for both the corporations and the community. This has lead to deep changes in software engineering, with a massive use of open-source methods and tools, for example distributed version control systems (DVCS) and web-based source development platforms.
The computer performance continues to increase exponentially
, now also with the help of Graphical Processing Units (GPU). This gave way to a big boom in practical uses of data science and machine learning, which drives a strong research on artificial intelligence. Such developments contribute to progresses in open-source software. To summarize, there is a strong dynamics in play around the use of computers (in particular with the web) and this creates very efficient tools and methods for collective work and software development.
These changes in our world also reflect in the way science is done. Software and programming in science occupy a much bigger place than before. The role of software in science has changed. In the past, coding was sometimes considered as an inferior activity by some scientists. The focus was on the theory and the mathematical demonstration, which had to be elegant as it gets included in the articles. In contrast, it was normal to write crude code and to just show the results. Nowadays, codes tend to be at the heart of research.
“Open-science” is a new trend taking advantage of these new facts. Pioneering attempts are being made to do better science, improving reproducibility and collective efficiency, by using the open-source methods and tools for science and sharing and collaborating via the world wide web.
FluidDyn is a project to foster open-science and open-source coding in Python in the field of fluid mechanics. The project envisages to provide the technical framework to allow collaborative development of tools useful for the fluid mechanics community, and to do science with open methods. We provide examples of solutions for:
Good coding practice with readable and easy to comprehend Python code (PEP 8).
Source control management (Mercurial) and forge (Bitbucket) simple for the new comers.
Licenses: depending on the packages, we choose to use the CeCILL-B or the CeCILL licenses. These licenses are a BSD compatible and a GPL compatible licenses adapted to both international and French legal matters333http://www.cecill.info/licences.en.html.
Documentation produced with standard and up-to-date tools: Sphinx, Anaconda and Jupyter. Built and hosted online at Read the Docs. Can also be generated offline.
Unittest and continuous integration with Bitbucket Pipelines and Travis.
We hope that such a clean framework will facilitate contributions from scientists in the field and that we can build together a nice, user-friendly and efficient ecosystem specialized in research and teaching in fluid dynamics.
Implementation and architecture
Organization of the code in packages
FluidDyn was originally intended to be a single package to perform experiments and simulations. Since a typical user may not be involved in both experiments and simulations and also, due to increasing complexity as a virtue of rapid development cycle made the need to decentralize FluidDyn evident. Now, FluidDyn project hosts a number of specialized packages, namely:
dyn444We use FluidDyn (with capital letters) to name the project and for the base package.: The base package which contains pure-python code that can be reused in scripts or in specialized FluidDyn packages. It also contains codes for miscellaneous command-line utilities useful for a typical fluid dynamics user.
The code of this package is presented in further detail in its documentation (https://fluiddyn.readthedocs.io) and some prominent features are presented in the following subsection.
sim (see the companion paper Mohanan et al., 2018b): Numerically oriented framework to run sequential and parallel Computational Fluid Dynamics (CFD) simulations and on-the-fly post-processing for a variety of problems (Navier-Stokes, Shallow Water, Föppl von Kármán equations, to name a few). A study using sim has just been published in Physics of Fluids Lindborg & Mohanan (2017).
lab: Package to handle laboratory experiments. Primarily used to communicate with various hardware devices such as motors and pumps, to handle I/O between sensors, and to store data. Experiments using lab have been carried out in the DAMTP fluid laboratory (Cambridge, UK. cf. Leclercq et al., 2016), in ENS Lyon laboratory (Lyon, France, Salort et al., 2018) and at LEGI (Grenoble, France, Campagne et al., 2016).
image: Scalable image processing package which implements various algorithms to calibrate cameras, to preprocess images, to do Particle Image Velocimetry (PIV) and to postprocess data. image is used to process images taken during experiments performed in the Coriolis platform at LEGI Campagne et al. (2016).
foam: Small package to load OpenFoam data and plot them.
coriolis: Small package used to carry out experiments in the Coriolis platform (a large rotating platform participating in the European consortiums Euhit and Hydralab) and open the data obtained (see, for example, Campagne et al., 2016). One of the motivations behind creating this package is to study how to use open-source to create and share open-data.
A detailed presentation on the above packages can be found in their respective documentations on the web and for fft and sim in the two companion papers Mohanan et al. (2018a, b). The code base was designed to follow Python 2.7 syntax during its genesis. Now, it has been made forward compatible with Python 3 through the use of external package future. This article will now focus on the base package .
API of the Python library
All functions and classes defined in are pure Python elements, meaning that no extensions are implemented in . Thus the package is extremely easy to install with just a pip install command and no compilation.
The package is organized into five sub-packages:
fluiddyn.io: This subpackage provides utilities for input/output to different file formats.
fluiddyn.util: Miscellaneous utilities.
fluiddyn.calcul: Modules for numerical computations.
fluiddyn.clusters: Classes to launch jobs on HPC clusters.
fluiddyn.output: Utilities to produce scientific outputs (figures and videos).
Sub-packages io, util and calcul are the largest in terms of lines of code and provides the Application Programming Interfaces (API) to support sim, lab and image. For the sake of brevity, we shall only describe here some of the most important modules.
Sub-package paramcontainer defines class ParamContainer which is a hierarchical container for any type of parameters. As shown in this tutorial, various strengths of an object of this class include:
Support containing and printing documentation on the parameters.
Support printing to console as XML and saving as XML, HDF5 and NetCDF Files.
Evaluate data types automatically while loading from saved files.
Easy exploration in an interactive console.
Allows modification of default parameters through simple Python script files. An error is raised if the user attempts to use an invalid parameter.
Graphical User Interface (GUI) frontend with PyQt.
Thus, it makes it a much more robust implementation for saving key parameters, compared to conventional methods which rely on text or CSV files.
This modules provides classes to iterate over files. It is a common task in data processing to understand how to organize a serie of files from filenames and formats. Typically, one has to form smaller sets of arrays contained in the files. For example, we may have a serie such as:
(im1_1.png, im1_2.png, im1_3.png, im2_1.png, im2_2.png, im2_3.png)
from which we could create different subsets like,
((im1_1.png, im1_2.png, im1_3.png), (im2_1.png, im2_2.png, im2_3.png)) ((im1_1.png, im2_1.png), (im1_2.png, im2_2.png), (im1_3.png, im2_3.png))
The classes of this module allows one to do it with a quite simple and general API as shown in the tutorial on the module.
This simple module makes simultaneous sequential and MPI programming a breeze by providing number of processes, nb_proc = 1 and rank = 0, when used in sequential mode, otherwise providing the appropriate values provided by mpi4py package. Use of this module thwarts coding several if-else clauses. If the program was using MPI, also defines the variable comm as an alias for the MPI.COMM_WORLD communicator.
Thin wrapper for an unified API using classes around the packages pyfftw and scipy.fftpack. It is very easy to perform forward and inverse Fast Fourier Transforms (FFT) in one-, two- and three-dimensions. The FFT can be multithreaded if the environment variable OMP_NUM_THREADS is defined.
The command-line utilities
The package also provides few command-line utilities to perform simple tasks useful for a scientist developing with Python and using the FluidDyn packages.
Displays important information related to software and hardware. It includes detailed information such as currently installed FluidDyn packages, other third-party packages, C compiler, MPI and configuration.
Utility to print the hierarchy of HDF5 and NetCDF files. It does not depend on the NetCDF4 library.
Very simple layer to stripout Jupyter notebooks of output, which is useful to keep the notebooks lightweight when included in a repository. This tool is based on nbstripout but, in contrast to nbstripout, by default the notebooks with a file name ending as ‘.nbconvert.ipynb’ are excluded.
Utility to produce a strange code which is no longer Matlab and not yet Python. This strange code is then much easier to translate into correct Python than the original Matlab code.
The package currently supplies unit tests covering around 70% of its code. These unit tests are run regularly through continuous integration on Travis CI with the most recent releases of ’s dependencies and on Bitbucket Pipelines inside a static Docker container. The tests are run using standard Python interpreter with all supported versions.
For , the code coverage results are displayed at Codecov. Using third-party packages coverage and tox, it is straightforward to bootstrap the installation with dependencies, test with multiple Python versions and combine the code coverage report, ready for upload. It is also possible to run similar isolated tests using tox or coverage analysis using coverage in a local machine. Up-to-date build status and coverage status are displayed on the landing page of the Bitbucket repository.
We also try to follow a consistent code style as recomended by PEP (Python enhancement proposals) 8 and 257. This is also inspected using lint checkers such as flake8 and pylint among the developers. The code is regularly cleaned up using the Python code formatter black.
Windows and any POSIX based OS, such as GNU/Linux and macOS.
Python 2.7, 3.4 or above.
We list here only the dependencies of the base package dyn.
Minimum: , Matplotlib, psutil, future, subprocess32 (for Python 2.7 only), h5py, h5netcdf.
Full functionality: mpi4py, Scipy, pyfftw (requires FFTW library), pillow.
Optional: OpenCV with Python bindings, scikit-image.
List of contributors
Pierre Augier (LEGI): creator of the FluidDyn project, developer of majority of the FluidDyn packages, future-proofing with Python 3 compatibility and documentation.
Ashwin Vishnu Mohanan (KTH): developer of the packages sim, fft, image and ; documentation, code coverage and continuous integration (Docker, Bitbucket Pipelines and Travis CI).
Cyrille Bonamy (LEGI): developer of fft, sim, image and foam. Main maintainer of foam.
Antoine Campagne (LEGI): developer of image and lab.
Miguel Calpe Linares (LEGI): developer of sim and lab.
Julien Salort (Laboratoire de physique, ENS de Lyon): developer of lab.
- Persistent identifier:
CeCILL-B, a BSD compatible French licence.
- Version published:
- Date published:
- Persistent identifier:
- Date published:
(3) Reuse potential
As a library, has been used in the project’s specialized packages. The common code base for packages with such varied applications is a proof of ’s versatility and generality. It can be used in other packages outside the FluidDyn project easily depending on the need. The command-lines tools can be useful to all scientists working with Python. Other use cases could be:
ParamContainer as a generic parameter storage standard.
Modules within fluiddyn.util for miniature tasks, printing in terminal with colours, getting memory usage information, detecting if the current Python session is inside IPython, creating a string with time and date, etc.
Modules within fluiddyn.io to read and save images of various formats including TIFF files with multiple images; easily ask user with yes/no queries; handle different file formats using classes, including CSV, HDF5, Digiflow, Dantec formats.
Modules inside fluiddyn.clusters subpackage to make job submission scriptable in HPC clusters with OAR or SLURM job schedulers. It could be even used for non-Python jobs.
There is no formal support mechanism. However, bug reports can be submitted at the Issues page on Bitbucket. Discussions and questions can be aired on instant messaging channels in Riot (or equivalent with Matrix protocol)555 https://matrix.to/#/#fluiddyn-users:matrix.org or via IRC protocol on Freenode at #fluiddyn-users. Discussions can also be exchanged via the official mailing list666 https://www.freelists.org/list/fluiddyn.
FluidDyn is an attempt to set off collaborative dynamics based on open-source development in fluid dynamics research. We shall try, with this project, to explore the possibilities of open-source in science and fluid dynamics by fully exploiting the new open-source tools and methods.
The project is right now in a preliminary stage. Packages are actively evolving with interesting features and a framework for collaborative development, packaging, documenting and testing is now well set. However, the community around the project is currently tiny and now, we have to work on attracting users and developers since an active community is a criteria for success and sustenance of an open-source project.
Will people use the FluidDyn tools and collaborate through the project FluidDyn? There are clearly many challenges and potential barriers:
Some habits in the community.
Knowledge and skills in the community. For example, only few people use issue tracker and pull requests.
Lack of a business model for open-source software in science. A good quality open-source software has a cost that institutions should be willing to fund and support.
Lack of recognition of the work spent in open-source, in particular for precarious scientists.
On our side, we also have positive points. The quality of the tools we use (Python and its scientific ecosystem, Mercurial, Read the Docs, Jupyter, …) is impressive. Scientific code is done to be read and to transmit ideas. To this effect, Python is among the best languages today. Python starts to be a standard tool in fluid dynamics, especially used for CFD (Dedalus, SpectralDNS, TriFlow, PyLBM, Oasis, PyFR, FEniCS, Cassiopee, pyCGNS, etc.) and data analysis (OpenPTV, PyPIV
). Moreover, we can benefit from the dynamics of Python and of emerging subjects like deep learning and the Internet of Things. Finally, if we manage to gather a community of users and of developers, the collective efficiency related to open-source methods and tools can be a strong booster.
We thank the CNRS to finance the work of Pierre Augier while giving freedom in terms of scientific project. Similarly, Ashwin Vishnu Mohanan could not have been as involved in this project without the kindness of Erik Lindborg. We thank Antoine Campagne, Miguel Calpe Linares and Julien Salort for their implications in the development of some of the FluidDyn packages. We are grateful to Bitbucket for providing us with a high quality forge compatible with Mercurial, free of cost. Finally, we thank Gabriel Moreau and Joël Sommeria for their constant will to discuss and share their knowledge.
This project has indirectly benefited from funding from the foundation Simone et Cino Del Duca de l’Institut de France, the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation program (grant agreement No 647018-WATU and Euhit consortium) and the Swedish Research Council (Vetenskapsrådet): 2013-5191. We have also been able to use supercomputers of CIMENT/GRICAD, CINES/GENCI and the Swedish National Infrastructure for Computing (SNIC).
The authors declare that they have no competing interests.
- Campagne et al. (2016) Campagne, A., Alfredsson, H., Chassagne, R., Micard, D., Mordant, N., Segalini, A., Sommeria, J., Viboud, S., Mohanan, A. V., Lindborg, E. & Augier, P. (2016), First report of the MILESTONE experiment: strongly stratified turbulence and mixing efficiency in the coriolis platform, VIIIth International Symposium on Stratified Flows (ISSF, San Diego, USA).
- Leclercq et al. (2016) Leclercq, C., Partridge, J. L., Augier, P., Dalziel, S. B. & Kerswell, R. R. (2016), ‘Using stratification to mitigate end effects in quasi-Keplerian Taylor–Couette flow’, J. Fluid Mech. 791, 608–630. doi: https://doi.org/10.1017/jfm.2016.44.
- Lindborg & Mohanan (2017) Lindborg, E. & Mohanan, A. V. (2017), ‘A two-dimensional toy model for geophysical turbulence’, Phys. Fluids 29(11), 111114. doi: https://doi.org/10.1063/1.4985990.
- Mohanan et al. (2018a) Mohanan, A. V., Bonamy, C. & Augier, P. (2018a), ‘FluidFFT: common API (C++ and Python) for Fast Fourier Transform libraries’, J. Open Research Software (to be submitted).
- Mohanan et al. (2018b) Mohanan, A. V., Bonamy, C. & Augier, P. (2018b), ‘FluidSim: modular, object-oriented python package for high-performance CFD simulations’, J. Open Research Software (to be submitted).
- Salort et al. (2018) Salort, J., Rusaouën, É., Robert, L., Du Puits, R., Loesch, A., Pirotte, O., Roche, P.-E., Castaing, B. & Chillà, F. (2018), ‘A local sensor for joint temperature and velocity measurements in turbulent flows’, Review of Scientific Instruments 89(1), 015005.