Fix warnings

.JETLSConfig.toml

@@ -4,4 +4,17 @@ formatter = "JuliaFormatter"
 auto_instantiate = false            # boolean, default: true
 
 [diagnostic]
-all_files = false                   # boolean, default: true
+all_files = false                   # boolean, default: true
+
+[[diagnostic.patterns]]
+pattern = "no matching method found `copy!\\(::Random\\.TaskLocalRNG, ::Nothing\\)`"
+match_by = "message"
+match_type = "regex"
+severity = "off"
+
+[[diagnostic.patterns]]
+pattern = "IncorrectCallArgs"
+match_by = "code"
+match_type = "literal"
+severity = "off"
+path = "src/solver.jl"

bin/jetls

@@ -0,0 +1,10 @@
+#!/bin/bash
+# SPDX-FileCopyrightText: 2025 Uwe Fechner
+# SPDX-License-Identifier: MIT
+
+cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")"
+if [[ $(basename $(pwd)) == "bin" ]]; then
+    cd ..
+fi
+
+jetls check --root=. src/

src/VortexStepMethod.jl

@@ -10,40 +10,38 @@ using DefaultApplication
 using Measures
 using LaTeXStrings
 using NonlinearSolve
-import NonlinearSolve: solve!, solve
+import NonlinearSolve: solve, solve!
 using Interpolations
-import Interpolations: Extrapolation
 using Parameters
 using Serialization
 using Timers
 using PreallocationTools
 using PrecompileTools
 using Pkg
 using DifferentiationInterface
-import SciMLBase: successful_retcode
 import YAML
 using StructMapping
 using Xfoil
 
 # Export public interface
-export VSMSettings, WingSettings, SolverSettings
-export Wing, Section, ObjWing, reinit!, refine!
+export SolverSettings, VSMSettings, WingSettings
+export ObjWing, Section, Wing, refine!, reinit!
 export BodyAerodynamics
-export Solver, solve, solve_base!, solve!, VSMSolution, linearize
+export Solver, VSMSolution, linearize, solve, solve!, solve_base!
 export calculate_results
 export add_section!, set_va!
-export calculate_span, calculate_projected_area
+export calculate_projected_area, calculate_span
 export MVec3
-export Model, VSM, LLT
-export AeroModel, LEI_AIRFOIL_BREUKELS, POLAR_VECTORS, POLAR_MATRICES, INVISCID
-export PanelDistribution, LINEAR, COSINE, SPLIT_PROVIDED, UNCHANGED
-export InitialGammaDistribution, ELLIPTIC, ZEROS
-export SolverStatus, FEASIBLE, INFEASIBLE, FAILURE
-export SolverType, LOOP, NONLIN
+export LLT, Model, VSM
+export AeroModel, INVISCID, LEI_AIRFOIL_BREUKELS, POLAR_MATRICES, POLAR_VECTORS
+export COSINE, LINEAR, PanelDistribution, SPLIT_PROVIDED, UNCHANGED
+export ELLIPTIC, InitialGammaDistribution, ZEROS
+export FAILURE, FEASIBLE, INFEASIBLE, SolverStatus
+export LOOP, NONLIN, SolverType
 export load_polar_data
 
-export plot_geometry, plot_distribution, plot_circulation_distribution, plot_polars,
-        save_plot, show_plot, plot_polar_data, plot_combined_analysis
+export plot_circulation_distribution, plot_combined_analysis, plot_distribution, plot_geometry,
+    plot_polar_data, plot_polars, save_plot, show_plot
 
 # the following functions are defined in ext/VortexStepMethodExt.jl
 function plot_geometry end
@@ -61,7 +59,7 @@ function plot_combined_analysis end
 Basic 3-dimensional vector, stack allocated, mutable.
 """
 const MVec3    = MVector{3, Float64}
-const MMat3    = MMatrix{3, 3, Float64}
+const MMat3    = MMatrix{3, 3, Float64, 9}
 
 """
    const PosVector=Union{MVec3, Vector}
@@ -202,9 +200,11 @@ const AeroData = Union{
         Tuple{Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, Matrix{Float64}}
     }
 
+const PACKAGE_ROOT = normpath(joinpath(@__DIR__, ".."))
+
 function menu()
    # Load the examples menu using a portable path
-   ex = joinpath(dirname(pathof(@__MODULE__)), "..", "examples", "menu.jl")
+    ex = joinpath(PACKAGE_ROOT, "examples", "menu.jl")
    Base.include(Main, normpath(ex))
 end
 
@@ -219,13 +219,13 @@ function copy_examples()
     if ! isdir(PATH)
         mkdir(PATH)
     end
-    src_path = joinpath(dirname(pathof(@__MODULE__)), "..", PATH)
+    src_path = joinpath(PACKAGE_ROOT, PATH)
     copy_files(PATH, readdir(src_path))
 end
 
 function install_examples(add_packages=true)
     copy_examples()
