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

gmshairfoil2d/__init__.py

@@ -0,0 +1,3 @@
+"""GMSH-Airfoil-2D: 2D airfoil mesh generation with GMSH."""
+
+__version__ = "1.0.0"

gmshairfoil2d/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for the gmshairfoil2d package."""
+
+from gmshairfoil2d.gmshairfoil2d import main
+
+if __name__ == "__main__":
+    main()

gmshairfoil2d/airfoil_func.py

@@ -1,8 +1,8 @@
+import sys
 from pathlib import Path
 
 import numpy as np
 import requests
-import sys
 
 import gmshairfoil2d.__init__
 
@@ -10,6 +10,71 @@ LIB_DIR = Path(gmshairfoil2d.__init__.__file__).parents[1]
 database_dir = Path(LIB_DIR, "database")
 
 
+def read_airfoil_from_file(file_path):
+    """Read airfoil coordinates from a .dat file.
+    
+    Parameters
+    ----------
+    file_path : str or Path
+        Path to airfoil data file
+    
+    Returns
+    -------
+    list
+        List of unique (x, y, 0) points sorted by original order
+    
+    Raises
+    ------
+    FileNotFoundError
+        If file does not exist
+    ValueError
+        If no valid airfoil points found
+    """
+    file_path = Path(file_path)
+    if not file_path.exists():
+        raise FileNotFoundError(f"File {file_path} not found.")
+
+    airfoil_points = []
+    with open(file_path, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith(('#', 'Airfoil')):
+                continue
+            parts = line.split()
+            if len(parts) != 2:
+                continue
+            try:
+                x, y = map(float, parts)
+            except ValueError:
+                continue
+            if x > 1 and y > 1:
+                continue
+            airfoil_points.append((x, y))
+
+    if not airfoil_points:
+        raise ValueError(f"No valid airfoil points found in {file_path}")
+
+    # Split upper and lower surfaces
+    try:
+        split_index = next(i for i, (x, y) in enumerate(airfoil_points) if x >= 1.0)
+    except StopIteration:
+        split_index = len(airfoil_points) // 2
+
+    upper_points = airfoil_points[:split_index + 1]
+    lower_points = airfoil_points[split_index + 1:]
+
+    # Ensure lower points start from trailing edge
+    if lower_points and lower_points[0][0] == 0.0:
+        lower_points = lower_points[::-1]
+
+    # Combine and remove duplicates
+    x_up, y_up = zip(*upper_points) if upper_points else ([], [])
+    x_lo, y_lo = zip(*lower_points) if lower_points else ([], [])
+
+    cloud_points = [(x, y, 0) for x, y in zip([*x_up, *x_lo], [*y_up, *y_lo])]
+    return sorted(set(cloud_points), key=cloud_points.index)
+
+
 def get_all_available_airfoil_names():
     """
     Request the airfoil list available at m-selig.ae.illinois.edu
@@ -34,102 +99,92 @@ def get_all_available_airfoil_names():
 
 def get_airfoil_file(airfoil_name):
     """
-    Request the airfoil .dat file at m-selig.ae.illinois.edu and stores it (if found) in the
-    database folder
+    Request the airfoil .dat file from m-selig.ae.illinois.edu and store it in database folder.
 
     Parameters
     ----------
-    airfoil_name : srt
-        name of the airfoil
+    airfoil_name : str
+        Name of the airfoil
+    
+    Raises
+    ------
+    SystemExit
+        If airfoil not found or network error occurs
     """
-
     if not database_dir.exists():
         database_dir.mkdir()
 
-    url = f"https://m-selig.ae.illinois.edu/ads/coord/{airfoil_name}.dat"
-
-    r = requests.get(url)
+    file_path = Path(database_dir, f"{airfoil_name}.dat")
+    if file_path.exists():
+        return
 
+    url = f"https://m-selig.ae.illinois.edu/ads/coord/{airfoil_name}.dat"
     try:
