#155 working, with Wing constructor

Author: jellepoland

data/TUDELFT_V3_KITE/vsm_settings.yaml

@@ -33,35 +33,24 @@
 # - n_panels should be divisible by n_groups for proper load balancing
 # - Higher n_panels improves accuracy but increases computation time
 # - Lower relaxation_factor if convergence issues occur
-#
-# =============================================================================
 
-# =============================================================================
-# FLIGHT CONDITIONS
-# =============================================================================
 # Define the flight state for the aerodynamic analysis
 condition:
     wind_speed: 10.0     # [m/s] Free stream velocity magnitude
     alpha: 5.0           # [°] Angle of attack (pitch angle relative to flow)
     beta: 0.0            # [°] Sideslip angle (yaw angle relative to flow)
     yaw_rate: 0.0        # [°/s] Yaw rate (for dynamic analysis, 0 for static)
 
-# =============================================================================
-# WING CONFIGURATION
-# =============================================================================
 # Define wing geometry files and discretization parameters
 wings:
-  - name: V3_Kite                    # Wing identifier for output labeling
-    yaml_path: data/TUDELFT_V3_KITE/wing_geometry_CAD_CFD_polars_pchip_fitted.yaml
-    n_panels: 36                     # Total number of panels along wingspan
-    n_groups: 1                      # Number of panel groups (must divide n_panels)
-    spanwise_panel_distribution: LINEAR    # Panel spacing algorithm
-    spanwise_direction: [0.0, 1.0, 0.0]   # Unit vector defining wingspan direction
-    remove_nan: true                 # Remove NaN values from polar data
+    - name: V3_Kite                    # Wing identifier for output labeling
+      geometry_file: data/TUDELFT_V3_KITE/wing_geometry_CAD_CFD_polars_pchip_fitted.yaml
+      n_panels: 36                     # Total number of panels along wingspan
+      n_groups: 1                      # Number of panel groups (must divide n_panels)
+      spanwise_panel_distribution: LINEAR    # Panel spacing algorithm
+      spanwise_direction: [0.0, 1.0, 0.0]   # Unit vector defining wingspan direction
+      remove_nan: true                 # Remove NaN values from polar data
 
-# =============================================================================
-# SOLVER CONFIGURATION
-# =============================================================================
 # Numerical method settings and convergence criteria
 solver_settings:
     # --- Core Aerodynamic Model ---

examples/V3_kite.jl

