#155 #185 added StructMapping for yaml parsing

Author: jellepoland

Project.toml

@@ -23,6 +23,7 @@ SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+StructMapping = "7c3b921d-20d6-4eba-ad57-605525e86ab2"
 Timers = "21f18d07-b854-4dab-86f0-c15a3821819a"
 Xfoil = "19641d66-a62d-11e8-2441-8f57a969a9c4"
 YAML = "ddb6d928-2868-570f-bddf-ab3f9cf99eb6"
@@ -59,6 +60,7 @@ SciMLBase = "2.77.0"
 Serialization = "1"
 StaticArrays = "1"
 Statistics = "1"
+StructMapping = "0.2.3"
 Test = "1"
 Timers = "0.1"
 Xfoil = "0.5"
@@ -75,4 +77,4 @@ Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "DataFrames", "CSV", "Documenter", "BenchmarkTools", "ControlPlots", "Aqua"]
+test = ["Test", "DataFrames", "CSV", "Documenter", "BenchmarkTools", "ControlPlots", "Aqua"]

src/VortexStepMethod.jl

@@ -12,7 +12,7 @@ using LaTeXStrings
 using NonlinearSolve
 import NonlinearSolve: solve!, solve
 using Interpolations
-using Interpolations: Extrapolation
+import Interpolations: Extrapolation
 using Parameters
 using Serialization
 using Timers
@@ -22,6 +22,7 @@ using Pkg
 using DifferentiationInterface
 import SciMLBase: successful_retcode
 import YAML
+using StructMapping
 using Xfoil
 
 # Export public interface
@@ -40,13 +41,12 @@ export InitialGammaDistribution, ELLIPTIC, ZEROS
 export SolverStatus, FEASIBLE, INFEASIBLE, FAILURE
 export SolverType, LOOP, NONLIN
 
-export plot_geometry, plot_distribution, plot_circulation_distribution, plot_geometry, plot_polars, save_plot, show_plot, plot_polar_data
+export plot_geometry, plot_distribution, plot_circulation_distribution, plot_polars, save_plot, show_plot, plot_polar_data
 
 # the following functions are defined in ext/VortexStepMethodExt.jl
 function plot_geometry end
 function plot_distribution end
 function plot_circulation_distribution end
-function plot_geometry end
 function plot_polars end
 function save_plot end
 function show_plot end

src/settings.jl

@@ -41,56 +41,63 @@ end
 end
 
 function vs(filename)
-    res = VSMSettings()
+    # Uwe's suggested 3-line approach using StructMapping.jl (adapted)
     data = YAML.load_file(joinpath("data", filename))
-    n_panels = 0
-    n_groups = 0
 
-    # Load condition settings if present
+    # Use StructMapping for basic structure conversion
+    # But handle special fields manually due to enum conversion needs
+    vsm_settings = VSMSettings()
+    
+    # Convert condition settings using StructMapping
     if haskey(data, "condition")
-        condition = data["condition"]
-        res.condition.wind_speed = condition["wind_speed"]
-        res.condition.alpha = condition["alpha"]
-        res.condition.beta = condition["beta"]
-        res.condition.yaw_rate = condition["yaw_rate"]
+        vsm_settings.condition = convertdict(ConditionSettings, data["condition"])
     end
 
-    # add and update wing settings
-    for (i, wing) in pairs(data["wings"])
-        push!(res.wings, WingSettings())
-        res.wings[i].name = wing["name"]
-        if haskey(wing, "geometry_file")
-            res.wings[i].geometry_file = wing["geometry_file"]
+    # Convert wing settings manually due to enum conversions
+    n_panels = 0
+    n_groups = 0
+    
+    if haskey(data, "wings")
+        for wing_data in data["wings"]
+            wing = WingSettings()
+            wing.name = wing_data["name"]
+            if haskey(wing_data, "geometry_file")
+                wing.geometry_file = wing_data["geometry_file"]
+            end
+            wing.n_panels = wing_data["n_panels"]
+            wing.n_groups = wing_data["n_groups"]
+            wing.spanwise_panel_distribution = eval(Symbol(wing_data["spanwise_panel_distribution"]))
+            wing.spanwise_direction = MVec3(wing_data["spanwise_direction"])
+            wing.remove_nan = wing_data["remove_nan"]
+            
+            push!(vsm_settings.wings, wing)
+            n_panels += wing.n_panels
+            n_groups += wing.n_groups
         end