-        r = requests.get(url, timeout=10) # Aggiungi sempre un timeout
-        if r.status_code != 200:
-             # Invece di raise Exception, print e exit pulito
-             print(f"❌ Error: Could not find airfoil '{airfoil_name}' on UIUC database.")
-             import sys
-             sys.exit(1)
-    except requests.exceptions.RequestException as e:
+        response = requests.get(url, timeout=10)
+        if response.status_code != 200:
+            print(f"❌ Error: Could not find airfoil '{airfoil_name}' on UIUC database.")
+            sys.exit(1)
+        with open(file_path, "wb") as f:
+            f.write(response.content)
+    except requests.exceptions.RequestException:
         print(f"❌ Network Error: Could not connect to the database. Check your internet.")
-        import sys
         sys.exit(1)
 
-    file_path = Path(database_dir, f"{airfoil_name}.dat")
-
-    if not file_path.exists():
-        with open(file_path, "wb") as f:
-            f.write(r.content)
-
 
 def get_airfoil_points(airfoil_name):
-
-    airfoil_points = []
-    upper_points = []
-    lower_points = []
-    upper_len = 0
-    lower_len = 0
-    reverse_lower = False
-
+    """Load airfoil points from the database.
+    
+    Parameters
+    ----------
+    airfoil_name : str
+        Name of the airfoil in the database
+    
+    Returns
+    -------
+    list
+        List of unique (x, y, 0) points
+    
+    Raises
+    ------
+    ValueError
+        If no valid points found for the airfoil
+    """
     get_airfoil_file(airfoil_name)
-    airfoil_file = Path(database_dir, airfoil_name + ".dat")
+    airfoil_file = Path(database_dir, f"{airfoil_name}.dat")
 
+    airfoil_points = []
     with open(airfoil_file) as f:
-        lines = f.readlines()
-
-    for line in lines:
-
-        # Catch the text lines
-        try:
-            x, y = map(float, line.strip("\n").split())
-        except ValueError:
-            continue
-
-        # Catch the line with the upper and lower number of points
-        if x > 1 and y > 1:
-            upper_len = int(x)
-            lower_len = int(y)
-            continue
-
-        # Catch the x, y coordinates
-        airfoil_points.append((x, y))
+        for line in f:
+            try:
+                x, y = map(float, line.strip().split())
+            except ValueError:
+                continue
+            if x > 1 and y > 1:
+                continue
+            airfoil_points.append((x, y))
+
+    if not airfoil_points:
+        raise ValueError(f"No valid points found for airfoil {airfoil_name}")
 
     n_points = len(airfoil_points)
+    upper_len = n_points // 2
 
-    if not upper_len or not lower_len:
-
-        upper_len = n_points // 2
-
-        for i, (x, y) in enumerate(airfoil_points):
-            if x == y == 0:
-                upper_len = i
-                break
-    else:
-        reverse_lower = True
+    # Try to find split point at (0, 0)
+    for i, (x, y) in enumerate(airfoil_points):
+        if x == y == 0:
+            upper_len = i
+            break
 
     upper_points = airfoil_points[:upper_len]
     lower_points = airfoil_points[upper_len:]
-
-    if reverse_lower:
+    
+    if lower_points and lower_points[0][0] == 0:
         lower_points = lower_points[::-1]
 
-    assert len(upper_points) + len(lower_points) == n_points
-
-    x_up, y_up = zip(*[points for points in upper_points])
-    x_lo, y_lo = zip(*[points for points in lower_points])
-
-    x = [*x_up, *x_lo]
-    y = [*y_up, *y_lo]
+    x_up, y_up = zip(*upper_points) if upper_points else ([], [])
+    x_lo, y_lo = zip(*lower_points) if lower_points else ([], [])
 
-    cloud_points = [(x[k], y[k], 0) for k in range(0, len(x))]
-    # remove duplicated points
+    cloud_points = [(x, y, 0) for x, y in zip([*x_up, *x_lo], [*y_up, *y_lo])]
     return sorted(set(cloud_points), key=cloud_points.index)
 
 

gmshairfoil2d/config_handler.py

