Manual refine

Author: 1-Bart-1

src/VortexStepMethod.jl

@@ -27,7 +27,7 @@ using Xfoil
 
 # Export public interface
 export VSMSettings, WingSettings, SolverSettings
-export Wing, Section, ObjWing, reinit!
+export Wing, Section, ObjWing, reinit!, refine!
 export BodyAerodynamics
 export Solver, solve, solve_base!, solve!, VSMSolution, linearize
 export calculate_results
@@ -36,7 +36,7 @@ export calculate_span, calculate_projected_area
 export MVec3
 export Model, VSM, LLT
 export AeroModel, LEI_AIRFOIL_BREUKELS, POLAR_VECTORS, POLAR_MATRICES, INVISCID
-export PanelDistribution, LINEAR, COSINE, COSINE_VAN_GARREL, SPLIT_PROVIDED, UNCHANGED, NONE
+export PanelDistribution, LINEAR, COSINE, COSINE_VAN_GARREL, SPLIT_PROVIDED, UNCHANGED
 export InitialGammaDistribution, ELLIPTIC, ZEROS
 export SolverStatus, FEASIBLE, INFEASIBLE, FAILURE
 export SolverType, LOOP, NONLIN
@@ -130,16 +130,14 @@ Enumeration of the implemented panel distributions.
 - COSINE               # Cosine distribution
 - `COSINE_VAN_GARREL`  # van Garrel cosine distribution
 - `SPLIT_PROVIDED`     # Split provided sections
-- `UNCHANGED`          # Keep original sections without interpolation
-- `NONE`               # No refinement - sections already refined
+- `UNCHANGED`          # 1:1 copy of unrefined to refined sections (no interpolation)
 """
 @enum PanelDistribution begin
    LINEAR             # Linear distribution
    COSINE             # Cosine distribution
    COSINE_VAN_GARREL  # van Garrel cosine distribution
    SPLIT_PROVIDED     # Split provided sections
-   UNCHANGED          # Keep original sections without interpolation
-   NONE               # No refinement - sections already refined
+   UNCHANGED          # 1:1 copy of unrefined to refined sections
 end
 
 """

src/body_aerodynamics.jl

@@ -71,6 +71,27 @@ function BodyAerodynamics(
     va=[15.0, 0.0, 0.0],
     omega=zeros(MVec3)
 ) where T <: AbstractWing
+    # Validate all wings are refined
+    for (i, wing) in enumerate(wings)
+        if isempty(wing.refined_sections) ||
+           length(wing.refined_sections) != wing.n_panels + 1
+            throw(ArgumentError(
+                "Wing $i has not been refined. " *
+                "Call refine!(wing) before creating BodyAerodynamics.\n\n" *
+                "Expected workflow:\n" *
+                "  wing = Wing(...)\n" *
+                "  refine!(wing)\n" *
+                "  body_aero = BodyAerodynamics([wing])"
+            ))
+        end
+
+        if isempty(wing.non_deformed_sections)
+            @warn "Wing $i has no non_deformed_sections. " *
+                  "Deformation (unrefined_deform!) will not work. " *
+                  "This should have been created by refine!." maxlog=1
+        end
+    end
+
     # Initialize panels
     panels = Panel[]
     n_unrefined_total = 0