-    pkg_root = joinpath(dirname(pathof(@__MODULE__)), "..")
+    pkg_root = PACKAGE_ROOT
     src = joinpath(pkg_root, "data")
     isdir(src) && cp(src, "data"; force=true)
     if add_packages
@@ -241,7 +241,7 @@ function copy_files(relpath, files)
     if ! isdir(relpath) 
         mkdir(relpath)
     end
-    src_path = joinpath(dirname(pathof(@__MODULE__)), "..", relpath)
+    src_path = joinpath(PACKAGE_ROOT, relpath)
     for file in files
         cp(joinpath(src_path, file), joinpath(relpath, file), force=true)
         chmod(joinpath(relpath, file), 0o774)
@@ -254,7 +254,7 @@ function help(url)
         io = IOBuffer()
         run(pipeline(`xdg-open $url`, stderr = io))
         # ignore any error messages
-        out_data = String(take!(io)) 
+        _ = take!(io)
     else
         DefaultApplication.open(url)
     end

src/body_aerodynamics.jl

@@ -22,9 +22,9 @@ Main structure for calculating aerodynamic properties of bodies. Use the constru
 - `y::MVector{P, Float64}` = MVector{P,Float64}(zeros(P))
 - `cache::Vector{PreallocationTools.LazyBufferCache{typeof(identity), typeof(identity)}}` = [LazyBufferCache() for _ in 1:15]
 """
-@with_kw mutable struct BodyAerodynamics{P}
+@with_kw mutable struct BodyAerodynamics{P,W<:AbstractWing}
     panels::Vector{Panel}
-    wings::Vector{Wing}
+    wings::Vector{W}
     _va::MVec3 = zeros(MVec3)
     has_distributed_va::Bool = false
     omega::MVec3 = zeros(MVec3)
@@ -110,7 +110,7 @@ function BodyAerodynamics(
         end
     end
 
-    body_aero = BodyAerodynamics{length(panels)}(; panels, wings)
+    body_aero = BodyAerodynamics{length(panels),T}(; panels, wings)
     reinit!(body_aero; va, omega)
     return body_aero
 end
@@ -159,6 +159,67 @@ end
     return true
 end
 
+"""
+    calculate_stall_angle_list(panels::Vector{Panel};
+                             begin_aoa=9.0,
+                             end_aoa=22.0,
+                             step_aoa=1.0,
+                             stall_angle_if_none_detected=50.0,
+                             cl_initial=-10.0)
+
+Calculate stall angles for each panel.
+
+Returns:
+    Vector{Float64}: Stall angles in radians
+"""
+function calculate_stall_angle_list(panels::Vector{Panel};
+                                  begin_aoa=9.0,
+                                  end_aoa=22.0,
+                                  step_aoa=1.0,
+                                  stall_angle_if_none_detected=50.0,
+                                  cl_initial=-10.0)
+    stall_angles = Vector{Float64}(undef, length(panels))
+    calculate_stall_angle_list!(stall_angles, panels;
+                                begin_aoa, end_aoa, step_aoa,
+                                stall_angle_if_none_detected, cl_initial)
+    return stall_angles
+end
+
+function calculate_stall_angle_list!(stall_angles::AbstractVector{Float64},
+                                     panels::Vector{Panel};
+                                     begin_aoa=9.0,
+                                     end_aoa=22.0,
+                                     step_aoa=1.0,
+                                     stall_angle_if_none_detected=50.0,
+                                     cl_initial=-10.0)
+
+    # Pre-compute range values to avoid allocation
+    n_steps = Int(floor((end_aoa - begin_aoa) / step_aoa)) + 1
+
+    for (idx, panel) in enumerate(panels)
+        # Default stall angle if none found
+        panel_stall = stall_angle_if_none_detected
+
+        # Start with minimum cl
+        cl_old = cl_initial
+
+        # Find stall angle
+        for i in 0:(n_steps-1)
+            aoa = deg2rad(begin_aoa + i * step_aoa)
+            cl = calculate_cl(panel, aoa)
+            if cl < cl_old
+                panel_stall = aoa
+                break
+            end
+            cl_old = cl
+        end
+
+        stall_angles[idx] = panel_stall
+    end
+
+    return nothing
+end
+
 """
     reinit!(body_aero::BodyAerodynamics; init_aero, va, omega, refine_mesh, recompute_mapping, sort_sections)
 