@@ -31,7 +31,7 @@ labels= [
 settings = vs("TUDELFT_V3_KITE/vsm_settings.yaml")
 
 # Create wing, body_aero, and solver objects using settings
-wing = YamlWing(settings.wings[1].yaml_path; 
+wing = YamlWing(settings.wings[1].geometry_file; 
     n_panels=settings.wings[1].n_panels, 
     n_groups=settings.wings[1].n_groups,
     spanwise_distribution=settings.wings[1].spanwise_panel_distribution

src/body_aerodynamics.jl

@@ -18,24 +18,24 @@ Main structure for calculating aerodynamic properties of bodies. Use the constru
 - `work_vectors`::NTuple{10, MVec3} = ntuple(_ -> zeros(MVec3), 10)
 - `AIC::Array{Float64, 3}` = zeros(3, P, P)
 - `projected_area::Float64` = 1.0: The area projected onto the xy-plane of the kite body reference frame [m²]
-- `y::MVector{P, Float64}` = zeros(MVector{P, Float64})
+- `y::MVector{P, Float64}` = MVector{P,Float64}(zeros(P))
 - `cache::Vector{PreallocationTools.LazyBufferCache{typeof(identity), typeof(identity)}}` = [LazyBufferCache() for _ in 1:5]
 """
 @with_kw mutable struct BodyAerodynamics{P}
     panels::Vector{Panel}
-    wings::Union{Vector{Wing}, Vector{RamAirWing}, Vector{YamlWing}}
+    wings::Union{Vector{Wing}, Vector{RamAirWing}}
     _va::MVec3 = zeros(MVec3)
     omega::MVec3 = zeros(MVec3)
-    gamma_distribution::MVector{P, Float64} = zeros(MVector{P, Float64})
-    alpha_uncorrected::MVector{P, Float64} = zeros(MVector{P, Float64})
-    alpha_corrected::MVector{P, Float64} = zeros(MVector{P, Float64})
-    stall_angle_list::MVector{P, Float64} = zeros(MVector{P, Float64})
-    alpha_array::MVector{P, Float64} = zeros(MVector{P, Float64})
-    v_a_array::MVector{P, Float64} = zeros(MVector{P, Float64})
+    gamma_distribution::MVector{P, Float64} = zeros(P)
+    alpha_uncorrected::MVector{P, Float64} = zeros(P)
+    alpha_corrected::MVector{P, Float64} = zeros(P)
+    stall_angle_list::MVector{P, Float64} = zeros(P)
+    alpha_array::MVector{P, Float64} = zeros(P)
+    v_a_array::MVector{P, Float64} = zeros(P)
     work_vectors::NTuple{10,MVec3} = ntuple(_ -> zeros(MVec3), 10)
     AIC::Array{Float64, 3} = zeros(3, P, P)
     projected_area::Float64 = one(Float64)
-    y::MVector{P, Float64} = zeros(MVector{P, Float64})
+    y::MVector{P, Float64} = zeros(P)
     cache::Vector{PreallocationTools.LazyBufferCache{typeof(identity), typeof(identity)}} = [LazyBufferCache() for _ in 1:5]
 end
 

src/precompile.jl

@@ -1,21 +1,16 @@
 @setup_workload begin
     # Putting some things in `@setup_workload` instead of `@compile_workload` can reduce the size of the
     # precompile file and potentially make loading faster.
-    # list = [OtherType("hello"), OtherType("world!")]
-    path = dirname(pathof(@__MODULE__))
-
+    
     @compile_workload begin
+        # Minimal precompilation to avoid segfault
         # all calls in this block will be precompiled, regardless of whether
         # they belong to your package or not (on Julia 1.8 and higher)
-        vss = vs(joinpath(path, "../data/vsm_settings_dual.yaml"))
+        
         # Step 1: Define wing parameters
-        n_panels = 20          # Number of panels
-        span = 20.0            # Wing span [m]
+        n_panels = 2           # Reduced number of panels for faster precompilation
+        span = 10.0            # Wing span [m]
         chord = 1.0            # Chord length [m]
-        v_a = 20.0             # Magnitude of inflow velocity [m/s]
-        density = 1.225        # Air density [kg/m³]
-        alpha_deg = 30.0       # Angle of attack [degrees]
-        alpha = deg2rad(alpha_deg)
 
         # Step 2: Create wing geometry with linear panel distribution
         wing = Wing(n_panels, spanwise_distribution=LINEAR)
@@ -30,11 +25,8 @@
             [chord, -span/2, 0.0], # Right tip TE
             INVISCID)
 
-        # Step 3: Initialize aerodynamics
-        body_aero::BodyAerodynamics = BodyAerodynamics([wing])
-
-        gamma_initial = zeros(length(body_aero.panels))
-        calculate_circulation_distribution_elliptical_wing(gamma_initial, body_aero)
+        # Step 3: Initialize aerodynamics (simplified)
+        body_aero = BodyAerodynamics([wing])
 
         nothing
     end

src/settings.jl

@@ -7,7 +7,7 @@ end
 
 @with_kw mutable struct WingSettings
     name::String = "main_wing"
-    yaml_path::String = ""          # path to wing geometry YAML file
+    geometry_file::String = ""          # path to wing geometry YAML file
     n_panels::Int64 = 40
     n_groups::Int64 = 40 
     spanwise_panel_distribution::PanelDistribution = LINEAR
@@ -59,8 +59,8 @@ function vs(filename)
     for (i, wing) in pairs(data["wings"])
         push!(res.wings, WingSettings())
         res.wings[i].name = wing["name"]
-        if haskey(wing, "yaml_path")
-            res.wings[i].yaml_path = wing["yaml_path"]
+        if haskey(wing, "geometry_file")
+            res.wings[i].geometry_file = wing["geometry_file"]
         end
         res.wings[i].n_panels = wing["n_panels"]
         n_panels += res.wings[i].n_panels

src/solver.jl

@@ -47,23 +47,23 @@ Struct for storing the solution of the [solve!](@ref) function. Must contain all
     moment::MVec3 = zeros(MVec3)       
     force_coeffs::MVec3 = zeros(MVec3)  
     moment_coeffs::MVec3 = zeros(MVec3)  
-    moment_dist::MVector{P, Float64} = zeros(MVector{P, Float64})
-    moment_coeff_dist::MVector{P, Float64} = zeros(MVector{P, Float64})
-    group_moment_dist::MVector{G, Float64} = zeros(MVector{G, Float64})
-    group_moment_coeff_dist::MVector{G, Float64} = zeros(MVector{G, Float64})
+    moment_dist::MVector{P, Float64} = zeros(P)
+    moment_coeff_dist::MVector{P, Float64} = zeros(P)
+    group_moment_dist::MVector{G, Float64} = zeros(G)
+    group_moment_coeff_dist::MVector{G, Float64} = zeros(G)
     solver_status::SolverStatus = FAILURE
 end
 
 # Output of the function gamma_loop!
 @with_kw mutable struct LoopResult{P}
     converged::Bool              = false
-    gamma_new::MVector{P, Float64}   = zeros(MVector{P, Float64})
-    alpha_array::MVector{P, Float64} = zeros(MVector{P, Float64}) # TODO: Is this different from BodyAerodynamics.alpha_array ?
-    v_a_array::MVector{P, Float64}   = zeros(MVector{P, Float64})
+    gamma_new::MVector{P, Float64}   = zeros(P)
+    alpha_array::MVector{P, Float64} = zeros(P) # TODO: Is this different from BodyAerodynamics.alpha_array ?
+    v_a_array::MVector{P, Float64}   = zeros(P)
 end
 
 @with_kw struct BaseResult{P}
-    va_norm_array::MVector{P, Float64} = zeros(MVector{P, Float64})
+    va_norm_array::MVector{P, Float64} = zeros(P)
     va_unit_array::Matrix{Float64} = zeros(P, 3)
 end
 

src/yaml_geometry.jl

@@ -1,67 +1,4 @@
-"""
-    @with_kw mutable struct AirfoilSettings
-
-Configuration settings for airfoils loaded from YAML files.
-
-This struct stores the mapping between airfoil IDs and their aerodynamic data sources,
-typically CSV files containing polar data. It preserves the original YAML configuration
-for reference and enables reconstruction of the wing geometry from YAML specifications.
-
-# Fields
-- `airfoil_id::Int64`: Unique identifier for the airfoil section
-- `type::String`: Type of aerodynamic data (e.g., "polars", "inviscid")  
-- `info_dict::Dict{String, Any}`: Additional configuration data, typically containing
-  file paths to CSV polar data files and other airfoil-specific parameters
-
-# Example
-```julia
-# Typical usage when parsing YAML wing configuration
-settings = AirfoilSettings(
-    airfoil_id = 1,
-    type = "polars", 
-    info_dict = Dict("csv_file_path" => "polars/airfoil_1.csv")
-)
-```
-"""
-@with_kw mutable struct AirfoilSettings
-    airfoil_id::Int64
-    type::String
-    info_dict::Dict{String, Any}
-end
 
-"""
-    YamlWing <: AbstractWing
-
-A wing model created from YAML configuration files with CSV polar data.
-
-## Core Features
-- Wing geometry defined through YAML section coordinates
-- Aerodynamic properties based on CSV polar data files
-- Support for multiple airfoil types per wing
-- Configurable panel distribution and geometry parameters
-
-## Notable Fields
-- `n_panels::Int16`: Number of panels in aerodynamic mesh
-- `n_groups::Int16`: Number of control groups
-- `spanwise_distribution::PanelDistribution`: Panel distribution type
-- `sections::Vector{Section}`: Wing cross-sections with aerodynamic data
-- `airfoil_settings::Vector{AirfoilSettings}`: Airfoil configuration data
-
-See constructor `YamlWing(yaml_path; kwargs...)` for usage details.
-"""
-mutable struct YamlWing <: AbstractWing
-    n_panels::Int16
-    n_groups::Int16
-    spanwise_distribution::PanelDistribution
-    panel_props::PanelProperties
-    spanwise_direction::MVec3
-    sections::Vector{Section}
-    refined_sections::Vector{Section}
-    remove_nan::Bool
-    
-    # Essential YAML-specific fields
-    airfoil_settings::Vector{AirfoilSettings}
-end
 
 """
     load_polar_data(csv_file_path)
@@ -124,7 +61,7 @@ end
 
 
 """
-    YamlWing(yaml_path; kwargs...)
+    YamlWing(geometry_file; kwargs...)
 
 Create a wing model from YAML configuration file with CSV polar data.
 
@@ -135,7 +72,7 @@ This constructor builds a complete aerodynamic model by:
 4. Setting up panel distribution and geometric properties
 
 # Arguments
-- `yaml_path`: Path to YAML file containing wing geometry and airfoil specifications
+- `geometry_file`: Path to YAML file containing wing geometry and airfoil specifications
 
 # Keyword Arguments
 - `n_panels=20`: Number of aerodynamic panels across wingspan
@@ -146,7 +83,7 @@ This constructor builds a complete aerodynamic model by:
 - `prn=true`: Print info messages during construction
 
 # Returns
-A fully initialized `YamlWing` instance ready for aerodynamic simulation.
+A fully initialized `Wing` instance ready for aerodynamic simulation.
 
 # Example YAML format
 ```yaml
@@ -176,7 +113,7 @@ wing = YamlWing(
 ```
 """
 function YamlWing(
-    yaml_path;
+    geometry_file;
     n_panels=20,
     n_groups=1,
     spanwise_distribution=LINEAR,
@@ -187,27 +124,30 @@ function YamlWing(
     !(n_panels % n_groups == 0) && throw(ArgumentError("Number of panels should be divisible by number of groups"))
     !isapprox(spanwise_direction, [0.0, 1.0, 0.0]) && throw(ArgumentError("Spanwise direction has to be [0.0, 1.0, 0.0], not $spanwise_direction"))
 
-    prn && @info "Reading YAML wing configuration from $yaml_path"
+    prn && @info "Reading YAML wing configuration from $geometry_file"
 
     # Read and parse YAML file
-    yaml_data = YAML.load_file(yaml_path)
+    yaml_data = YAML.load_file(geometry_file)
 
     # Parse airfoils and create CSV file mapping
     airfoil_csv_map = Dict{Int64, String}()
-    airfoil_settings = AirfoilSettings[]
 
     for row in yaml_data["wing_airfoils"]["data"]
         airfoil_dict = Dict(zip(yaml_data["wing_airfoils"]["headers"], row))
         airfoil_id, airfoil_type, info_dict = airfoil_dict["airfoil_id"], airfoil_dict["type"], airfoil_dict["info_dict"]
 
-        push!(airfoil_settings, AirfoilSettings(airfoil_id, airfoil_type, info_dict))
         haskey(info_dict, "csv_file_path") && (airfoil_csv_map[airfoil_id] = info_dict["csv_file_path"])
     end
 
-    # Parse sections and create wing sections
-    sections = Section[]
-    refined_sections = Section[]
+    # Create Wing using the standard constructor
+    wing = Wing(n_panels; 
+        n_groups=n_groups, 
+        spanwise_distribution=spanwise_distribution,
+        spanwise_direction=MVec3(spanwise_direction), 
+        remove_nan=remove_nan
+    )
 
+    # Parse sections and populate wing
     for row in yaml_data["wing_sections"]["data"]
         section_dict = Dict(zip(yaml_data["wing_sections"]["headers"], row))
         airfoil_id = section_dict["airfoil_id"]
@@ -220,21 +160,17 @@ function YamlWing(
         csv_file_path = get(airfoil_csv_map, airfoil_id, "")
         if !isempty(csv_file_path) && !isabspath(csv_file_path)
             # Make relative paths relative to YAML file directory
-            csv_file_path = joinpath(dirname(yaml_path), csv_file_path)
+            csv_file_path = joinpath(dirname(geometry_file), csv_file_path)
         end
         aero_data, aero_model = load_polar_data(csv_file_path)
 
         prn && println("Section airfoil_id $airfoil_id: Using $aero_model model")
 
-        section = Section(le_coord, te_coord, aero_model, aero_data)
-        push!(sections, section)
-        push!(refined_sections, Section(le_coord, te_coord, aero_model, aero_data))
+        add_section!(wing, le_coord, te_coord, aero_model, aero_data)
     end
 
-    # Create YamlWing
-    YamlWing(
-        n_panels, n_groups, spanwise_distribution, PanelProperties{n_panels}(), 
-        MVec3(spanwise_direction), sections, refined_sections, remove_nan,
-        airfoil_settings
-    )
+    # Initialize the wing after adding all sections
+    reinit!(wing)
+    
+    return wing
 end