@@ -79,17 +100,6 @@ function BodyAerodynamics(
             section.LE_point .-= kite_body_origin
             section.TE_point .-= kite_body_origin
         end
-        if wing.spanwise_distribution == NONE
-            # NONE distribution: refined_sections already populated in constructor
-            !(wing.n_panels == length(wing.refined_sections) - 1) &&
-                throw(ArgumentError("(wing.n_panels = $(wing.n_panels)) != (length(wing.refined_sections) - 1 = $(length(wing.unrefined_sections) - 1))"))
-        elseif wing.spanwise_distribution == UNCHANGED
-            wing.refined_sections = wing.unrefined_sections
-            !(wing.n_panels == length(wing.unrefined_sections) - 1) &&
-                throw(ArgumentError("(wing.n_panels = $(wing.n_panels)) != (length(wing.unrefined_sections) - 1 = $(length(wing.unrefined_sections) - 1))"))
-        else
-            wing.refined_sections = Section[Section() for _ in 1:wing.n_panels+1]
-        end
 
         # Create panels
         for _ in 1:wing.n_panels
@@ -127,31 +137,22 @@ Initialize a BodyAerodynamics struct in-place by setting up panels and coefficie
 - `body_aero::BodyAerodynamics`: The structure to initialize
 
 # Keyword Arguments
-- `init_aero::Bool`: Wether to initialize the aero data or not
+- `init_aero::Bool`: Whether to initialize the aero data or not
 - `va=[15.0, 0.0, 0.0]`: Apparent wind vector
 - `omega=zeros(3)`: Turn rate in kite body frame x y and z
-- `refine_mesh=true`: Whether to refine wing meshes. Set to `false` after
-  `deform!()` to preserve deformed geometry.
-- `recompute_mapping=true`: Whether to recompute the refined panel mapping.
-  Set to `false` to skip mapping computation when it hasn't changed.
-- `sort_sections=true`: Whether to sort sections by spanwise position.
-  Set to `false` for REFINE wings where section order is determined by structural connectivity.
 
 # Returns
 nothing
 """
 function reinit!(body_aero::BodyAerodynamics;
     init_aero=true,
     va=[15.0, 0.0, 0.0],
-    omega=zeros(MVec3),
-    refine_mesh=true,
-    recompute_mapping=true,
-    sort_sections=true
+    omega=zeros(MVec3)
 )
     idx = 1
     vec = @MVector zeros(3)
     for wing in body_aero.wings
-        reinit!(wing; refine_mesh, recompute_mapping, sort_sections)
+        reinit!(wing)
         panel_props = wing.panel_props
 
         # Create panels

src/obj_geometry.jl

@@ -428,15 +428,9 @@ function ObjWing(
     interp_steps=n_panels+1
 )
 
-    # Force NONE distribution for ObjWing
-    if spanwise_distribution != NONE
-        @warn "ObjWing only supports spanwise_distribution=NONE. Overriding to NONE." maxlog=1
-        spanwise_distribution = NONE
-    end
-
     # Set default: evenly spaced unrefined sections including both tips
     if isnothing(n_unrefined_sections)
-        # Default to having same number of unrefined sections as refined (no refinement)
+        # Default to having same number of unrefined sections as refined (no interpolation needed)
         n_unrefined_sections = n_panels + 1
     end
 
@@ -493,24 +487,34 @@ function ObjWing(
             push!(sections, Section(LE_point, TE_point, POLAR_MATRICES, aero_data))
         end
 
+        # Create refined sections (evenly spaced including both tips)
         refined_sections = Section[]
         for gamma in range(-gamma_tip, gamma_tip, n_panels+1)
             LE_point = [le_interp[i](gamma) for i in 1:3]
             TE_point = [te_interp[i](gamma) for i in 1:3]
             push!(refined_sections, Section(LE_point, TE_point, POLAR_MATRICES, aero_data))
         end
 
+        # Create non_deformed_sections as copy of refined_sections for deformation support
+        non_deformed_sections = [Section() for _ in 1:n_panels+1]
+        for i in 1:n_panels+1
+            reinit!(non_deformed_sections[i], refined_sections[i])
+        end
+
         panel_props = PanelProperties{n_panels}()
         cache = [PreallocationTools.LazyBufferCache()]
 
         wing = Wing(n_panels, Int16(n_unrefined_sections), spanwise_distribution, panel_props, MVec3(spanwise_direction),
             sections, refined_sections, remove_nan,
             Int16[],
-            Section[], zeros(n_panels), zeros(n_panels),
+            non_deformed_sections, zeros(n_panels), zeros(n_panels),
             mass, gamma_tip, inertia_tensor, T_cad_body, R_cad_body, radius,
             le_interp, te_interp, area_interp, cache)
 
-        # Refine mesh and update panel properties
+        # Compute panel mapping for deformation support
+        VortexStepMethod.compute_refined_panel_mapping!(wing)
+
+        # Update panel properties
         reinit!(wing)
 
         wing

src/precompile.jl

@@ -26,6 +26,7 @@
             INVISCID)
 
         # Step 3: Initialize aerodynamics (simplified)
+        refine!(wing)
         body_aero = BodyAerodynamics([wing])
 
         nothing

src/wing_geometry.jl

@@ -297,25 +297,20 @@ function Wing(n_panels::Int;
 end
 
 """
-    reinit!(wing::AbstractWing; refine_mesh=true, recompute_mapping=true, sort_sections=true)
+    reinit!(wing::AbstractWing)
 
-Reinitialize wing geometry and panel properties.
+Reinitialize wing panel properties based on current refined_sections geometry.
 
-# Keyword Arguments
-- `refine_mesh::Bool=true`: Whether to refine the mesh. Set to `false` after
-  `deform!()` to preserve deformed geometry while updating panel properties.
-- `recompute_mapping::Bool=true`: Whether to recompute the refined panel mapping.
-  Set to `false` to skip mapping computation when it hasn't changed.
-- `sort_sections::Bool=true`: Whether to sort sections by spanwise position.
-  Set to `false` for REFINE wings where section order is determined by structural connectivity.
-"""
-function reinit!(wing::AbstractWing; refine_mesh=true, recompute_mapping=true, sort_sections=true)
-    # Refine mesh unless explicitly disabled (e.g., to preserve deformation)
-    if refine_mesh
-        refine_aerodynamic_mesh!(wing; recompute_mapping, sort_sections)
-    end
+This function only updates panel properties (chord, area, etc.) from the existing
+refined_sections. It does NOT refine the mesh - call refine_aerodynamic_mesh!(wing)
+first if needed.
 
-    # Calculate panel properties
+# Note
+After deformation via `unrefined_deform!()` or `deform!()`, call `reinit!` to update
+panel properties while preserving the deformed geometry.
+"""
+function reinit!(wing::AbstractWing)
+    # Calculate panel properties from refined sections
     update_panel_properties!(
         wing.panel_props,
         wing.refined_sections,
@@ -620,54 +615,99 @@ end
 
 Create non_deformed_sections to match refined_sections.
 This enables deformation support for all wings (YAML and OBJ).
-Should be called after refined_sections are populated for the FIRST time only.
+Should be called after refined_sections are populated.
 Once populated, non_deformed_sections serves as the undeformed reference geometry.
 """
 function update_non_deformed_sections!(wing::AbstractWing)
     n_sections = wing.n_panels + 1
 
-    # Only populate non_deformed_sections if it's empty (initial setup)
-    # Once populated, it serves as the undeformed reference and should not be overwritten
+    # Populate or update non_deformed_sections
     if isempty(wing.non_deformed_sections)
+        @show length(wing.refined_sections) n_sections
+        # Initial setup
         wing.non_deformed_sections = [Section() for _ in 1:n_sections]
         for i in 1:n_sections
             reinit!(wing.non_deformed_sections[i], wing.refined_sections[i])
         end
+    elseif length(wing.non_deformed_sections) != n_sections
+        # Size mismatch - error
+        throw(ArgumentError(
+            "non_deformed_sections has incorrect size. " *
+            "Expected $(n_sections) sections (n_panels+1), got $(length(wing.non_deformed_sections)). " *
+            "This indicates an inconsistent wing state."
+        ))
+    else
+        # Correct size - update all sections
+        for i in 1:n_sections
+            reinit!(wing.non_deformed_sections[i], wing.refined_sections[i])
+        end
     end
     return nothing
 end
 
 """
-    refine_aerodynamic_mesh!(wing::AbstractWing; recompute_mapping=true, sort_sections=true)
-
-Refine the aerodynamic mesh of the wing based on spanwise panel distribution.
+    refine!(wing::AbstractWing; recompute_mapping=true, sort_sections=true)
+
+Refine the wing aerodynamic mesh from unrefined sections to refined sections.
+
+This function interpolates the wing geometry from a coarse set of unrefined sections
+to a fine mesh of refined sections (n_panels+1 sections) based on the wing's
+spanwise_distribution setting. It also populates non_deformed_sections which
+enables deformation support via `unrefined_deform!`.
+
+# Required Workflow
+Must be called after wing construction and before creating `BodyAerodynamics`:
+```julia
+wing = Wing("wing.yaml"; n_panels=40)  # or ObjWing(...) or manual Wing
+refine!(wing)                          # Refine mesh
+body_aero = BodyAerodynamics([wing])   # Create aerodynamics
+```
+
+# Distribution Methods
+- `LINEAR`: Linear interpolation between sections
+- `COSINE`: Cosine spacing (more panels near tips)
+- `COSINE_VAN_GARREL`: van Garrel cosine distribution
+- `SPLIT_PROVIDED`: Split each unrefined section into sub-panels
+- `UNCHANGED`: 1:1 copy when n_unrefined_sections == n_panels+1
 
 # Keyword Arguments
-- `recompute_mapping::Bool=true`: Whether to recompute the refined panel mapping.
-  Set to `false` to skip mapping computation when it hasn't changed.
-- `sort_sections::Bool=true`: Whether to sort sections by spanwise position (y-coordinate).
-  Set to `false` for REFINE wings where section order is determined by structural connectivity.
+- `recompute_mapping::Bool=true`: Recompute the mapping from refined panels to unrefined sections
+- `sort_sections::Bool=true`: Sort sections by spanwise position (disable for structural ordering)
 
-Returns:
-    Vector{Section}: List of refined sections
+# Effects
+1. Populates `wing.refined_sections` (n_panels+1 sections)
+2. Populates `wing.non_deformed_sections` (copy of refined_sections for deformation reference)
+3. Computes `wing.refined_panel_mapping` (panel → unrefined section mapping)
+4. Resizes `wing.theta_dist` and `wing.delta_dist` to n_panels
+
+# Example
+```julia
+# YAML wing
+wing = Wing("wing.yaml"; n_panels=40)
+refine!(wing)
+body_aero = BodyAerodynamics([wing])
+
+# After refinement, deformation is supported
+unrefined_deform!(wing, theta_angles, delta_angles)
+```
 """
-function refine_aerodynamic_mesh!(wing::AbstractWing; recompute_mapping=true, sort_sections=true)
+function refine!(wing::AbstractWing; recompute_mapping=true, sort_sections=true)
+    # Validate unrefined_sections exist
+    if isempty(wing.unrefined_sections)
+        throw(ArgumentError(
+            "Cannot refine mesh: wing has no unrefined_sections. " *
+            "Add sections using add_section! or check wing construction."
+        ))
+    end
+
     # Only sort sections if requested (skip for REFINE wings with fixed structural order)
     sort_sections && sort!(wing.unrefined_sections, by=s -> s.LE_point[2], rev=true)
     n_sections = wing.n_panels + 1
 
-    # Handle NONE distribution - sections already refined, just compute mapping
-    if wing.spanwise_distribution == NONE
-        if length(wing.refined_sections) != n_sections
-            throw(ArgumentError("NONE distribution requires refined_sections to be pre-populated"))
-        end
-        recompute_mapping && compute_refined_panel_mapping!(wing)
-        update_non_deformed_sections!(wing)
-        return nothing
-    end
-
     if length(wing.refined_sections) == 0
-        if wing.spanwise_distribution == UNCHANGED || length(wing.unrefined_sections) == n_sections
+        @show wing.spanwise_distribution
+        if wing.spanwise_distribution == UNCHANGED ||
+               length(wing.unrefined_sections) == n_sections
             wing.refined_sections = wing.unrefined_sections
             update_non_deformed_sections!(wing)
             return nothing

src/yaml_geometry.jl

@@ -246,7 +246,7 @@ function Wing(
         # 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, section.airfoil_id, "")
         if !isempty(csv_file_path) && !isabspath(csv_file_path)
@@ -256,15 +256,12 @@ function Wing(
             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 $(section.airfoil_id): Using $aero_model model")
-        
+
         add_section!(wing, le_coord, te_coord, aero_model, aero_data)
     end
-    
-    # Initialize the wing after adding all sections
-    reinit!(wing)
-    
+
     return wing
 end