-        res.wings[i].n_panels = wing["n_panels"]
-        n_panels += res.wings[i].n_panels
-        res.wings[i].n_groups = wing["n_groups"]
-        n_groups += res.wings[i].n_groups
-        res.wings[i].spanwise_panel_distribution = eval(Symbol(wing["spanwise_panel_distribution"]))
-        res.wings[i].spanwise_direction = MVec3(wing["spanwise_direction"])
-        res.wings[i].remove_nan = wing["remove_nan"]
     end
-    # update solver settings
-    solver = data["solver_settings"]
-    res.solver_settings.n_panels = n_panels
-    res.solver_settings.n_groups = n_groups
-    res.solver_settings.aerodynamic_model_type = eval(Symbol(solver["aerodynamic_model_type"]))
-    if haskey(solver, "solver_type")
-        res.solver_settings.solver_type = solver["solver_type"]
+    
+    # Convert solver settings using StructMapping base, then override special fields
+    if haskey(data, "solver_settings")
+        solver_data = data["solver_settings"]
+        
+        # Create a copy of solver_data with string fields for enums removed
+        solver_data_clean = copy(solver_data)
+        delete!(solver_data_clean, "aerodynamic_model_type")
+        delete!(solver_data_clean, "type_initial_gamma_distribution")
+        
+        # Use StructMapping for the basic fields
+        vsm_settings.solver_settings = convertdict(SolverSettings, solver_data_clean)
+        
+        # Handle enum conversions manually
+        vsm_settings.solver_settings.aerodynamic_model_type = eval(Symbol(solver_data["aerodynamic_model_type"]))
+        vsm_settings.solver_settings.type_initial_gamma_distribution = eval(Symbol(solver_data["type_initial_gamma_distribution"]))
+        
+        # Override with calculated totals
+        vsm_settings.solver_settings.n_panels = n_panels
+        vsm_settings.solver_settings.n_groups = n_groups
     end
-    res.solver_settings.density = solver["density"]
-    res.solver_settings.max_iterations = solver["max_iterations"]
-    res.solver_settings.rtol = solver["rtol"]
-    res.solver_settings.tol_reference_error = solver["tol_reference_error"]
-    res.solver_settings.relaxation_factor = solver["relaxation_factor"]
-    res.solver_settings.artificial_damping = solver["artificial_damping"]
-    res.solver_settings.k2 = solver["k2"]
-    res.solver_settings.k4 = solver["k4"]
-    res.solver_settings.type_initial_gamma_distribution = eval(Symbol(solver["type_initial_gamma_distribution"]))
-    res.solver_settings.core_radius_fraction = solver["core_radius_fraction"]
-    res.solver_settings.mu = solver["mu"]
-    res.solver_settings.calc_only_f_and_gamma = solver["calc_only_f_and_gamma"]
-    res
+    
+    return vsm_settings
 end
 
 function Base.show(io::IO, vs::VSMSettings)

src/yaml_geometry.jl

