airfoilranssolver 0.1.0__tar.gz

airfoilranssolver-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isaac.Robledo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

airfoilranssolver-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: airfoilranssolver
+Version: 0.1.0
+Summary: Python tools for 2D airfoil Openfoam Simulation
+Author-email: Isaac <isaac.robledo.martin@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ipatazas/AirfoilRANSSolver
+Project-URL: Repository, https://github.com/ipatazas/AirfoilRANSSolver
+Project-URL: Issues, https://github.com/ipatazas/AirfoilRANSSolver/issues
+Keywords: airfoil,aerodynamics,cfd
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: airfoilgmesher
+Requires-Dist: scipy
+Requires-Dist: fluidfoam
+Requires-Dist: pandas
+Requires-Dist: gmsh
+Dynamic: license-file
+
+# AirfoilRANSSolver
+Repository to run RANS models on 2D airfoils

airfoilranssolver-0.1.0/README.md

@@ -0,0 +1,2 @@
+# AirfoilRANSSolver
+Repository to run RANS models on 2D airfoils

airfoilranssolver-0.1.0/airfoilranssolver/launchers_no_coefficient_control.py

@@ -0,0 +1,273 @@
+import os
+import shutil
+import numpy as np
+import pandas as pd
+import time
+import subprocess
+import signal
+
+from pathlib import Path
+
+from fluidfoam.readof import readmesh, readscalar, readvector
+from airfoilgmesher.mesher import meshing_pipeline
+from airfoilgmesher.utils import plot_gmsh_mesh
+
+from airfoilranssolver.utils import (
+    replace_foam_scalar_entry,
+    read_post_processing_file,
+    compute_sst_initial_properties_from_nut_ratio,
+    compute_compressible_freestream,
+    replace_foam_internal_field,
+    replace_dictionary_scalar,
+    replace_p_outlet_fieldInf,
+    patch_control_dict_time_settings,
+    estimate_min_edge_from_gmsh_msh,
+    compute_acoustic_cfl_delta_t,
+)
+
+def patch_transonic_case(output_path, props):
+    output_path = Path(output_path)
+    replace_foam_internal_field(output_path / "0" / "U", (props["U_inf"], 0.0, 0.0), is_vector=True)
+    replace_foam_internal_field(output_path / "0" / "p", props["p_inf"])
+    replace_foam_internal_field(output_path / "0" / "T", props["T_inf"])
+    replace_foam_internal_field(output_path / "0" / "k", props["k"])
+    replace_foam_internal_field(output_path / "0" / "omega", props["omega"])
+    replace_foam_internal_field(output_path / "0" / "nut", props["nut"])
+    replace_foam_internal_field(output_path / "0" / "alphat", props["alphat"])
+    replace_p_outlet_fieldInf(output_path / "0" / "p", props["p_inf"])
+    replace_dictionary_scalar(output_path / "system" / "forceCoeffs", "rhoInf", props["rho_inf"])
+    replace_dictionary_scalar(output_path / "system" / "forceCoeffs", "magUInf", props["U_inf"])
+
+def launch_pimplefoam(output_path, Re, geometry_parameters, mesh_parameters, splitting_parameters=None, permutation_parameters=None,refinement_parameters=None, n_subdomains=48):
+    ref = time.time()
+    local_path = os.path.dirname(__file__)
+
+    nu = 1.0 / Re
+    
+    if not os.path.isdir(output_path):
+        os.mkdir(output_path)
+    shutil.copytree(f'{local_path}/Templates/Template_pimplefoam', output_path, dirs_exist_ok=True)
+    shutil.copytree(f'{output_path}/0_org', f'{output_path}/0', dirs_exist_ok=True)
+
+    if Re <= 0:
+        raise ValueError("reynolds must be positive.")
+
+    if n_subdomains < 1:
+        raise ValueError("n_subdomains must be >= 1.")
+
+    props = compute_sst_initial_properties_from_nut_ratio(
+        Re=Re,
+        c=1.0,
+        u_inf=1.0,
+        rho=1.0,
+        I=0.005,          # 0.5% turbulence intensity
+        nut_over_nu=10.0, # robust initial turbulent-viscosity ratio
+    )
+
+    replace_foam_scalar_entry(
+        Path(output_path) / "constant" / "transportProperties",
+        "nu",
+        props["nu"],
+    )
+
+    replace_foam_internal_field(
+        Path(output_path) / "0" / "k",
+        props["k"],
+    )
+
+    replace_foam_internal_field(
+        Path(output_path) / "0" / "omega",
+        props["omega"],
+    )
+
+    replace_foam_internal_field(
+        Path(output_path) / "0" / "nut",
+        props["nut"],
+    )
+
+    geo_path = Path(output_path) / "airfoil.geo"
+
+    meshing_pipeline(
+        str(geo_path),
+        geometry_parameters,
+        mesh_parameters,
+        splitting_parameters,
+        permutation_parameters,
+        refinement_parameters,
+    )
+
+    msh_path = geo_path.with_suffix(".msh")
+
+    plot_gmsh_mesh(msh_path, output_path + "mesh.png")
+
+    try:
+        env = os.environ.copy()
+        env.pop("DISPLAY", None)
+        env.pop("XAUTHORITY", None)
+        env["NP"] = str(int(n_subdomains))
+        result = subprocess.run(
+                ["bash", "Allrun"],
+                cwd=output_path,
+                capture_output=True,
+                text=True,
+                env=env,
+            )
+        
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"OpenFOAM failed with return code {result.returncode}\n"
+                f"STDOUT:\n{result.stdout[-4000:]}\n"
+                f"STDERR:\n{result.stderr[-4000:]}"
+            )
+
+        print(f'Processing time {(time.time()-ref)/60} mins')
+        # Read the mean pressure field (pMean) from the time folder
+        p_mean = readscalar(output_path, time_name="latestTime", name="pMean", boundary='airfoil')
+        tau_W  = readvector(output_path, time_name="latestTime", name="wallShearStressMean", boundary='airfoil')
+        mag_tau_w = np.sqrt(np.power(tau_W[0,:],2)+np.power(tau_W[1,:],2))
+        x,y,_ = readmesh(output_path,boundary='airfoil')
+        # Since inco Cp = 2*(p-pinf) since uinf, rhoinf = 1
+        Cp = 2*(p_mean-0)
+        Cf = mag_tau_w*2
+        df_to = pd.DataFrame({'x':x,'y':y,'Cp':Cp,'Cf':Cf})
+        df_to.to_csv(f'{output_path}/Cp.csv')
+
+        filename = f'{output_path}/postProcessing/forces/0/coefficient.dat'
+
+        df = read_post_processing_file(filename)
+
+        n_tail = min(2000, df.shape[0])
+        Cd = df["Cd"].iloc[-n_tail:].mean()
+        Cl = df["Cl"].iloc[-n_tail:].mean()
+
+        np.savez(output_path + '/coefficients',Cd=Cd, Cl=Cl)
+        df.to_csv(output_path + '/outputs_processed.csv')
+
+    except:
+        raise Exception('Error in the computation')
+    
+def launch_rho_pimplefoam(
+    output_path,
+    Mach,
+    Re,
+    geometry_parameters,
+    mesh_parameters,
+    splitting_parameters=None,
+    permutation_parameters=None,
+    refinement_parameters=None,
+    n_subdomains=48,
+    c=1.0,
+    T_inf=288.15,
+    I=0.005,
+    nut_over_nu=10.0,
+    target_cfl=0.95,
+    n_iterations=100000,
+    write_every_iterations=1000,
+    dx_percentile=None,   # None = absolute minimum edge; 1.0 = 1st percentile
+    ):
+    ref = time.time()
+    local_path = os.path.dirname(__file__)
+    output_path = Path(output_path)
+
+    if Re <= 0:
+        raise ValueError("Re must be positive.")
+    if Mach <= 0:
+        raise ValueError("Mach must be positive.")
+    if n_subdomains < 1:
+        raise ValueError("n_subdomains must be >= 1.")
+    if target_cfl <= 0:
+        raise ValueError("target_cfl must be positive.")
+    if n_iterations < 1:
+        raise ValueError("n_iterations must be >= 1.")
+    if write_every_iterations < 1:
+        raise ValueError("write_every_iterations must be >= 1.")
+    
+    output_path.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(Path(local_path) / "Templates" / "Template_rhoPimpleFoam", output_path, dirs_exist_ok=True)
+    shutil.copytree(output_path / "0_org", output_path / "0", dirs_exist_ok=True)
+
+    props = compute_compressible_freestream(
+        Mach=Mach,
+        Re=Re,
+        c=c,
+        T_inf=T_inf,
+        I=I,
+        nut_over_nu=nut_over_nu,
+    )
+    patch_transonic_case(output_path, props)
+
+    geo_path = output_path / "airfoil.geo"
+    meshing_pipeline(
+        str(geo_path),
+        geometry_parameters,
+        splitting_parameters,
+        permutation_parameters,
+        mesh_parameters,
+        refinement_parameters,
+    )
+    msh_path = geo_path.with_suffix(".msh")
+
+    plot_gmsh_mesh(msh_path, output_path / "mesh.png")
+
+    dx_cfl = estimate_min_edge_from_gmsh_msh(
+        msh_path,
+        percentile=dx_percentile,
+    )
+
+    delta_t = compute_acoustic_cfl_delta_t(
+        props=props,
+        dx=dx_cfl,
+        cfl=target_cfl,
+    )
+
+    end_time = patch_control_dict_time_settings(
+        output_path,
+        delta_t=delta_t,
+        n_iterations=n_iterations,
+        write_every_iterations=write_every_iterations,
+        start_from="startTime",
+    )
+
+    env = os.environ.copy()
+    env.pop("DISPLAY", None)
+    env.pop("XAUTHORITY", None)
+    env["NP"] = str(int(n_subdomains))
+
+    result = subprocess.run(["bash", "Allrun"], cwd=output_path, capture_output=True, text=True, env=env)
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"OpenFOAM failed with return code {result.returncode}\n"
+            f"STDOUT:\n{result.stdout[-6000:]}\n"
+            f"STDERR:\n{result.stderr[-6000:]}"
+        )
+
+    print(f'Processing time {(time.time()-ref)/60} mins')
+    # Read the mean pressure field (pMean) from the time folder
+    p_mean = readscalar(output_path, time_name="latestTime", name="pMean", boundary='airfoil')
+    tau_W  = readvector(output_path, time_name="latestTime", name="wallShearStressMean", boundary='airfoil')
+    mag_tau_w = np.sqrt(np.power(tau_W[0,:],2)+np.power(tau_W[1,:],2))
+    x,y,_ = readmesh(str(output_path),boundary='airfoil')
+    # Since inco Cp = 2*(p-pinf) since uinf, rhoinf = 1
+    Cp = 2*(p_mean-0)
+    Cf = mag_tau_w*2
+    df_to = pd.DataFrame({'x':x,'y':y,'Cp':Cp,'Cf':Cf})
+    df_to.to_csv(f'{output_path}/Cp.csv')
+
+    coeff_file = output_path / "postProcessing" / "forces" / "0" / "coefficient.dat"
+    df = read_post_processing_file(str(coeff_file))
+    n_tail = min(2000, df.shape[0])
+    Cd = df["Cd"].iloc[-n_tail:].mean()
+    Cl = df["Cl"].iloc[-n_tail:].mean()
+
+    np.savez(
+        output_path / "coefficients.npz",
+        Cd=Cd,
+        Cl=Cl,
+        delta_t=delta_t,
+        dx_cfl=dx_cfl,
+        target_cfl=target_cfl,
+        n_iterations=n_iterations,
+        end_time=end_time,
+        **props,
+    )
+    df.to_csv(output_path / "outputs_processed.csv", index=False)