@@ -381,67 +442,6 @@ function calculate_circulation_distribution_elliptical_wing(gamma_i, body_aero::
     nothing
 end
 
-"""
-    calculate_stall_angle_list(panels::Vector{Panel};
-                             begin_aoa=9.0,
-                             end_aoa=22.0,
-                             step_aoa=1.0,
-                             stall_angle_if_none_detected=50.0,
-                             cl_initial=-10.0)
-
-Calculate stall angles for each panel.
-
-Returns:
-    Vector{Float64}: Stall angles in radians
-"""
-function calculate_stall_angle_list(panels::Vector{Panel};
-                                  begin_aoa=9.0,
-                                  end_aoa=22.0,
-                                  step_aoa=1.0,
-                                  stall_angle_if_none_detected=50.0,
-                                  cl_initial=-10.0)
-    stall_angles = Vector{Float64}(undef, length(panels))
-    calculate_stall_angle_list!(stall_angles, panels;
-                                begin_aoa, end_aoa, step_aoa,
-                                stall_angle_if_none_detected, cl_initial)
-    return stall_angles
-end
-
-function calculate_stall_angle_list!(stall_angles::AbstractVector{Float64},
-                                     panels::Vector{Panel};
-                                     begin_aoa=9.0,
-                                     end_aoa=22.0,
-                                     step_aoa=1.0,
-                                     stall_angle_if_none_detected=50.0,
-                                     cl_initial=-10.0)
-
-    # Pre-compute range values to avoid allocation
-    n_steps = Int(floor((end_aoa - begin_aoa) / step_aoa)) + 1
-
-    for (idx, panel) in enumerate(panels)
-        # Default stall angle if none found
-        panel_stall = stall_angle_if_none_detected
-
-        # Start with minimum cl
-        cl_old = cl_initial
-
-        # Find stall angle
-        for i in 0:(n_steps-1)
-            aoa = deg2rad(begin_aoa + i * step_aoa)
-            cl = calculate_cl(panel, aoa)
-            if cl < cl_old
-                panel_stall = aoa
-                break
-            end
-            cl_old = cl
-        end
-
-        stall_angles[idx] = panel_stall
-    end
-
-    return nothing
-end
-
 """
     update_effective_angle_of_attack_if_VSM(body_aero::BodyAerodynamics, gamma,
                                           core_radius_fraction,
@@ -694,11 +694,11 @@ end
 
 """
     calculate_results(body_aero::BodyAerodynamics, gamma_new, 
-                     density, aerodynamic_model_type::Model,
+                     density,
                      core_radius_fraction, mu,
                      alpha_dist, v_a_dist,
                      chord_array, x_airf_array,
-                     y_airf_array, z_airf_array,
+                     z_airf_array,
                      va_array, va_norm_array,
                      va_unit_array, panels::Vector{Panel},
                      is_only_f_and_gamma_output::Bool)
@@ -713,14 +713,12 @@ function calculate_results(
     gamma_new,
     reference_point,
     density,
-    aerodynamic_model_type::Model,
     core_radius_fraction,
     mu,
     alpha_dist,
     v_a_dist,
     chord_array,
     x_airf_array,
-    y_airf_array,
     z_airf_array,
     va_array,
     va_norm_array,
@@ -1041,23 +1039,23 @@ Set velocity array and update wake filaments.
 - `omega::VelVector`: Turn rate vector around x y and z axis            [rad/s]
 """
 function set_va!(body_aero::BodyAerodynamics, va::AbstractVector, omega=zeros(MVec3))
-    # Calculate va_distribution based on input type
-    va_distribution = if all(omega .== 0.0)
-        repeat(reshape(va, 1, 3), length(body_aero.panels))
-    elseif !all(omega .== 0.0)
-        va_dist = zeros(length(body_aero.panels), 3)
-
+    n_panels = length(body_aero.panels)
+    va_distribution = zeros(n_panels, 3)
+
+    if all(iszero, omega)
+        va_distribution .= repeat(reshape(va, 1, 3), n_panels)
+    else
+        idx = 1
         for wing in body_aero.wings
-            # Get spanwise positions
-            spanwise_positions = [panel.control_point for panel in body_aero.panels]
-
-            # Calculate velocities for each panel
-            for i in 1:wing.n_panels
-                omega_va = -omega × spanwise_positions[i]
-                va_dist[i, :] .= omega_va .+ va
+            panel_end = idx + wing.n_panels - 1
+
+            # Calculate velocities for each panel in this wing slice
+            for j in idx:panel_end
+                omega_va = -omega × body_aero.panels[j].control_point
+                va_distribution[j, :] .= omega_va .+ va
             end
+            idx = panel_end + 1
         end
-        va_dist
     end
 
     # Update panel velocities
@@ -1067,12 +1065,18 @@ function set_va!(body_aero::BodyAerodynamics, va::AbstractVector, omega=zeros(MV
 
     # Update wake elements
     frozen_wake!(body_aero, va_distribution)
-    body_aero._va .= va
-    body_aero.has_distributed_va = false
+    if all(iszero, omega)
+        body_aero._va .= va
+        body_aero.has_distributed_va = false
+    else
+        body_aero._va .= _compute_reference_velocity_from_distribution(
+            va_distribution, n_panels)
+        body_aero.has_distributed_va = true
+    end
     return nothing
 end
 
-function set_va!(body_aero::BodyAerodynamics, va_distribution::AbstractMatrix, omega=zeros(MVec3))
+function set_va!(body_aero::BodyAerodynamics, va_distribution::AbstractMatrix)
     size(va_distribution, 1) != length(body_aero.panels) &&
         throw(ArgumentError("Number of rows in va distribution should be equal to number of panels."))