gmshairfoil2d 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

gmshairfoil2d/gmshairfoil2d.py

@@ -1,17 +1,109 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
+"""Main module for GMSH airfoil 2D mesh generation."""
 
 import argparse
 import math
 import sys
 from pathlib import Path
-import numpy as np
 
 import gmsh
 from gmshairfoil2d.airfoil_func import (NACA_4_digit_geom, get_airfoil_points,
-                                        get_all_available_airfoil_names)
+                                        get_all_available_airfoil_names, read_airfoil_from_file)
 from gmshairfoil2d.geometry_def import (AirfoilSpline, Circle, PlaneSurface,
                                         Rectangle, outofbounds, CType)
+from gmshairfoil2d.config_handler import read_config, merge_config_with_args, create_example_config
+
+
+def _calculate_spline_length(spline):
+    """Calculate the length of a spline based on its points.
+    
+    Parameters
+    ----------
+    spline : object
+        Spline object with point_list attribute
+    
+    Returns
+    -------
+    float
+        Total length of the spline
+    """
+    if not hasattr(spline, 'point_list') or not spline or not spline.point_list:
+        return 0
+    
+    points = spline.point_list
+    if len(points) < 2:
+        return 0
+    
+    return sum(
+        math.sqrt((points[i].x - points[i+1].x)**2 + 
+                 (points[i].y - points[i+1].y)**2)
+        for i in range(len(points) - 1)
+    )
+
+
+def apply_transfinite_to_surfaces(airfoil_obj, airfoil_mesh_size, name=""):
+    """
+    Apply transfinite meshing to all three splines (upper, lower, and front) of an 
+    airfoil or flap object for smooth cell transitions based on edge lengths.
+    
+    The key is to distribute nodes proportionally to each edge's length:
+    - longer edges get more points
+    - all edges get consistent cell sizing at junctions
+    
+    Parameters
+    ----------
+    airfoil_obj : AirfoilSpline
+        The airfoil or flap object containing front_spline, upper_spline, lower_spline
+    airfoil_mesh_size : float
+        The target mesh size to maintain consistent cell dimensions
+    name : str, optional
+        Name of the object (for logging purposes)
+    """
+    # Calculate the length of each spline
+    l_front = _calculate_spline_length(airfoil_obj.front_spline) if hasattr(airfoil_obj, 'front_spline') else 0
+    l_upper = _calculate_spline_length(airfoil_obj.upper_spline) if hasattr(airfoil_obj, 'upper_spline') else 0
+    l_lower = _calculate_spline_length(airfoil_obj.lower_spline) if hasattr(airfoil_obj, 'lower_spline') else 0
+    
+    # Calculate total perimeter
+    total_length = l_front + l_upper + l_lower
+    
+    if total_length == 0:
+        print(f"Warning: {name} has zero total length, skipping transfinite meshing")
+        return
+    
+    # Distribute points proportionally to edge lengths
+    # Target cell size should be approximately airfoil_mesh_size on all edges
+    total_points = max(20, int(total_length / airfoil_mesh_size))
+    
+    # Distribute points based on proportion of each edge length
+    # Front gets a multiplier for higher density at leading edge (Bump effect)
+    front_multiplier = 2  # 100% extra density for front region
+    weighted_length = l_front * front_multiplier + l_upper + l_lower
+    
+    nb_points_front = max(15, int((l_front * front_multiplier / weighted_length) * total_points))
+    nb_points_upper = max(15, int((l_upper / weighted_length) * total_points))
+    nb_points_lower = max(15, int((l_lower / weighted_length) * total_points))
+    
+    # Apply transfinite curves
+    if hasattr(airfoil_obj, 'front_spline') and airfoil_obj.front_spline:
+        gmsh.model.mesh.setTransfiniteCurve(
+            airfoil_obj.front_spline.tag, nb_points_front, "Bump", 10)
+    
+    if hasattr(airfoil_obj, 'upper_spline') and airfoil_obj.upper_spline:
+        gmsh.model.mesh.setTransfiniteCurve(airfoil_obj.upper_spline.tag, nb_points_upper)
+    
+    if hasattr(airfoil_obj, 'lower_spline') and airfoil_obj.lower_spline:
+        gmsh.model.mesh.setTransfiniteCurve(airfoil_obj.lower_spline.tag, nb_points_lower)
+    
+    if name:
+        # Calculate actual cell sizes for info
+        front_cell_size = l_front / (nb_points_front - 1) if nb_points_front > 1 else 0
+        upper_cell_size = l_upper / (nb_points_upper - 1) if nb_points_upper > 1 else 0
+        lower_cell_size = l_lower / (nb_points_lower - 1) if nb_points_lower > 1 else 0
+        
+        print(f"Applied transfinite meshing to {name}:")
+        print(f"  - Front spline: {nb_points_front:3d} points, length={l_front:.4f}, cell size ~ {front_cell_size:.6f}")
+        print(f"  - Upper spline: {nb_points_upper:3d} points, length={l_upper:.4f}, cell size ~ {upper_cell_size:.6f}")
+        print(f"  - Lower spline: {nb_points_lower:3d} points, length={l_lower:.4f}, cell size ~ {lower_cell_size:.6f}")
 
 
 def main():
