Improved obj file reading

Author: 1-Bart-1

src/obj_geometry.jl

@@ -112,7 +112,8 @@ Create interpolation functions for leading/trailing edges and area.
 - Where le_interp and te_interp are tuples themselves, containing the x, y and z interpolations
 """
 function create_interpolations(vertices, circle_center_z, radius, gamma_tip, R=I(3); interp_steps=40)
-    gamma_range = range(-gamma_tip+1e-6, gamma_tip-1e-6, interp_steps)
+    gamma_range = range(-gamma_tip+gamma_tip/interp_steps*2,
+                        gamma_tip-gamma_tip/interp_steps*2, interp_steps)
     stepsize = gamma_range.step.hi
     vz_centered = [v[3] - circle_center_z for v in vertices]
 
@@ -122,33 +123,91 @@ function create_interpolations(vertices, circle_center_z, radius, gamma_tip, R=I
     leading_edges = zeros(3, length(gamma_range))
     areas  = zeros(length(gamma_range))
 
+    n_slices = length(gamma_range)
     for (j, gamma) in enumerate(gamma_range)
         trailing_edges[1, j] = -Inf
         leading_edges[1, j] = Inf
-        for (i, v) in enumerate(vertices)
-            # Rotate y coordinate to check box containment
-            # rotated_y = v[2] * cos(-gamma) - vz_centered[i] * sin(-gamma)
-            gamma_v = atan(-v[2], vz_centered[i])
-            if gamma ≤ 0 && gamma - stepsize ≤ gamma_v ≤ gamma
-                if v[1] > trailing_edges[1, j]
-                    trailing_edges[:, j] .= v
-                    te_gammas[j] = gamma_v
-                end
-                if v[1] < leading_edges[1, j]
-                    leading_edges[:, j] .= v
-                    le_gammas[j] = gamma_v
+
+        # Determine if this is a tip slice and get search parameters
+        is_first_tip = (j == 1)
+        is_last_tip = (j == n_slices)
+
+        if is_first_tip || is_last_tip
+            # Tip slices: use directional search within adjacent slice region
+            gamma_search = is_first_tip ? gamma_range[1] : gamma_range[end]
+            max_te_score = -Inf
+            max_le_score = -Inf
+
+            for (i, v) in enumerate(vertices)
+                gamma_v = atan(-v[2], vz_centered[i])
+
+                # Check if vertex is in the adjacent slice region
+                in_range = if gamma_search ≤ 0
+                    gamma_search - stepsize ≤ gamma_v ≤ gamma_search
+                else
+                    gamma_search ≤ gamma_v ≤ gamma_search + stepsize
                 end
-            elseif gamma > 0 && gamma ≤ gamma_v ≤ gamma + stepsize
-                if v[1] > trailing_edges[1, j]
-                    trailing_edges[:, j] .= v
-                    te_gammas[j] = gamma_v
+
+                if in_range
+                    if is_first_tip
+                        # TE: furthest in [X, Y, -Z] direction
+                        te_score = v[1] + v[2] - v[3]
+                        if te_score > max_te_score
+                            trailing_edges[:, j] .= v
+                            te_gammas[j] = gamma_v
+                            max_te_score = te_score
+                        end
+                        # LE: furthest in [-X, Y, -Z] direction
+                        le_score = -v[1] + v[2] - v[3]
+                        if le_score > max_le_score
+                            leading_edges[:, j] .= v
+                            le_gammas[j] = gamma_v
+                            max_le_score = le_score
+                        end
+                    else  # is_last_tip
+                        # TE: furthest in [X, -Y, -Z] direction
+                        te_score = v[1] - v[2] - v[3]
+                        if te_score > max_te_score
+                            trailing_edges[:, j] .= v
+                            te_gammas[j] = gamma_v
+                            max_te_score = te_score
+                        end
+                        # LE: furthest in [-X, -Y, -Z] direction
+                        le_score = -v[1] - v[2] - v[3]
+                        if le_score > max_le_score
+                            leading_edges[:, j] .= v
+                            le_gammas[j] = gamma_v
+                            max_le_score = le_score
+                        end
+                    end
                 end
-                if v[1] < leading_edges[1, j]
-                    leading_edges[:, j] .= v
-                    le_gammas[j] = gamma_v
+            end
+        else
+            # Interior slices: use standard min/max x-coordinate search
+            for (i, v) in enumerate(vertices)
+                gamma_v = atan(-v[2], vz_centered[i])
+                if gamma ≤ 0 && gamma - stepsize ≤ gamma_v ≤ gamma
+                    if v[1] > trailing_edges[1, j]
+                        trailing_edges[:, j] .= v
+                        te_gammas[j] = gamma_v
+                    end
+                    if v[1] < leading_edges[1, j]
+                        leading_edges[:, j] .= v
+                        le_gammas[j] = gamma_v
+                    end
+                elseif gamma > 0 && gamma ≤ gamma_v ≤ gamma + stepsize
+                    if v[1] > trailing_edges[1, j]
+                        trailing_edges[:, j] .= v
+                        te_gammas[j] = gamma_v
+                    end
+                    if v[1] < leading_edges[1, j]
+                        leading_edges[:, j] .= v
+                        le_gammas[j] = gamma_v
+                    end
                 end
             end
         end
+
         area = norm(leading_edges[:, j] - trailing_edges[:, j]) * stepsize * radius
         last_area = j > 1 ? areas[j-1] : 0.0
         areas[j] = last_area + area
@@ -159,9 +218,9 @@ function create_interpolations(vertices, circle_center_z, radius, gamma_tip, R=I
         trailing_edges[:, j] .= R * trailing_edges[:, j]
     end
 
-    le_interp = ntuple(i -> linear_interpolation(te_gammas, leading_edges[i, :],
+    le_interp = ntuple(i -> linear_interpolation(le_gammas, leading_edges[i, :],
                                            extrapolation_bc=Line()), 3)
-    te_interp = ntuple(i -> linear_interpolation(le_gammas, trailing_edges[i, :],
+    te_interp = ntuple(i -> linear_interpolation(te_gammas, trailing_edges[i, :],
                                            extrapolation_bc=Line()), 3)
     area_interp = linear_interpolation(gamma_range, areas, extrapolation_bc=Line())
 

src/wing_geometry.jl

@@ -462,7 +462,8 @@ function deform!(wing::Wing)
         local_y .= normalize(section1.LE_point - section2.LE_point)
         chord .= section1.TE_point .- section1.LE_point
         normal .= chord × local_y
-        @. wing.refined_sections[i].TE_point = section1.LE_point + cos(wing.theta_dist[i]) * chord - sin(wing.theta_dist[i]) * normal
+        @. wing.refined_sections[i].TE_point = section1.LE_point +
+            cos(wing.theta_dist[i]) * chord - sin(wing.theta_dist[i]) * normal
     end
     return nothing
 end

test/Project.toml

@@ -13,6 +13,7 @@ Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+VortexStepMethod = "ed3cd733-9f0f-46a9-93e0-89b8d4998dd9"
 YAML = "ddb6d928-2868-570f-bddf-ab3f9cf99eb6"
 
 [compat]

test/TestSupport.jl

@@ -189,38 +189,80 @@ using Serialization
         # Create an ObjWing for testing
         wing = ObjWing(test_obj_path, test_dat_path; remove_nan=true)
         body_aero = BodyAerodynamics([wing])
-        
+
         # Store original TE point for comparison
         i = length(body_aero.panels) ÷ 2
         original_te_point = copy(body_aero.panels[i].TE_point_1)
-        
+
         # Apply deformation with non-zero angles
         theta_dist = fill(deg2rad(30.0), wing.n_panels)  # 10 degrees twist
         delta_dist = fill(deg2rad(5.0), wing.n_panels)   # 5 degrees trailing edge deflection
-        
+
         VortexStepMethod.deform!(wing, theta_dist, delta_dist)
         VortexStepMethod.reinit!(body_aero)
-        
+
         # Check if TE point changed after deformation
         deformed_te_point = copy(body_aero.panels[i].TE_point_1)
         @test !isapprox(original_te_point, deformed_te_point, atol=1e-2)
         @test deformed_te_point[3] < original_te_point[3] # right hand rule
         @test deformed_te_point[2] ≈ original_te_point[2] atol=1e-2 # right hand rule
         @test deformed_te_point[1] < original_te_point[1] # right hand rule
         @test body_aero.panels[i].delta ≈ deg2rad(5.0)
-        
+
         # Reset deformation with zero angles
         zero_theta_dist = zeros(wing.n_panels)
         zero_delta_dist = zeros(wing.n_panels)
-        
+
         VortexStepMethod.deform!(wing, zero_theta_dist, zero_delta_dist)
         VortexStepMethod.reinit!(body_aero)
-        
+
         # Check if TE point returned to original position
         reset_te_point = copy(body_aero.panels[i].TE_point_1)
         @test original_te_point ≈ reset_te_point atol=1e-4
     end
+
+    @testset "First and Last Section Deformation with group_deform!" begin
+        # Create an ObjWing with a small number of panels and groups
+        wing = ObjWing(test_obj_path, test_dat_path;
+            n_panels=4, n_groups=2, remove_nan=true)
+
+        # Store original TE points from all refined_sections
+        # Wing has n_panels+1 sections (5 sections for 4 panels)
+        n_sections = wing.n_panels + 1
+        original_te_points = [copy(wing.refined_sections[i].TE_point)
+            for i in 1:n_sections]
+
+        @show wing.refined_sections[1].LE_point
+        @show wing.refined_sections[1].TE_point
+        @show wing.refined_sections[end].LE_point
+        @show wing.refined_sections[end].TE_point
+
+        # Apply group_deform! with non-zero angles (2 groups, each controlling 2 panels)
+        theta_angles = [deg2rad(15.0), deg2rad(20.0)]
+        delta_angles = [deg2rad(5.0), deg2rad(10.0)]
+
+        VortexStepMethod.group_deform!(wing, theta_angles, delta_angles; smooth=false)
+
+        # Check that all sections' TE points have been deformed
+        for i in 1:n_sections
+            deformed_te = wing.refined_sections[i].TE_point
+            original_te = original_te_points[i]
+
+            if i == 1
+                # First section should be deformed
+                @test !isapprox(original_te, deformed_te, atol=1e-6)
+                @info "Section 1 (first): original=$original_te, deformed=$deformed_te"
+            elseif i == n_sections
+                # Last section (n_panels+1) should be deformed
+                @test !isapprox(original_te, deformed_te, atol=1e-6)
+                @info "Section $(n_sections) (last): original=$original_te, deformed=$deformed_te"
+            else
+                # Intermediate sections should also be deformed
+                @test !isapprox(original_te, deformed_te, atol=1e-6)
+            end
+        end
+    end
 
     rm(test_obj_path)
     rm(test_dat_path)
-end
+end

test/ram_geometry/test_kite_geometry.jl

@@ -2,8 +2,7 @@ using Test, VortexStepMethod
 
 # Make paths robust (avoid cd(".."))
 cd(@__DIR__)  # ensure we're in test/ no matter how tests are launched
-include("TestSupport.jl")
-using .TestSupport
+include("test_data_utils.jl")
 
 println("Running tests...")
 

test/runtests.jl

@@ -11,6 +11,6 @@ using Test
     @test vss.wings isa Vector{WingSettings}
     @test length(vss.wings) == 2
     io = IOBuffer(repr(vss))
-    @test countlines(io) == 44  # Updated to match new output format
+    @test countlines(io) == 46  # Updated to match new output format
 end
 nothing

test/settings/test_settings.jl

@@ -2,10 +2,6 @@ using VortexStepMethod
 using LinearAlgebra
 using Test
 
-# Load test support
-include("../TestSupport.jl")
-using .TestSupport
-
 @testset "Group Coefficient Arrays Tests" begin
     @testset "Group coefficients with EQUAL_SIZE method" begin
         # Create a simple wing with groups

test/solver/test_group_coefficients.jl

@@ -2,12 +2,6 @@ using VortexStepMethod
 using LinearAlgebra
 using Test
 
-# Load TestSupport if not already loaded (for standalone execution)
-if !@isdefined(TestSupport)
-    include(joinpath(@__DIR__, "..", "TestSupport.jl"))
-    using .TestSupport
-end
-
 @testset "YAML Wing Deformation Tests" begin
     @testset "Simple Wing Deformation" begin
         # Load existing simple_wing.yaml