@@ -0,0 +1,198 @@
+"""Configuration file handler for gmshairfoil2d.
+
+Supports reading and writing simple key=value configuration files.
+Empty values are skipped.
+"""
+
+from pathlib import Path
+
+
+def _convert_value(value, key, string_params):
+    """Convert string value to appropriate type.
+    
+    Parameters
+    ----------
+    value : str
+        String value to convert
+    key : str
+        Configuration key name
+    string_params : set
+        Set of keys that should remain as strings
+    
+    Returns
+    -------
+    str, int, float, bool, or None
+        Converted value
+    """
+    if key in string_params:
+        return value
+    
+    value_lower = value.lower()
+    if value_lower == 'true':
+        return True
+    elif value_lower == 'false':
+        return False
+    elif value_lower == 'none':
+        return None
+    
+    # Try to convert to numeric
+    try:
+        if '.' in value or 'e' in value_lower:
+            return float(value)
+        return int(value)
+    except ValueError:
+        return value
+
+
+def read_config(config_path):
+    """Read configuration from a simple config file (key=value format).
+    
+    Empty values are skipped. Values are automatically converted to appropriate types
+    (int, float, bool) unless the key is in the string_params set.
+    
+    Parameters
+    ----------
+    config_path : str or Path
+        Path to the configuration file
+    
+    Returns
+    -------
+    dict
+        Dictionary containing configuration parameters
+    
+    Raises
+    ------
+    FileNotFoundError
+        If the configuration file doesn't exist
+    Exception
+        If there's an error parsing the configuration file
+    """
+    config_path = Path(config_path)
+    
+    if not config_path.exists():
+        raise FileNotFoundError(f"Configuration file not found: {config_path}")
+    
+    # Parameters that should always remain as strings
+    string_params = {'naca', 'airfoil', 'airfoil_path', 'flap_path', 'format', 'arg_struc', 'box'}
+    
+    config = {}
+    
+    try:
+        with open(config_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                # Skip empty lines and comments
+                if not line or line.startswith('#'):
+                    continue
+                
+                # Split by first '=' only
+                if '=' not in line:
+                    continue
+                
+                key, value = line.split('=', 1)
+                key = key.strip()
+                value = value.strip()
+                
+                # Skip empty values
+                if not value:
+                    continue
+                
+                # Convert value to appropriate type
+                config[key] = _convert_value(value, key, string_params)
+        
+        return config
+    
+    except FileNotFoundError:
+        raise
+    except Exception as e:
+        raise Exception(f"Error parsing configuration file: {e}") from e
+
+
+def write_config(config_dict, output_path):
+    """
+    Write configuration to a simple config file (key=value format).
+    
+    Parameters
+    ----------
+    config_dict : dict
+        Configuration dictionary to write
+    output_path : str or Path
+        Output path for the configuration file
+    """
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(output_path, 'w') as f:
+        for key, value in config_dict.items():
+            if value is None:
+                f.write(f"{key}=\n")
+            else:
+                f.write(f"{key}= {value}\n")
+    
+    print(f"Configuration saved to: {output_path}")
+
+
+def merge_config_with_args(config_dict, args):
+    """Merge configuration file parameters with command-line arguments.
+    
+    Command-line arguments take precedence over config file values. Only applies
+    config values when the command-line value is None or False (default).
+    
+    Parameters
+    ----------
+    config_dict : dict
+        Configuration dictionary from config file
+    args : argparse.Namespace
+        Command-line arguments
+    
+    Returns
+    -------
+    argparse.Namespace
+        Merged arguments with config values applied
+    """
+    args_dict = vars(args)
+    
+    # For each key in config, update args only if not explicitly set on command line
+    for key, value in config_dict.items():
+        if key in args_dict:
+            # Only override with config value if current value is default/None/False
+            if args_dict[key] is None or args_dict[key] is False:
+                setattr(args, key, value)
+    
+    return args
+
+
+def create_example_config(output_path="config_example.cfg"):
+    """
+    Create an example configuration file with all available options.
+    
+    Parameters
+    ----------
+    output_path : str or Path
+        Output path for the example configuration file
+    """
+    example_config = {
+        "naca": "0012",
+        "airfoil": None,
+        "airfoil_path": None,
+        "flap_path": None,
+        "aoa": "0.0",
+        "deflection": "0.0",
+        "farfield": "10",
+        "farfield_ctype": None,
+        "box": None,
+        "airfoil_mesh_size": "0.01",
+        "flap_mesh_size": None,
+        "ext_mesh_size": "0.2",
+        "no_bl": "False",
+        "first_layer": "3e-05",
+        "ratio": "1.2",
+        "nb_layers": "35",
+        "format": "su2",
+        "structured": "False",
+        "arg_struc": "10x10",
+        "output": None,
+        "ui": "False",
+    }
+    
+    write_config(example_config, output_path)