@@ -24,6 +116,26 @@ def main():
         ),
     )
 
+    parser.add_argument(
+        "--config",
+        type=str,
+        metavar="PATH",
+        help="Path to YAML configuration file",
+    )
+
+    parser.add_argument(
+        "--save_config",
+        type=str,
+        metavar="PATH",
+        help="Save configuration to a YAML file",
+    )
+
+    parser.add_argument(
+        "--example_config",
+        action="store_true",
+        help="Create an example configuration file (config_example.yaml)",
+    )
+
     parser.add_argument(
         "--list",
         action="store_true",
@@ -46,6 +158,20 @@ def main():
         help="Name of an airfoil profile in the database (database available with the --list argument)",
     )
 
+    parser.add_argument(
+        "--airfoil_path",
+        type=str,
+        metavar="PATH",
+        help="Path to a custom .dat file with airfoil coordinates",
+    )
+
+    parser.add_argument(
+        "--flap_path",
+        type=str,
+        metavar="PATH",
+        help="Path to a custom .dat file with flap coordinates",
+    )
+
     parser.add_argument(
         "--aoa",
         type=float,
@@ -54,6 +180,14 @@ def main():
         default=0.0,
     )
 
+    parser.add_argument(
+        "--deflection",
+        type=float,
+        nargs="?",
+        help="Angle of flap deflection [deg] (default: 0 [deg])",
+        default=0.0,
+    )
+
     parser.add_argument(
         "--farfield",
         type=float,
@@ -62,6 +196,13 @@ def main():
         default=10,
         help="Create a circular farfield mesh of given radius [m] (default 10m)",
     )
+
+    parser.add_argument(
+        "--farfield_ctype",
+        action="store_true",
+        help="Generate a structured circular farfield (CType) for hybrid meshes",
+    )
+
     parser.add_argument(
         "--box",
         type=str,
@@ -69,13 +210,23 @@ def main():
         nargs="?",
         help="Create a box mesh of dimensions [length]x[height] [m]",
     )
+
     parser.add_argument(
         "--airfoil_mesh_size",
         type=float,
         metavar="SIZE",
         nargs="?",
         default=0.01,
-        help="Mesh size of the airfoil contour [m]  (default 0.01m) (for normal, bl and structural)",
+        help="Mesh size of the airfoil contour [m]  (default 0.01m) (for normal, bl and structured)",
+    )
+
+    parser.add_argument(
+        "--flap_mesh_size",
+        type=float,
+        metavar="SIZE",
+        nargs="?",
+        default=None,
+        help="Mesh size of the flap contour [m] (if not provided, defaults to 85%% of airfoil_mesh_size)",
     )
 
     parser.add_argument(
@@ -99,7 +250,7 @@ def main():
         metavar="HEIGHT",
         nargs="?",
         default=3e-5,
-        help="Height of the first layer [m] (default 3e-5m) (for bl and structural)",
+        help="Height of the first layer [m] (default 3e-5m) (for bl and structured)",
     )
 
     parser.add_argument(
@@ -108,7 +259,7 @@ def main():
         metavar="RATIO",
         nargs="?",
         default=1.2,
-        help="Growth ratio of layers (default 1.2) (for bl and structural)",
+        help="Growth ratio of layers (default 1.2) (for bl and structured)",
     )
 
     parser.add_argument(
@@ -129,16 +280,16 @@ def main():
     )
 
     parser.add_argument(
-        "--structural",
+        "--structured",
         action="store_true",
-        help="Generate a structural mesh",
+        help="Generate a structured mesh",
     )
     parser.add_argument(
         "--arg_struc",
         type=str,
         metavar="[LxL]",
         default="10x10",
-        help="Parameters for the structural mesh [wake length (axis x)]x[total height (axis y)] [m] (default 10x10)",
+        help="Parameters for the structured mesh [wake length (axis x)]x[total height (axis y)] [m] (default 10x10)",
     )
 
     parser.add_argument(
@@ -157,6 +308,24 @@ def main():
     )
     args = parser.parse_args()
 
