Use a lot more mvec

Author: 1-Bart-1

src/body_aerodynamics.jl

@@ -24,16 +24,16 @@ Main structure for calculating aerodynamic properties of bodies.
     wings::Union{Vector{Wing}, Vector{RamAirWing}}
     _va::MVec3 = zeros(MVec3)
     omega::MVec3 = zeros(MVec3)
-    gamma_distribution::Vector{Float64} = zeros(Float64, P)
-    alpha_uncorrected::Vector{Float64} = zeros(Float64, P)
-    alpha_corrected::Vector{Float64} = zeros(Float64, P)
-    stall_angle_list::Vector{Float64} = zeros(Float64, P)
-    alpha_array::Vector{Float64} = zeros(Float64, P)
-    v_a_array::Vector{Float64} = zeros(Float64, P)
+    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})
     work_vectors::NTuple{10,MVec3} = ntuple(_ -> zeros(MVec3), 10)
     AIC::Array{Float64, 3} = zeros(3, P, P)
     projected_area::Float64 = one(Float64)
-    y::Vector{Float64} = zeros(Float64, P)
+    y::MVector{P, Float64} = zeros(MVector{P, Float64})
 end
 
 """

src/kite_geometry.jl

@@ -375,7 +375,7 @@ Represents a curved wing that inherits from Wing with additional geometric prope
   -  refined_sections::Vector{Section}
   - `remove_nan::Bool`: Wether to remove the NaNs from interpolations or not
 - Additional fields:
-  - `circle_center_z::Vector{Float64}`: Center of circle coordinates
+  - `circle_center_z`: Center of circle coordinates
   - gamma_tip::Float64: Angle between the body frame z axis and the vector going from the kite circular shape center to the wing tip.
   - `inertia_tensor`::Matrix{Float64}: see: [`calculate_inertia_tensor`](@ref)
   - radius::Float64: Radius of curvature
@@ -398,13 +398,13 @@ mutable struct RamAirWing <: AbstractWing
     mass::Float64
     gamma_tip::Float64
     inertia_tensor::Matrix{Float64}
-    center_of_mass::Vector{Float64}
+    center_of_mass
     radius::Float64
     le_interp::NTuple{3, Extrapolation}
     te_interp::NTuple{3, Extrapolation}
     area_interp::Extrapolation
-    theta_dist::Vector{Float64}
-    delta_dist::Vector{Float64}
+    theta_dist
+    delta_dist
 end
 
 """

src/panel.jl

@@ -301,11 +301,11 @@ function compute_lei_coeffs(section_1::Section, section_2::Section)
 end
 
 """
-    calculate_relative_alpha_and_velocity(panel::Panel, induced_velocity::Vector{Float64})
+    calculate_relative_alpha_and_velocity(panel::Panel, induced_velocity)
 
 Calculate relative angle of attack and relative velocity of the panel.
 """
-function calculate_relative_alpha_and_velocity(panel::Panel, induced_velocity::Vector{Float64})
+function calculate_relative_alpha_and_velocity(panel::Panel, induced_velocity)
     relative_velocity = panel.va + induced_velocity
     v_normal = dot(panel.z_airf, relative_velocity)
     v_tangential = dot(panel.x_airf, relative_velocity)

src/solver.jl

@@ -20,12 +20,12 @@ Struct for storing the solution of the [solve!](@ref) function. Must contain all
     y_airf_array::Matrix{Float64} = zeros(P, 3)
     z_airf_array::Matrix{Float64} = zeros(P, 3)
     va_array::Matrix{Float64} = zeros(P, 3)
-    chord_array::Vector{Float64} = zeros(P)
+    chord_array::MVector{P, Float64} = zeros(MVector{P, Float64})
     ###
-    panel_width_array::Vector{Float64} = zeros(P)
-    cl_array::Vector{Float64} = zeros(P)
-    cd_array::Vector{Float64} = zeros(P)
-    cm_array::Vector{Float64} = zeros(P)
+    panel_width_array::MVector{P, Float64} = zeros(MVector{P, Float64})
+    cl_array::MVector{P, Float64} = zeros(MVector{P, Float64})
+    cd_array::MVector{P, Float64} = zeros(MVector{P, Float64})
+    cm_array::MVector{P, Float64} = zeros(MVector{P, Float64})
     panel_lift::Matrix{Float64} = zeros(P,1)
     panel_drag::Matrix{Float64} = zeros(P,1)
     panel_moment::Matrix{Float64} = zeros(P,1)
@@ -36,8 +36,8 @@ Struct for storing the solution of the [solve!](@ref) function. Must contain all
     moment::MVec3 = zeros(MVec3)       
     force_coefficients::MVec3 = zeros(MVec3)  
     moment_coefficients::MVec3 = zeros(MVec3)  
