PANKH: An unsteady potential flow solver for hovering airfoils
PANKH: An unsteady potential flow solver for hovering airfoils - Published in JOSS (2025)
Science Score: 93.0%
This score indicates how likely this project is to be science-related based on various indicators:
-
○CITATION.cff file
-
✓codemeta.json file
Found codemeta.json file -
✓.zenodo.json file
Found .zenodo.json file -
✓DOI references
Found 1 DOI reference(s) in JOSS metadata -
○Academic publication links
-
○Academic email domains
-
○Institutional organization owner
-
✓JOSS paper metadata
Published in Journal of Open Source Software
Keywords
Repository
PANKH (Panel Analysis of uNsteady Kinematics of Hovering airfoils) is a solver for studying unsteady aerodynamics of flapping and hovering airfoils using the unsteady vortex panel method. This repository includes the source code, example cases, and validation results.
Basic Info
Statistics
- Stars: 2
- Watchers: 3
- Forks: 4
- Open Issues: 2
- Releases: 2
Topics
Metadata Files
README.md
PANKH: A Potential Flow Solver for Hovering Airfoils
Description
This project implements PANKH (Panel Analysis for uNsteady Kinematics of Hovering airfoils), a solver designed to study the aerodynamics of flapping foils. PANKH is a low-fidelity solver that solves the Laplace equation to determine the velocity distribution in the flow field. It enforces the Neumann boundary condition to satisfy the no-penetration condition (zero normal flux) on the airfoil surface. The unsteady Bernoulli equation is then applied to compute the pressure difference across the airfoil, enabling the calculation of aerodynamic loads.
The essence of this approach lies in transforming a partial differential equation (PDE) into a system of linear algebraic equations, reducing the problem to a linear algebra problem. The real geometry is discretized into a series of flat panels, and a piecewise linearly varying vortex panel method is used to simulate the flow around the airfoil. At each time instant, a constant-strength vortex panel is shed from the trailing edge to satisfy Kelvin's Circulation Theorem, ensuring the correct representation of unsteady effects.
This solver is implemented in C++ and utilizes the Eigen library for efficient matrix operations. The code computes unsteady aerodynamic forces acting on an airfoil undergoing prescribed motion. A detailed document explaining the numerical framework will be provided separately.
Purpose and Motivation
What does PANKH do?
Studying and analyzing the aerodynamic forces acting on bodies immersed in a fluid is central to a wide range of applications — from the design of fixed-wing aircraft and flexible morphing wings (HAL), to understanding bird and insect flight, developing flapping-wing drones and ornithopters, and optimizing rotor blades in helicopters and wind turbines. Before addressing the complete three-dimensional problem, it is often essential to study the two-dimensional airfoil cross-section, which provides critical insights into the underlying flow physics and lift generation mechanisms. Traditionally, aerodynamic problems are investigated through: 1. Experimental studies – accurate but time-consuming and costly due to setup design and instrumentation. 2. Analytical studies – provide closed-form solutions that offer exact mathematical results and deep physical insight, but are generally limited to highly idealized or simplified versions of real-world problems. 3. Numerical simulations – increasingly popular since the advent of modern computing, offering flexibility and control over complex configurations. Numerical approaches can be broadly classified into: - **High-fidelity solvers** that resolve the Navier–Stokes equations with all flow physics, and - **Reduced-order models** based on simplifying assumptions that retain key aerodynamic behavior at a fraction of the computational cost. **PANKH** falls into the second category of numerical studies. It solves the **Laplace equation** under **potential flow assumptions**, making it ideal for low-speed, inviscid, incompressible, and irrotational flows. High-fidelity CFD solvers demand substantial computational resources — often running for **days on HPC clusters** across multiple nodes and cores. Moreover, **commercial CFD packages** are expensive, opaque “black-box” systems, making benchmark validations and modifications challenging. This motivated the development of **PANKH** — an open-source, reduced-order aerodynamic solver for **unsteady potential flows** that is: - Fast and lightweight, running within minutes on a single-core desktop, - Reasonably accurate, suitable for early-stage aerodynamic analysis, - Easy to compile, modify, and extend, supporting researchers and educators alike. PANKH aims to help users focus on their **state-of-the-art aerodynamic problems** without depending on GUI-based proprietary tools or reinventing in-house codes.Why PANKH?
Several open-source tools exist for simulating flow around airfoils — such as **FoilSim III**, **JavaFoil**, and **XFOIL** — but they are **limited to steady-state aerodynamics**. In contrast, open-source solvers that handle **unsteady potential flows** are scarce, and those that do exist are often **proprietary, undocumented, or poorly maintained**. **PANKH bridges this gap.** It provides a **modular C++ implementation** capable of simulating: - **Impulsive starts**, - **Pitching and plunging motions**, and - **Arbitrary user-defined unsteady kinematics.** The solver computes **aerodynamic loads**, including **lift** and **inviscid drag** due to pressure forces, and visualizes the **real-time evolution** of both the aerodynamic coefficients and the **vortex wake roll-up**. Remarkably, all this computation can be performed **within minutes on a standard single-core processor**. While **PANKH does not claim to replace high-fidelity CFD or experiments**, it **complements them effectively** — offering an excellent **trade-off between accuracy, computational cost, and setup complexity**. In doing so, PANKH lays the foundation for a new generation of **open-source tools** dedicated to **unsteady aerodynamics** in the potential flow regime.Who is PANKH for?
**PANKH** is designed with versatility in mind, serving a diverse user base: - Research and Academia: PANKH can be seamlessly integrated into research workflows for preliminary aerodynamic assessments, parametric studies, or as a component in coupled two-dimensional fluid–structure interaction (FSI) simulations. Its modular design allows researchers to adapt the solver to specific unsteady flow problems, reducing development time while maintaining flexibility for extensions and custom studies. PANKH provides a clear, modular, and well-documented framework, making it an ideal tool for classroom demonstrations, student projects, and graduate-level coursework in unsteady aerodynamics and aeroelasticity. Its simplicity and transparency allow students to observe aerodynamic forces, visualize vortex evolution, and explore unsteady phenomena hands-on, bridging the gap between theoretical learning and practical simulation experience. - Hobbyists and Independent Developers: With its minimal dependencies and easy compilation process, PANKH provides a hands-on platform for aerodynamic exploration, enabling enthusiasts to simulate and visualize unsteady flow phenomena on their personal computers. With continued development, PANKH aims to evolve into an industry-grade research tool — balancing open accessibility, scientific rigor, and educational utility.Features
Real-time wake visualization using Gnuplot for enhanced flow analysis.
Live tracking of Cl vs time plot to observe aerodynamic force variations dynamically.
Support for any NACA 4-digit series airfoil, allowing user-defined airfoil selection.
Flexible motion simulation — the code can be easily modified to analyze various kinematic motions
User-controlled wake modeling – The
input.jsonfile allows users to choose between prescribed wake and free wake analysis.Flexible panel discretization – The code supports both even and odd numbers of panels with cosine clustering for improved resolution near the leading and trailing edges. For details, refer to the
nodal_coordinates_initialfunction ingeometry.cpp.
Installation
Prerequisites
Before compiling and running the code, ensure the installation of the following dependencies:
Install a C++ Compiler
A C++ compiler supporting the C++11 standard or later is required for building the project. Recommended compilers include: - **Clang**: A high-performance, LLVM-based compiler with robust C++ support. - **GCC**: The GNU Compiler Collection, widely used for C++ development. - **Intel oneAPI DPC++/C++ Compiler (icpx)**: Optimized for high-performance computing - To install GCC on Ubuntu: ```bash sudo apt install g++ ``` - To install Clang on Ubuntu and ensure compatibility with the GNU C++ standard library (libstdc++): ```bash sudo apt install clang libstdc++-8-dev ``` - clang: Provides the Clang compiler (clang++). - libstdc++-8-dev: Installs the GNU C++ standard library headers (e.g., `Install Eigen Library (Required for matrix operations:)
- On Ubuntu: - Install via package manager (Recommended): ```bash sudo apt install libeigen3-dev # Ubuntu ``` This installs Eigen headers typically in `/usr/include/eigen3`. - Manual Installation: Download Eigen from the official website and extract it to a directory `(e.g., /usr/local/include/eigen3)`. Update the include path during compilation if necessary. [Eigen's official website](https://eigen.tuxfamily.org/). - On macOS: - Install Eigen via Homebrew: ```bash brew install eigen ``` - When compiling, you may need to specify the Eigen include path explicitly: ```bash g++ -I/opt/homebrew/Cellar/eigen/3.4.0_1/include/eigen3/ -Iinclude src/*.cpp -o PANKH_solver ``` Note: When executing the program, avoid extra whitespace: ```bash ./PANKH_solver # Correct ./ PANKH_solver # Incorrect ``` - For further help: [Getting started with Eigen](https://eigen.tuxfamily.org/dox/GettingStarted.html)Real-time / In-situ Visualization of Aerodynamic Forces and Vortex Shedding
Comprehensive platform-specific prerequisites, installation procedures, and verification protocols for enabling real-time visualization are detailed in [visualization_setup.md](https://github.com/coding4Acause/PANKH/blob/main/visualization_setup.md). This includes instructions for Gnuplot terminals, X11 support, and validation of plotting functionality across Linux, macOS, and Windows.Getting the Source Code
You can obtain the source code in two ways:
Cloning the Repository (Recommended for Development)
If you want to contribute or track changes, clone the repository using Git:
bash
git clone https://github.com/coding4Acause/PANKH.git
cd PANKH # this is simply the name of the local(host system) directory
<!-- cd 2d_UnsteadyVortexPanel is the name of the local(in the host system) directory for the project -->
Downloading as a ZIP (For Direct Usage)
If you only need the code without version control: 1) Go to the GitHub repository. 2) Click the "Code" button. 3) Select "Download ZIP". 4) Extract the ZIP file and navigate to the extracted folder.Compilation
To compile the code, ensure all .cpp and .h files are in the appropriate directories.
The typical structure is:
PANKH # the name of the local repository
- │── /src # Contains all .cpp source files
- │── /include # Contains all .h header files
- │── README.md
- │── LICENSE
- │── /output_files
- │── input.json # the input file
clang compiler
To compile with Clang, use the following command to link all source files and include necessary headers: ```bash clang++ -o PANKH_solver src/*.cpp -Iinclude -std=c++11 ````GCC compilers
If you are using g++, compile everything together with: ```bash g++ -o PANKH_solver src/*.cpp -Iinclude -std=c++11 ````Intel compilers
```bash icpx -o PANKH_solver src/*.cpp -Iinclude -std=c++11 ```Usage
Prepare the Input File
- Modify simulation parameters in the `input.json` file as per your requirements (e.g., freestream conditions, kinematic motion(e.g. pitch,plunge), total simulation time, airfoil geometry, panel discretization, etc.). - For parameters that are set to null in `input.json`, their values are automatically computed within the code during runtime. It is recommended to review the relevant section in `main.cpp` that handles JSON parsing for a complete understanding of how default values are derived and assigned.Ensure Output Directories Exist
- The solver produces multiple output files, including **pressure coefficients**, **lift and drag coefficients**, and **wake data**. These files are written to the appropriate subdirectories under `output_files/`. - If the required directories are absent, consult [`SETUP.md`](https://github.com/coding4Acause/PANKH/blob/main/SETUP.md) for detailed instructions or execute the provided setup script to automatically generate the directory structure.Run the Solver
After successful compilation, execute the solver from the terminal:
bash
./PANKH_solver input.json
Note: The solver expects the
input.jsonfile as a command-line argument. Ensure this file exists in the same directory or provide the correct path.
Running Tests
To verify the correctness of PANKH, you can run the automated test locally. The user does not need to modify anything unless explicitly desired. Simply ensure the prerequisites are satisfied, then compile and execute the test script.
Prerequisites
- Compile the main solver (PANKH_solver) from the root directory before executing the test script. The test relies on this executable to run the simulations internally. - Ensure there is a folder named `tests/` in the project root. - Inside the `tests/` folder, you will find: - **`test.cpp`** – The test script. - **`input_test.json`** – The input file designed for the test case. - **Reference solution file** – Contains published data used for verification.Compilation
- From the project root directory, compile the test script: ```bash g++ -o test_exec tests/test.cpp ```Run
```bash ./test_exec tests/input_test.json ``` - The script will automatically run the main solver, compare the computed lift coefficient with the reference solution, and print the results.Functionality of test.cpp
- Internally, `test.cpp` executes the main solver using the provided test input. - It collects the solver’s output (aerodynamic loads data) from the `output_files/` directory. - Compares the computed lift coefficient against the reference solution. - Prints clear messages indicating whether the test passed or failed.API Documentation
Overview
The source code has been extensively documented using Doxygen-style comments, enabling automatic generation of API documentation in HTML format. This documentation includes: - Function descriptions - Call graphs and dependency trees - Input/output descriptions - Hyperlinked navigation for easy access
View Documentation Online
The generated API documentation is hosted using **GitHub Pages** and can be accessed at: **[https://coding4Acause.github.io/PANKH/](https://coding4Acause.github.io/PANKH/)** > This will open the `index.html` of the Doxygen-generated documentation directly in your browser.Generate Locally (Optional)
If you want to regenerate the documentation on your system: #### 1. Install Required Tools: ```bash sudo apt install doxygen graphviz ``` #### 2. Verify Installation: ```bash doxygen -v # Check Doxygen version dot -V # Check Graphviz version ``` #### 3. Run Doxygen: From the root of your repository (where the `Doxyfile` is located), run: ```bash doxygen Doxyfile ``` This will generate a folder (`docs/` or `docs/html/`) containing the full documentation suite.License
This project is licensed under the terms of the MIT License. See License for details.
Future Work
Incorporating the viscous effects - A hybrid approach can be implemented by first solving the inviscid potential flow to obtain velocity and pressure distributions. These will serve as inputs for a 2D boundary layer solver to estimate local wall friction and boundary layer thickness. If displacement thickness effect is sought, the airfoil geometry is iteratively updated by adjusting the body panels based on local boundary layer displacement, and the potential flow solution is recomputed until convergence is achieved.
Airfoil Geometry – Currently, the code supports only NACA 4-digit series airfoils. Future improvements could extend its capability to handle other NACA series airfoils, as well as non-NACA airfoils, providing greater flexibility in airfoil selection.
Parallelization for Improved Performance – The current implementation runs sequentially, but performance can be significantly enhanced using parallel computing techniques. Since the code utilizes the Eigen library, enabling multi-threading with OpenMP and leveraging Eigen’s built-in vectorization (SIMD) can accelerate matrix operations.
Contributers
- Nipun Arora
- Ashish Pathak
- Rohit Chowdhury
JOSS Publication
PANKH: An unsteady potential flow solver for hovering airfoils
Authors
Department of Mechanical Engineering, Indian Institute of Technology, Jodhpur, Rajasthan, India
Department of Mechanical Engineering, Indian Institute of Technology, Jodhpur, Rajasthan, India
Department of Mechanical Engineering, Indian Institute of Technology, Jodhpur, Rajasthan, India
Editor
Pi-Yueh Chuang
Tags
Unsteady Aerodynamics Potential Flows Vortex Panel Kutta Condition Kelvin Circulation Theorem Flapping WingsGitHub Events
Total
- Create event: 2
- Release event: 2
- Issues event: 8
- Watch event: 1
- Delete event: 1
- Issue comment event: 6
- Push event: 62
- Pull request event: 1
- Fork event: 2
Last Year
- Create event: 2
- Release event: 2
- Issues event: 8
- Watch event: 1
- Delete event: 1
- Issue comment event: 6
- Push event: 62
- Pull request event: 1
- Fork event: 2
Issues and Pull Requests
Last synced: 5 months ago
All Time
- Total issues: 5
- Total pull requests: 1
- Average time to close issues: 15 days
- Average time to close pull requests: N/A
- Total issue authors: 2
- Total pull request authors: 1
- Average comments per issue: 0.6
- Average comments per pull request: 0.0
- Merged pull requests: 0
- Bot issues: 0
- Bot pull requests: 0
Past Year
- Issues: 5
- Pull requests: 1
- Average time to close issues: 15 days
- Average time to close pull requests: N/A
- Issue authors: 2
- Pull request authors: 1
- Average comments per issue: 0.6
- Average comments per pull request: 0.0
- Merged pull requests: 0
- Bot issues: 0
- Bot pull requests: 0
Top Authors
Issue Authors
- daavid00 (4)
- andrewgiuliani (1)
Pull Request Authors
- daavid00 (1)