+    # Handle configuration file operations
+    if args.example_config:
+        create_example_config()
+        sys.exit()
+
+    # Load configuration from file if provided
+    if args.config:
+        try:
+            config_dict = read_config(args.config)
+            args = merge_config_with_args(config_dict, args)
+            print(f"Configuration loaded from: {args.config}")
+        except FileNotFoundError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error reading configuration: {e}", file=sys.stderr)
+            sys.exit(1)
+
     if len(sys.argv) == 1:
         parser.print_help()
         sys.exit()
@@ -167,6 +336,17 @@ def main():
 
     # Airfoil choice
     cloud_points = None
+    airfoil_name = None
+
+    # Check that only one airfoil source is specified
+    airfoil_sources = [args.naca, args.airfoil, args.airfoil_path]
+    specified_sources = [s for s in airfoil_sources if s is not None]
+    
+    if len(specified_sources) > 1:
+        print("\nError: Only one airfoil source can be specified at a time!")
+        print("Choose one of: --naca, --airfoil, or --airfoil_path\n")
+        sys.exit(1)
+
     if args.naca:
         airfoil_name = args.naca
         cloud_points = NACA_4_digit_geom(airfoil_name)
@@ -175,9 +355,17 @@ def main():
         airfoil_name = args.airfoil
         cloud_points = get_airfoil_points(airfoil_name)
 
+    if args.airfoil_path:
+        airfoil_name = Path(args.airfoil_path).stem
+        cloud_points = read_airfoil_from_file(args.airfoil_path)
+
+        if args.flap_path:
+            airfoil_name = Path(args.airfoil_path).stem
+            flap_points = read_airfoil_from_file(args.flap_path)
+
     if cloud_points is None:
         print("\nNo airfoil profile specified, exiting")
-        print("You must use --naca or --airfoil\n")
+        print("You must use --naca, --airfoil, or --airfoil_path\n")
         parser.print_help()
         sys.exit()
 
@@ -200,12 +388,22 @@ def main():
 
     # Airfoil
     airfoil = AirfoilSpline(
-        cloud_points, args.airfoil_mesh_size)
+        cloud_points, args.airfoil_mesh_size, name="airfoil")
     airfoil.rotation(aoa, (0.5, 0, 0), (0, 0, 1))
     gmsh.model.geo.synchronize()
 
-    # If structural, all is done in CType
-    if args.structural:
+    if args.flap_path:
+        # Use flap_mesh_size if provided, otherwise use 85% of airfoil_mesh_size
+        flap_mesh_size = args.flap_mesh_size if args.flap_mesh_size else args.airfoil_mesh_size * 0.85
+        flap = AirfoilSpline(
+            flap_points, flap_mesh_size, name="flap", is_flap=True)
+        flap.rotation(aoa, (0.5, 0, 0), (0, 0, 1))
+        if args.deflection:
+            flap.rotation(-args.deflection * (math.pi / 180), (flap.le.x, flap.le.y, 0), (0, 0, 1))
+        gmsh.model.geo.synchronize()
+
+    # If structured, all is done in CType
+    if args.structured:
         dx_wake, dy = [float(value)for value in args.arg_struc.split("x")]
         mesh = CType(airfoil, dx_wake, dy,
                      args.airfoil_mesh_size, args.first_layer, args.ratio, aoa)
@@ -213,6 +411,8 @@ def main():
 
     else:
         k1, k2 = airfoil.gen_skin()