-    moment_distribution::Vector{Float64} = zeros(P)
-    moment_coeff_dist::Vector{Float64} = zeros(P)
+    moment_distribution::MVector{P, Float64} = zeros(MVector{P, Float64})
+    moment_coeff_dist::MVector{P, Float64} = zeros(MVector{P, Float64})
     solver_status::SolverStatus = FAILURE
 end
 
@@ -58,7 +58,7 @@ function LoopResult(P)
 end
 
 @with_kw struct BaseResult{P}
-    va_norm_array::Vector{Float64} = zeros(P)
+    va_norm_array::MVector{P, Float64} = zeros(MVector{P, Float64})
     va_unit_array::Matrix{Float64} = zeros(P, 3)
 end
 
@@ -556,7 +556,7 @@ function gamma_loop!(
 end
 
 """
-    smooth_circulation(circulation::Vector{Float64}, 
+    smooth_circulation(circulation, 
                       smoothness_factor::Float64, 
                       damping_factor::Float64)
 
@@ -566,7 +566,7 @@ Returns:
 - Tuple of smoothed circulation and boolean indicating if smoothing was applied
 """
 function smooth_circulation(
-    circulation::Vector{Float64},
+    circulation,
     smoothness_factor::Float64,
     damping_factor::Float64
 )

src/wing_geometry.jl

@@ -16,22 +16,13 @@ Represents a wing section with leading edge, trailing edge, and aerodynamic prop
     aero_model::AeroModel = INVISCID
     aero_data::AeroData = nothing
 end
-"""
-    Section(LE_point::Vector{Float64}, TE_point::Vector{Float64}, 
-            aero_model=INVISCID, aero_data=nothing)
-
-Constructor for [Section](@ref) that allows to pass Vectors of Float64 as point coordinates.
-"""
-function Section(LE_point::Vector{Float64}, TE_point::Vector{Float64}, aero_model=INVISCID, aero_data=nothing)
-    Section(MVec3(LE_point), MVec3(TE_point), aero_model, aero_data)
-end
 
 """
     init!(section::Section, LE_point, TE_point, aero_model=nothing, aero_data=nothing)
 
 Function to update a [Section](@ref) in place.
 """
-function init!(section::Section, LE_point, TE_point, aero_model=nothing, aero_data=nothing)
+function init!(section::Section, LE_point::AbstractVector, TE_point::AbstractVector, aero_model=nothing, aero_data=nothing)
     section.LE_point .= LE_point
     section.TE_point .= TE_point
     (!isnothing(aero_model)) && (section.aero_model = aero_model)
@@ -281,8 +272,8 @@ Add a new section to the wing.
 - `aero_model`::AeroModel: [AeroModel](@ref)
 - `aero_data`::AeroData: See [AeroData](@ref)  
 """
-function add_section!(wing::Wing, LE_point::Vector{Float64}, 
-                     TE_point::Vector{Float64}, aero_model::AeroModel, aero_data::AeroData=nothing)
+function add_section!(wing::Wing, LE_point, 
+                     TE_point, aero_model::AeroModel, aero_data::AeroData=nothing)
     if aero_model == POLAR_VECTORS && wing.remove_nan
         aero_data = remove_vector_nans(aero_data)
     elseif aero_model == POLAR_MATRICES && wing.remove_nan
@@ -771,15 +762,15 @@ end
 end
 
 """
-    calculate_projected_area(wing::AbstractWing, z_plane_vector::Vector{Float64}=[0.0, 0.0, 1.0])
+    calculate_projected_area(wing::AbstractWing, z_plane_vector=[0.0, 0.0, 1.0])
 
 Calculate projected wing area onto plane defined by normal vector.
 
 Returns:
     Float64: Projected area
 """
 function calculate_projected_area(wing::AbstractWing, 
-                                z_plane_vector::Vector{Float64}=[0.0, 0.0, 1.0])
+                                z_plane_vector=[0.0, 0.0, 1.0])
     # Normalize plane normal vector
     z_plane_vector = z_plane_vector ./ norm(z_plane_vector)
 

test/utils.jl

@@ -18,10 +18,10 @@ end
 Generate 3D coordinates of a rectangular wing with twist and dihedral.
 
 # Arguments
-- `chord::Vector{Float64}`: Chord lengths of wing panels
+- `chord`: Chord lengths of wing panels
 - `span::Float64`: Total wing span
-- `theta::Vector{Float64}`: Twist angles in radians
-- `beta::Vector{Float64}`: Dihedral angles in radians
+- `theta`: Twist angles in radians
+- `beta`: Dihedral angles in radians
 - `N::Int`: Number of spanwise panels
 - `dist::String`: Distribution type ("cos" or "lin")