Make sure 0 groups works

Author: 1-Bart-1

src/ram_geometry.jl

@@ -415,7 +415,7 @@ function RamAirWing(
     interp_steps=n_sections # TODO: check if interpolations are still needed
 )
 
-    !(n_panels % n_groups == 0) && throw(ArgumentError("Number of panels should be divisible by number of groups"))
+    !(n_groups == 0 || 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"))
 
     # Load or create polars

src/solver.jl

@@ -292,21 +292,29 @@ function solve!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution=
         moment_coeff_dist[i] = moment_dist[i] / (q_inf * projected_area)
     end
 
-    group_moment_dist = solver.sol.group_moment_dist
-    group_moment_coeff_dist = solver.sol.group_moment_coeff_dist
-    group_moment_dist .= 0.0
-    group_moment_coeff_dist .= 0.0
-    panel_idx = 1
-    group_idx = 1
-    for wing in body_aero.wings
-        panels_per_group = wing.n_panels ÷ wing.n_groups
-        for _ in 1:wing.n_groups
-            for _ in 1:panels_per_group
-                group_moment_dist[group_idx] += moment_dist[panel_idx]
-                group_moment_coeff_dist[group_idx] += moment_coeff_dist[panel_idx]
-                panel_idx += 1
+    # Only compute group moments if there are groups
+    if length(solver.sol.group_moment_dist) > 0
+        group_moment_dist = solver.sol.group_moment_dist
+        group_moment_coeff_dist = solver.sol.group_moment_coeff_dist
+        group_moment_dist .= 0.0
+        group_moment_coeff_dist .= 0.0
+        panel_idx = 1
+        group_idx = 1
+        for wing in body_aero.wings
+            if wing.n_groups > 0
+                panels_per_group = wing.n_panels ÷ wing.n_groups
+                for _ in 1:wing.n_groups
+                    for _ in 1:panels_per_group
+                        group_moment_dist[group_idx] += moment_dist[panel_idx]
+                        group_moment_coeff_dist[group_idx] += moment_coeff_dist[panel_idx]
+                        panel_idx += 1
+                    end
+                    group_idx += 1
+                end
+            else
+                # Skip panels for wings with n_groups=0
+                panel_idx += wing.n_panels
             end
-            group_idx += 1
         end
     end
 
@@ -689,8 +697,8 @@ jac, results = linearize(
 )
 ```
 """
-function linearize(solver::Solver, body_aero::BodyAerodynamics, y::Vector{T}; 
-        theta_idxs=1:4, 
+function linearize(solver::Solver, body_aero::BodyAerodynamics, y::Vector{T};
+        theta_idxs=1:4,
         delta_idxs=nothing,
         va_idxs=nothing,
         omega_idxs=nothing,
@@ -700,6 +708,19 @@ function linearize(solver::Solver, body_aero::BodyAerodynamics, y::Vector{T};
     !(length(body_aero.wings) == 1) && throw(ArgumentError("Linearization only works for a body_aero with one wing"))
     wing = body_aero.wings[1]
 
+    # Validate that theta_idxs and delta_idxs match the number of groups
+    if !isnothing(theta_idxs) && wing.n_groups > 0
+        length(theta_idxs) != wing.n_groups && throw(ArgumentError(
+            "Length of theta_idxs ($(length(theta_idxs))) must match number of groups ($(wing.n_groups))"))
+    end
+    if !isnothing(delta_idxs) && wing.n_groups > 0
+        length(delta_idxs) != wing.n_groups && throw(ArgumentError(
+            "Length of delta_idxs ($(length(delta_idxs))) must match number of groups ($(wing.n_groups))"))
+    end
+    if wing.n_groups == 0 && (!isnothing(theta_idxs) || !isnothing(delta_idxs))
+        throw(ArgumentError("Cannot use theta_idxs or delta_idxs when wing has n_groups=0 (no group functionality)"))
+    end
+
     init_va = body_aero.cache[1][body_aero.va]
     init_va .= body_aero.va
     if !isnothing(theta_idxs)

src/wing_geometry.jl

@@ -235,7 +235,7 @@ function Wing(n_panels::Int;
         spanwise_distribution::PanelDistribution=LINEAR,
         spanwise_direction::PosVector=MVec3([0.0, 1.0, 0.0]),
         remove_nan=true)
-    !(n_panels % n_groups == 0) && throw(ArgumentError("Number of panels should be divisible by number of groups"))
+    !(n_groups == 0 || n_panels % n_groups == 0) && throw(ArgumentError("Number of panels should be divisible by number of groups"))
     panel_props = PanelProperties{n_panels}()
     Wing(n_panels, n_groups, spanwise_distribution, panel_props, spanwise_direction, Section[], Section[], remove_nan)
 end

src/yaml_geometry.jl

@@ -190,7 +190,7 @@ function Wing(
     remove_nan=true,
     prn=false
 )
-    !(n_panels % n_groups == 0) && throw(ArgumentError("Number of panels should be divisible by number of groups"))
+    !(n_groups == 0 || 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 $geometry_file"

test/data/solver/wings/solver_test_wing.yaml

@@ -0,0 +1,12 @@
+wing_sections:
+  headers: [airfoil_id, LE_x, LE_y, LE_z, TE_x, TE_y, TE_z]
+  data:
+    - [1, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0]
+    - [1, 0.0, -1.0, 0.0, 1.0, -1.0, 0.0]
+
+wing_airfoils:
+  alpha_range: [-10, 10, 1]
+  reynolds: 1000000
+  headers: [airfoil_id, type, info_dict]
+  data:
+    - [1, polars, {csv_file_path: ""}]

test/solver/test_solver.jl

@@ -29,4 +29,152 @@ using Test
             rm(settings_file; force=true)
         end
     end
+
+    @testset "Solver with n_groups=0" begin
+        # Test that solver works correctly when n_groups=0 (no group functionality)
+        settings_file = create_temp_wing_settings("solver", "solver_test_wing.yaml";
+            alpha=5.0, beta=0.0, wind_speed=10.0, n_groups=0)
+
+        try
+            settings = VSMSettings(settings_file)
+            wing = Wing(settings)
+            @test wing.n_groups == 0
+
+            body_aero = BodyAerodynamics([wing])
+            solver = Solver(body_aero, settings)
+
+            # Verify solver has zero groups
+            @test length(solver.sol.group_moment_dist) == 0
+            @test length(solver.sol.group_moment_coeff_dist) == 0
+
+            # Test that solve! works without errors
+            va = [10.0, 0.0, 0.0]
+            set_va!(body_aero, va)
+            sol = solve!(solver, body_aero)
+
+            @test sol isa VSMSolution
+            @test sol.solver_status == SUCCESS
+
+            # Verify that group moments are empty
+            @test length(sol.group_moment_dist) == 0
+            @test length(sol.group_moment_coeff_dist) == 0
+
+            # But force and moment should still be computed
+            @test !all(sol.force .== 0.0)
+            @test norm(sol.force) > 0
+
+        finally
+            rm(settings_file; force=true)
+        end
+    end
+
+    @testset "Linearize with n_groups=0" begin
+        # Test that linearize works correctly when n_groups=0
+        settings_file = create_temp_wing_settings("solver", "solver_test_wing.yaml";
+            alpha=5.0, beta=0.0, wind_speed=10.0, n_groups=0, n_panels=4)
+
+        try
+            settings = VSMSettings(settings_file)
+            wing = Wing(settings)
+            @test wing.n_groups == 0
+
+            body_aero = BodyAerodynamics([wing])
+            solver = Solver(body_aero, settings)
+
+            # Set velocity
+            va = [10.0, 0.0, 0.0]
+            set_va!(body_aero, va)
+
+            # Test linearize with only velocity (no theta or delta since n_groups=0)
+            y = va  # Only velocity in input vector
+            jac, results = VortexStepMethod.linearize(
+                solver,
+                body_aero,
+                y;
+                theta_idxs=nothing,
+                delta_idxs=nothing,
+                va_idxs=1:3,
+                omega_idxs=nothing
+            )
+
+            # Results should only have 6 elements (force + moment, no group moments)
+            @test length(results) == 6
+            @test size(jac) == (6, 3)  # 6 outputs, 3 inputs (vx, vy, vz)
+
+            # Verify forces are non-zero
+            @test norm(results[1:3]) > 0
+
+            # Test that using theta_idxs with n_groups=0 throws an error
+            @test_throws ArgumentError VortexStepMethod.linearize(
+                solver,
+                body_aero,
+                [0.0, 10.0, 0.0, 0.0];  # Invalid: trying to use theta
+                theta_idxs=1:1,
+                va_idxs=2:4
+            )
+
+            # Test that using delta_idxs with n_groups=0 throws an error
+            @test_throws ArgumentError VortexStepMethod.linearize(
+                solver,
+                body_aero,
+                [0.0, 10.0, 0.0, 0.0];  # Invalid: trying to use delta
+                delta_idxs=1:1,
+                va_idxs=2:4
+            )
+
+        finally
+            rm(settings_file; force=true)
+        end
+    end
+
+    @testset "Linearize theta_idxs validation" begin
+        # Test that theta_idxs length must match n_groups
+        settings_file = create_temp_wing_settings("solver", "solver_test_wing.yaml";
+            alpha=5.0, beta=0.0, wind_speed=10.0, n_groups=2, n_panels=4)
+
+        try
+            settings = VSMSettings(settings_file)
+            wing = Wing(settings)
+            @test wing.n_groups == 2
+
+            body_aero = BodyAerodynamics([wing])
+            solver = Solver(body_aero, settings)
+
+            va = [10.0, 0.0, 0.0]
+            set_va!(body_aero, va)
+
+            # Test with correct number of theta angles (2)
+            y_correct = [0.0, 0.0, 10.0, 0.0, 0.0]  # 2 theta + 3 va
+            jac, results = VortexStepMethod.linearize(
+                solver,
+                body_aero,
+                y_correct;
+                theta_idxs=1:2,
+                va_idxs=3:5
+            )
+            @test size(jac, 1) == 8  # 6 + 2 group moments
+
+            # Test with wrong number of theta angles (should throw error)
+            y_wrong = [0.0, 0.0, 0.0, 0.0, 10.0, 0.0, 0.0]  # 4 theta + 3 va
+            @test_throws ArgumentError VortexStepMethod.linearize(
+                solver,
+                body_aero,
+                y_wrong;
+                theta_idxs=1:4,  # Wrong: 4 angles but only 2 groups
+                va_idxs=5:7
+            )
+
+            # Test with wrong number of delta angles
+            @test_throws ArgumentError VortexStepMethod.linearize(
+                solver,
+                body_aero,
+                y_wrong;
+                delta_idxs=1:4,  # Wrong: 4 angles but only 2 groups
+                va_idxs=5:7
+            )
+
+        finally
+            rm(settings_file; force=true)
+        end
+    end
 end

test/yaml_geometry/test_wing_constructor.jl

@@ -151,7 +151,12 @@ wing_airfoils:
 
         # Test invalid n_panels/n_groups combination
         @test_throws ArgumentError Wing(test_yaml_path; n_panels=5, n_groups=2)
-        
+
+        # Test n_groups=0 (no grouping functionality)
+        wing_no_groups = Wing(test_yaml_path; n_panels=4, n_groups=0)
+        @test wing_no_groups.n_groups == 0
+        @test wing_no_groups.n_panels == 4
+
         # Test invalid spanwise direction
         @test_throws ArgumentError Wing(test_yaml_path; spanwise_direction=[1.0, 0.0, 0.0])
     end