+        if args.flap_path:
+            k1_flap, k2_flap = flap.gen_skin()
         # Choose the parameters for bl (when exist)
         if not args.no_bl:
             N = args.nb_layers
@@ -228,7 +428,13 @@ def main():
         outofbounds(airfoil, args.box, args.farfield, d[-1])
 
         # External domain
-        if args.box:
+        if args.farfield_ctype:
+            # Use C-type farfield (unstructured) for hybrid meshes
+            ext_domain = CType(
+                airfoil, args.farfield, args.farfield, args.ext_mesh_size,
+                structured=args.structured
+            )
+        elif args.box:
             length, width = [float(value) for value in args.box.split("x")]
             ext_domain = Rectangle(0.5, 0, 0, length, width,
                                    mesh_size=args.ext_mesh_size)
@@ -238,13 +444,21 @@ def main():
         gmsh.model.geo.synchronize()
 
         # Create the surface for the mesh
-        surface = PlaneSurface([ext_domain, airfoil])
+        if args.flap_path:
+            surface = PlaneSurface([ext_domain, airfoil, flap])
+
+        else:
+            surface = PlaneSurface([ext_domain, airfoil])
+
         gmsh.model.geo.synchronize()
 
         # Create the boundary layer
         if not args.no_bl:
             curv = [airfoil.upper_spline.tag,
                     airfoil.lower_spline.tag, airfoil.front_spline.tag]
+            if args.flap_path:
+                curv += [flap.upper_spline.tag,
+                         flap.lower_spline.tag, flap.front_spline.tag]
 
             # Creates a new mesh field of type 'BoundaryLayer' and assigns it an ID (f).
             f = gmsh.model.mesh.field.add('BoundaryLayer')
@@ -260,8 +474,13 @@ def main():
             gmsh.model.mesh.field.setNumber(f, 'Quads', 1)
 
             # Enter the points where we want a "fan" (points must be at end on line)(only te for us)
-            gmsh.model.mesh.field.setNumbers(
-                f, "FanPointsList", [airfoil.te.tag])
+            if args.flap_path:
+                print(f"airfoil.te.tag, flap.te.tag = {airfoil.te.tag, flap.te.tag}")
+                gmsh.model.mesh.field.setNumbers(
+                    f, "FanPointsList", [airfoil.te.tag, flap.te.tag])
+            else:
+                gmsh.model.mesh.field.setNumbers(
+                    f, "FanPointsList", [airfoil.te.tag])
 
             gmsh.model.mesh.field.setAsBoundaryLayer(f)
 
@@ -269,23 +488,26 @@ def main():
         ext_domain.define_bc()
         surface.define_bc()
         airfoil.define_bc()
+        if args.flap_path:
+            flap.define_bc()
 
     gmsh.model.geo.synchronize()
 
     # Choose the parameters of the mesh : we want the mesh size according to the points and not curvature (doesn't work with farfield)
     gmsh.option.setNumber("Mesh.MeshSizeFromPoints", 1)
     gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 0)
-    if not args.structural and not args.no_bl:
-        # Add transfinite line on the front to get more point in the middle (where the curvature of the le makes it usually more spaced)
-        x, y, v, w = airfoil.points[k1].x, airfoil.points[k2].y, airfoil.points[k1].x, airfoil.points[k2].y
-        c1, c2 = airfoil.le.x, airfoil.le.y
-        # To get an indication of numbers of points needed, compute approximate length of curve of front spline
-        l = (math.sqrt((x-c1)*(x-c1)+(y-c2)*(y-c2)) +
-             math.sqrt((v-c1)*(v-c1)+(w-c2)*(w-c2)))
-        # As points will be more near than mesh size on the front, need more points
-        nb_points = int(3.5*l/args.airfoil_mesh_size)
-        gmsh.model.mesh.setTransfiniteCurve(
-            airfoil.front_spline.tag, nb_points, "Bump", 10)
+
+    if not args.structured and not args.no_bl:
+        # Apply transfinite meshing to all three splines (front, upper, lower) 
+        # for consistent cell sizing around the airfoil/flap surfaces
+        
+        # Apply to airfoil
+        apply_transfinite_to_surfaces(airfoil, args.airfoil_mesh_size, name="Airfoil")
+        
+        # Apply to flap if present
+        if args.flap_path:
+            apply_transfinite_to_surfaces(flap, args.airfoil_mesh_size, name="Flap")
+        
         # Choose the nbs of points in the fan at the te:
         # Compute coef : between 10 and 25, 15 when usual mesh size but adapted to mesh size
         coef = max(10, min(25, 15*0.01/args.airfoil_mesh_size))