@@ -12,6 +12,45 @@ Expected format: header row and columns alpha, cl, cd, cm (case-insensitive, ord
 
 Returns (aero_data, POLAR_VECTORS) or (nothing, INVISCID) if missing/invalid.
 """
+
+# Structs for YAML parsing using StructMapping.jl
+@kwdef struct WingAirfoilInfo
+    csv_file_path::String = ""
+end
+
+@kwdef struct WingAirfoilData
+    airfoil_id::Int64
+    type::String
+    info_dict::WingAirfoilInfo
+end
+
+@kwdef struct WingAirfoils
+    alpha_range::Vector{Float64}
+    reynolds::Float64
+    headers::Vector{String}
+    data::Vector{WingAirfoilData}
+end
+
+@kwdef struct WingSectionData
+    airfoil_id::Int64
+    LE_x::Float64
+    LE_y::Float64
+    LE_z::Float64
+    TE_x::Float64
+    TE_y::Float64
+    TE_z::Float64
+end
+
+@kwdef struct WingSections
+    headers::Vector{String}
+    data::Vector{WingSectionData}
+end
+
+@kwdef struct WingGeometry
+    wing_sections::WingSections
+    wing_airfoils::WingAirfoils
+end
+
 function load_polar_data(csv_file_path::String)
     if isempty(csv_file_path) || !isfile(csv_file_path)
         @warn "Polar file not found or empty path: $csv_file_path. Using INVISCID model instead."
@@ -126,17 +165,44 @@ function YamlWing(
 
     prn && @info "Reading YAML wing configuration from $geometry_file"
 
-    # Read and parse YAML file
-    yaml_data = YAML.load_file(geometry_file)
+    # Load YAML file following Uwe's suggestion
+    data = YAML.load_file(geometry_file)
 
-    # Parse airfoils and create CSV file mapping
-    airfoil_csv_map = Dict{Int64, String}()
+    # Convert YAML data to our struct format
+    # Convert wing sections
+    wing_sections_data = data["wing_sections"]
+    sections = WingSectionData[]
+    for row in wing_sections_data["data"]
+        section_dict = Dict(zip(wing_sections_data["headers"], row))
+        push!(sections, WingSectionData(
+            airfoil_id = section_dict["airfoil_id"],
+            LE_x = section_dict["LE_x"],
+            LE_y = section_dict["LE_y"], 
+            LE_z = section_dict["LE_z"],
+            TE_x = section_dict["TE_x"],
+            TE_y = section_dict["TE_y"],
+            TE_z = section_dict["TE_z"]
+        ))
+    end
 
-    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"]
-        
-        haskey(info_dict, "csv_file_path") && (airfoil_csv_map[airfoil_id] = info_dict["csv_file_path"])
+    # Convert wing airfoils
+    wing_airfoils_data = data["wing_airfoils"]
+    airfoils = WingAirfoilData[]
+    for row in wing_airfoils_data["data"]
+        airfoil_dict = Dict(zip(wing_airfoils_data["headers"], row))
+        push!(airfoils, WingAirfoilData(
+            airfoil_id = airfoil_dict["airfoil_id"],
+            type = airfoil_dict["type"],
+            info_dict = WingAirfoilInfo(csv_file_path = get(airfoil_dict["info_dict"], "csv_file_path", ""))
+        ))
+    end
+    
+    # Create CSV file mapping from airfoils
+    airfoil_csv_map = Dict{Int64, String}()
+    for airfoil in airfoils
+        if !isempty(airfoil.info_dict.csv_file_path)
+            airfoil_csv_map[airfoil.airfoil_id] = airfoil.info_dict.csv_file_path
+        end
     end
 
     # Create Wing using the standard constructor
@@ -148,23 +214,20 @@ function YamlWing(
     )
 
     # 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"]
-        
-        # Get coordinates
-        le_coord = [section_dict["LE_x"], section_dict["LE_y"], section_dict["LE_z"]]
-        te_coord = [section_dict["TE_x"], section_dict["TE_y"], section_dict["TE_z"]]
+    for section in sections
+        # Get coordinates directly from struct fields
+        le_coord = [section.LE_x, section.LE_y, section.LE_z]
+        te_coord = [section.TE_x, section.TE_y, section.TE_z]
 
         # Load polar data and create section
-        csv_file_path = get(airfoil_csv_map, airfoil_id, "")
+        csv_file_path = get(airfoil_csv_map, section.airfoil_id, "")
         if !isempty(csv_file_path) && !isabspath(csv_file_path)
             # Make relative paths relative to YAML file directory
             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")
+        prn && println("Section airfoil_id $(section.airfoil_id): Using $aero_model model")
 
         add_section!(wing, le_coord, te_coord, aero_model, aero_data)
     end