Pseudo-spectral collocation code for two-dimensional turbulence simulations written in object-oriented python.
These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.
To run the code provided in this repository, you will need standard python packages, such as numpy and matplotlib. These should already be installed on most machines.
To use the master branch of this code (the fast one!), you will need to have pyFFTW installed. Installation instructions can be found here.
Alternatively, you can create a new conda environment using the environment.yml file provided. First, got in the '2D-Turbulence-Python' cloned repository and creat the new environment
$ conda env create -f environment.yml
This will create a new conda environment called 2D-Turbulence-Python. Then activate it
$ conda activate 2D-Turbulence-Python
This will install all the required packages and allows you to use this repo.
This repository contains three (as of today) branches, the master branch that includes the pseudo-spectral code running with the pyFFTW library, the CDS branch that contains the high-order (up to 6th) compact difference scheme version and the numpy branch that contains a numpy-only version of the code. When the repository has been cloned/downloaded, you can switch between branches using
git checkout numpy (or CDS)
to switch to the desired branch. The solver is implemented such that functions calls perform the same tasks on each branch.
Once you are happy with the version you are going to use, check that everything works by running the validation script
python valid.py
This runs a simulation of the Taylor-Green Vortex for which we have an analytical solution. The output should look similar to this
Starting integration on field.
Iteration 100, time 0.020, time remaining 0.079. TKE: 0.180 ENS: 23580.54
Iteration 200, time 0.041, time remaining 0.058. TKE: 0.129 ENS: 16934.10
Iteration 300, time 0.061, time remaining 0.038. TKE: 0.092 ENS: 12157.35
Iteration 400, time 0.082, time remaining 0.017. TKE: 0.066 ENS: 8725.782
Execution time for 484 iterations is 2.737 seconds.
The L2-norm of the Error in the Taylor-Green vortex on a 128x128 grid is 1.362e-10.
The Linf-norm of the Error in the Taylor-Green vortex on a 128x128 grid is 2.725e-10.
You should get errors in both norms close to the values displayed above.
This repo also contains some more basic test, that can be run using pytest
$ pytest
Simulations are initialized by defining a grid, and specifying the Reynolds number of the flow
flow = Fluid(nx=64, ny=64, Re=1)
flow.init_solver()
flow.init_field(TaylorGreen)Here we have initialized the Taylor-Green vortex. The solver initiation generates all the working arrays and transforms the initial conditions. Simulations can also be initialized using results from previous runs (these need to have been saved with flow.write(folder='', 1))
from src.field import FromDat
flow.init_field(FromDat, name="vort_000001.dat")here we reset the flow timer using the time value saved in the vort_ID.dat file. The finish time of the simulation must be adjusted accordingly, as well as the ID if the field is saved. This allows user-generated field to be used, within the limitations of the method (periodic boundary conditions). The main loop of the solver is called as
# loop to solve
while(flow.time<=finish):
flow.update()
if(flow.it % 1000 == 0):
print("Iteration \t %d, time \t %f, time remaining \t %f. TKE: %f, ENS: %f" %(flow.it,
flow.time, finish-flow.time, flow.tke(), flow.enstrophy()))
flow.write(file="fluid")Small simulations can also be run live, which can also be handy for de-bugging
flow.run_live(finish, every=100)For a description of the theory behind this code, or to run other cases, such as a double shear layer, or decaying isotropic turbulence, look at this.
- Marin Lauber - Initial work - github
This project is licensed under the MIT License - see the LICENSE file for details