@@ -300,11 +522,25 @@ def main():
         gmsh.fltk.run()
 
     # Mesh file name and output
+    if airfoil_name:
+        airfoil_name = airfoil_name.replace(".dat", "")
+
+    if args.flap_path:
+        airfoil_name = airfoil_name + "_flap"
+
     mesh_path = Path(
         args.output, f"mesh_airfoil_{airfoil_name}.{args.format}")
     gmsh.write(str(mesh_path))
     gmsh.finalize()
 
+    # Save configuration if requested
+    if args.save_config:
+        # Remove None values and internal arguments from the config dict
+        config_dict = {k: v for k, v in vars(args).items() 
+                      if v is not None and v is not False 
+                      and k not in ['config', 'save_config', 'example_config', 'list']}
+        from gmshairfoil2d.config_handler import write_config
+        write_config(config_dict, args.save_config)
 
 if __name__ == "__main__":
     main()

{gmshairfoil2d-0.2.1.dist-info → gmshairfoil2d-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gmshairfoil2d
-Version: 0.2.1
+Version: 0.2.3
 Summary: Python tool to generate 2D mesh around an airfoil
 Home-page: https://github.com/cfsengineering/GMSH-Airfoil-2D
 Author: Giacomo Benedetti
@@ -61,32 +61,68 @@ gmshairfoil2d -h
 
 optional arguments:
   -h, --help                  Show this help message and exit
+  --config [PATH]             Path to configuration file (key=value format)
+  --save_config [PATH]        Save current configuration to file
+  --example_config            Create an example configuration file
   --list                      Display all airfoil available in the database :
                               https://m-selig.ae.illinois.edu/ads/coord_database.html
   --naca [4DIGITS]            NACA airfoil 4 digit
   --airfoil [NAME]            Name of an airfoil profile in the database (database available with
                               the --list argument)
+  --airfoil_path [PATH]       Path to custom airfoil .dat file
+  --flap_path [PATH]          Path to custom flap .dat file
   --aoa [AOA]                 Angle of attack [deg] (default: 0 [deg])
+  --deflection [DEFLECTION]   Flap deflection angle [deg] (default: 0 [deg])
   --farfield [RADIUS]         Create a circular farfield mesh of given radius [m] (default 10m)
+  --farfield_ctype            Generate a C-type structured farfield for hybrid meshes
   --box [LENGTHxWIDTH]        Create a box mesh of dimensions [length]x[height] [m]
   --airfoil_mesh_size [SIZE]  Mesh size of the airfoil contour [m] (default 0.01m)
-  --ext_mesh_size [SIZE]      Mesh size of the external domain [m] (default 0.2m) (for normal, bl
-                              and structural)
+  --ext_mesh_size [SIZE]      Mesh size of the external domain [m] (default 0.2m)
   --no_bl                     Do the unstructured meshing (with triangles), without a boundary
                               layer
-  --first_layer [HEIGHT]      Height of the first layer [m] (default 3e-5m) (for bl and structural)
-  --ratio [RATIO]             Growth ratio of layers (default 1.2) (for bl and structural)
+  --first_layer [HEIGHT]      Height of the first layer [m] (default 3e-5m) (for bl and structured)
+  --ratio [RATIO]             Growth ratio of layers (default 1.2) (for bl and structured)
   --nb_layers [INT]           Total number of layers in the boundary layer (default 35)
   --format [FORMAT]           Format of the mesh file, e.g: msh, vtk, wrl, stl, mesh, cgns, su2,
                               dat (default su2)
-  --structural                Generate a structural mesh
-  --arg_struc [LxLxL]         Parameters for the structural mesh [leading (axis x)]x[wake (axis
-                              x)]x[total height (axis y)] [m] (default 1x10x10)
+  --structured                Generate a structured mesh
+  --arg_struc [LxL]           Parameters for the structured mesh [wake length (axis x)]x[total 
+                              height (axis y)] [m] (default 10x10)
   --output [PATH]             Output path for the mesh file (default : current dir)
   --ui                        Open GMSH user interface to see the mesh
 
 ```
 
+## Configuration Files
+
+Instead of using command-line arguments, you can use configuration files for batch processing. Configuration files use a simple `key=value` format with support for comments.
+
+**Create an example configuration file:**
+
+```bash
+gmshairfoil2d --example_config
+```
+
+**Use a configuration file:**
+
+```bash
+gmshairfoil2d --config my_config.cfg
+```
+
+**Override config values with CLI arguments:**
+
+```bash
+gmshairfoil2d --config my_config.cfg --aoa 5.0
+```
+
+**Save current configuration to file:**
+
+```bash
+gmshairfoil2d --naca 0012 --aoa 5.0 --save_config my_config.cfg
+```
+
+For more details, see [example/CONFIG_README.md](example/CONFIG_README.md) and ready-to-use examples in [example/EXAMPLES_README.md](example/EXAMPLES_README.md).
+
 ## Examples of use
 
 To check all airfoil available in the [database](https://m-selig.ae.illinois.edu/ads/coord_database.html):
@@ -95,7 +131,9 @@ To check all airfoil available in the [database](https://m-selig.ae.illinois.edu
 gmshairfoil2d --list
 ```
 
-For all the following examples, the defauld chord lenght is 1 meter.
+For all the following examples, the default chord length is 1 meter.
+
+### Example 1: NACA0012 with circular farfield
 
 To create a circular farfield mesh around a NACA0012 of 10m of radius and see the result with GMSH user interface:
 
@@ -103,37 +141,87 @@ To create a circular farfield mesh around a NACA0012 of 10m of radius and see th
 gmshairfoil2d --naca 0012 --farfield 10 --ui --no_bl
 ```
 
+Or using config file:
+
+```bash
+gmshairfoil2d --config example/example1_naca0012.cfg
+```
+
 ![GMSH user interface with the 2D mesh](images/example_mesh.png)
 
-To create a circular farfield mesh with boudary layer around a Drela DAE11 airfoil (the name in the database is "dae11") of 4m or radius with a mesh size of 0.005m on the airfoil (but to not open on the interface):
+### Example 2: DAE11 with boundary layer
+
+To create a circular farfield mesh with boundary layer around a Drela DAE11 airfoil (the name in the database is "dae11") of 4m of radius with a mesh size of 0.005m on the airfoil:
 
 ```bash
 gmshairfoil2d --airfoil dae11 --farfield 4 --airfoil_mesh_size 0.005
 ```
 
-To create mesh around a Eppler E220 airfoil (the name in the database is "e211") with an angle of attack of 8 degree in a box of 12x4m (lenght x height) and save it as a vtk mesh and see the result with GMSH user interface:
+Or using config file:
+
+```bash
+gmshairfoil2d --config example/example2_dae11.cfg
+```
+
+### Example 3: E211 in box with angle of attack
+
+To create mesh around an Eppler E211 airfoil (the name in the database is "e211") with an angle of attack of 8 degree in a box of 12x4m (length x height) and save it as a VTK mesh:
 
 ```bash
 gmshairfoil2d --airfoil e211 --aoa 8 --box 12x4 --format vtk --ui --no_bl
 ```
 
-![GMSH user interface with the 2D mesh, rectangular box](images/example_mesh_box.png)
+Or using config file:
 
+```bash
+gmshairfoil2d --config example/example3_e211_box.cfg
+```
 
+![GMSH user interface with the 2D mesh, rectangular box](images/example_mesh_box.png)
+
+### Example 4: CH10SM with box and boundary layer
 
-To create a boxed mesh around a Chuch Hollinger CH 10-48-13 smoothed airfoil (the name in the database is "ch10sm"), using the boundary layer with default parameters (first layer of height 3e-5, 35 layers and growth ratio of 1.2) :
+To create a boxed mesh around a Chuck Hollinger CH10SM airfoil (the name in the database is "ch10sm"), using the boundary layer with default parameters (first layer of height 3e-5, 35 layers and growth ratio of 1.2):
 
 ```bash
 gmshairfoil2d --airfoil ch10sm --ui --box 2x1.4
 ```
 
+Or using config file:
+
+```bash
+gmshairfoil2d --config example/example4_ch10sm_bl.cfg
+```
+
 ![GMSH result with 2D mesh with boundary layer, rectangular box](images/example_ch10sm_bl.png)
 
+### Example 5: NACA4220 structured mesh
+
+To create a structured mesh around a NACA4220 airfoil with first layer height of 0.01, mesh size of 0.08, wake length of 6, height of 7, and angle of attack of 6 degrees:
+
+```bash
+gmshairfoil2d --naca 4220 --airfoil_mesh_size 0.08 --ui --structured --first_layer 0.01 --arg_struc 6x7 --aoa 6
+```
+
+Or using config file:
+
+```bash
+gmshairfoil2d --config example/example5_naca4220_structured.cfg
+```
+
+![GMSH result with 2D structured mesh](images/example_structured_naca4220.png)
+### Example 6: Custom airfoil from file
+
+To create a mesh around a custom airfoil profile with a deflected flap:
+
+```bash
+gmshairfoil2d --airfoil_path tests/test_data/NLR_7301.dat --flap_path tests/test_data/Flap_NLR_7301.dat --deflection 10 --box 4x3 --ui --no_bl
+```
 
-To create a structural mesh around a Naca 4220 airfoil (the 4 digits code is obviously "4220"), with first layer height of 0.01, mesh_size of 0.08 wake length of 6, height of 7, and angle of attack of 6 degrees :
+Or using config file:
 
 ```bash
- gmshairfoil2d --naca 4220 --airfoil_mesh_size 0.08 --ui --structural --first_layer 0.01 --arg_struc 6x7 --aoa 6
+gmshairfoil2d --config example/example6_custom_airfoil_flap.cfg
 ```
 
-![GMSH result with 2D structural mesh](images/example_structural_naca4220.png)
+This example shows how to load custom airfoil and flap profiles from external .dat files and generate a mesh with flap deflection, useful for using proprietary or custom-designed airfoil geometries.

gmshairfoil2d-0.2.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+gmshairfoil2d/__init__.py,sha256=VEFFbq6EClONvPaNYBMGUnR64J06nJaO_ErPZi6WyRE,84
+gmshairfoil2d/__main__.py,sha256=SdT5IPOCPld7yGCoC3cb6v55E9Ys3KeM1vrVocBqtG4,134
+gmshairfoil2d/airfoil_func.py,sha256=UGugj2Djp-7JTv_AzEwmQcMQNMtqHSVzAdIIxZNwDyQ,7545
+gmshairfoil2d/config_handler.py,sha256=WM10C_yxlAl6A0sAsgW9KbfIHnrWOhvwMbs7F_AQePI,5490
+gmshairfoil2d/geometry_def.py,sha256=D3FuRfaZ_YgHTvDW3KWB6Cya_2tJEktFvZkTA13h7pQ,48800
+gmshairfoil2d/gmshairfoil2d.py,sha256=acEOhx8IlhRkXfFP-C-3rtqlslXgbIW276Xcz3k5Tq8,18657
+gmshairfoil2d-0.2.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_airfoil_func.py,sha256=uCzaCbr4BHfKCHF_9gEQ7hzgwQSt7rEZRrRCbEOtOlw,4158
+tests/test_config_handler.py,sha256=TI0OvZRbsho8mjzf1kUXLQ-rm_6dGY4b6w9RxYDxS5A,6449
+tests/test_geometry_def.py,sha256=Ox_ePu1sZs5dOZTsPj87b3b_gHwrC3UzyoJsuL-VeUk,1325
+gmshairfoil2d-0.2.3.dist-info/METADATA,sha256=WP9jWHSg8z1bSsyYFuYMdG36-AqspQWKO6T-vHlQzFc,8152
+gmshairfoil2d-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gmshairfoil2d-0.2.3.dist-info/entry_points.txt,sha256=6OBSsEXNhTICrsEGgfg30RGIkKRFXELizYtfZfT1_zk,67
+gmshairfoil2d-0.2.3.dist-info/top_level.txt,sha256=OUzQHTQIzJHlW1k6tm_9PLfE4eEWkwH0oOYNUuUXekw,20
+gmshairfoil2d-0.2.3.dist-info/RECORD,,