`AeroFuse.PanelGeometry.Panel3D`

— Type`Panel3D(p1, p2, p3, p4)`

Four Cartesian coordinates `p1, p2, p3, p4`

representing corners of a panel in 3 dimensions. The following commutative diagram (math joke) depicts the order:

```
z → y
↓
x
p1 —→— p4
| |
↓ ↓
| |
p2 —→— p3
```

`AeroFuse.PanelGeometry.get_transformation`

— Function`get_transformation(panel :: AbstractPanel3D)`

Generate the mapping to transform a point from global coordinates to an `AbstractPanel3D`

's local coordinate system.

`AeroFuse.PanelGeometry.make_panels`

— Method`make_panels(xyzs)`

Convert an array of coordinates corresponding to a wing, ordered from root to tip and leading-edge to trailing-edge, into panels.

`AeroFuse.PanelGeometry.midpoint`

— Method`midpoint(panel :: AbstractPanel3D)`

Compute the midpoint of an `AbstractPanel3D`

.

`AeroFuse.PanelGeometry.normal_vector`

— Method`normal_vector(panel :: Panel3D)`

Compute the normal vector of an `AbstractPanel3D`

.

`AeroFuse.PanelGeometry.panel_area`

— Method`panel_area(panel :: AbstractPanel3D)`

Compute the area of a planar quadrilateral 3D panel.

`AeroFuse.PanelGeometry.panel_coordinates`

— Method`panel_coordinates(panel :: Panel3D)`

Compute the coordinates of a `Panel3D`

.

`AeroFuse.PanelGeometry.reflect_xz`

— Method`reflect_xz(panel :: Panel3D)`

Reflect a Panel3D with respect to the $x$-$z$ plane of its reference coordinate system.

`AeroFuse.PanelGeometry.transform`

— Method`transform(panel :: Panel3D, rotation, translation)`

Perform an affine transformation on the coordinates of a `Panel3D`

given a rotation matrix and translation vector.

`AeroFuse.PanelGeometry.transform_normal`

— Method`transform_normal(panel :: Panel3D, h_l, g_l)`

Transform the normal vector $n̂₀$ of a `Panel3D`

about the hinge axis $ĥₗ$ by the control gain $gₗ$.

The transformation is the following: $n̂ₗ = gₗ ĥₗ × n̂₀$ (Flight Vehicle Aerodynamics, M. Drela, Eq. 6.36).

`AeroFuse.PanelGeometry.wake_panel`

— Method`wake_panel(panels :: DenseArray{<: AbstractPanel3D}, bound, U)`

Calculate required transformation from the global coordinate system to an to an `AbstractPanel3D`

's local coordinate system.

`AeroFuse.PanelGeometry.wetted_area`

— Method`wetted_area(panels :: Array{Panel3D})`

Compute the total wetted area by summing the areas of an array of `Panel3D`

.

`AeroFuse.DoubletSource.boundary_vector`

— Method`boundary_vector(panels, u)`

Create the vector for the boundary condition of the problem given an array of `Panel2D`

s and velocity $u$.

`AeroFuse.DoubletSource.doublet_matrix`

— Method`doublet_matrix(panels_1, panels_2)`

Create the matrix of doublet potential influence coefficients between pairs of `panels₁`

and `panels₂`

.

`AeroFuse.DoubletSource.influence_matrix`

— Method`influence_matrix(panels, wake_panel :: AbstractPanel2D)`

Assemble the Aerodynamic Influence Coefficient matrix consisting of the doublet matrix, wake vector, Kutta condition given `Panel2Ds`

and the wake panel.

`AeroFuse.DoubletSource.kutta_condition`

— Method`kutta_condition(panels)`

Create the vector describing Morino's Kutta condition given `Panel2D`

s.

`AeroFuse.DoubletSource.solve_linear`

— Method`solve_linear(panels, u, wakes)`

Solve the linear aerodynamic system given the array of Panel2Ds, a velocity $\vec U$, a vector of wake `Panel2D`

s, and an optional named bound for the length of the wake.

The system of equations $A[φ] = [\vec{U} ⋅ n̂] - B[σ]$ is solved, where $A$ is the doublet influence coefficient matrix, $φ$ is the vector of doublet strengths, $B$ is the source influence coefficient matrix, and $σ$ is the vector of source strengths.

`AeroFuse.DoubletSource.solve_linear`

— Method`solve_linear(panels, u, sources, bound)`

Solve the system of equations $[AIC][φ] = [\vec{U} ⋅ n̂] - B[σ]$ condition given the array of `Panel2D`

s, a velocity $\vec U$, a condition whether to disable source terms ($σ = 0$), and an optional named bound for the length of the wake.

`AeroFuse.DoubletSource.source_matrix`

— Method`doublet_matrix(panels_1, panels_2)`

Create the matrix of source potential influence coefficients between two arrays of `Panel2D`

s.

`AeroFuse.DoubletSource.source_strengths`

— Method`source_strengths(panels, freestream)`

Create the vector of source strengths for the Dirichlet boundary condition $σ = \vec U_{\infty} ⋅ n̂$ given Panel2Ds and a Uniform2D.

`AeroFuse.DoubletSource.wake_vector`

— Method`wake_vector(woke_panel :: AbstractPanel2D, panels)`

Create the vector of doublet potential influence coefficients from the wake on the panels given the wake panel and the array of `Panel2Ds`

.

`AeroFuse.surface_velocities`

— Method`surface_velocities(panels, φs, u, sources :: Bool)`

Compute the surface speeds and panel distances given the array of `Panel2D`

s, their associated doublet strengths $φ$s, the velocity $u$, and a condition whether to disable source terms ($σ = 0$).

`AeroFuse.NonDimensional.aerodynamic_coefficients`

— Method`aerodynamic_coefficients(force, moment, Ω, V, S, b, c, ρ)`

Compute the relevant aerodynamic coefficients given a net force, moment and angular rates $Ω$ with reference speed $V$, area $S$, span $b$, chord $c$, and density $ρ$.

`AeroFuse.NonDimensional.dynamic_pressure`

— Method`dynamic_pressure(ρ, V)`

Compute the dynamic pressure given density $ρ$ and speed $V$.

`AeroFuse.NonDimensional.force_coefficient`

— Method`force_coefficient(force, q, S)`

Compute the non-dimensional force coefficient given force, dynamic pressure $q$, and area $S$.

`AeroFuse.NonDimensional.moment_coefficient`

— Method`moment_coefficient(moment, q, S, L)`

Compute the non-dimensional moment coefficient given force, dynamic pressure $q$, area $S$, and reference length $L$.

`AeroFuse.NonDimensional.pressure_coefficient`

— Method`pressure_coefficient(force, ρ, V, S)`

Compute the pressure coefficient given force, reference density $ρ$, speed $V$ and area $S$.

`AeroFuse.NonDimensional.rate_coefficient`

— Method`rate_coefficient(Ω, V, L)`

Compute the non-dimensional angular velocity coefficient given angular speed $Ω$, reference speed $V$, and reference length $L$.

`AeroFuse.Beams.Material`

— Method```
Material(E, J, σ_max, ρ)
Material(; elastic_modulus, shear_modulus, yield_stress, density)
```

Define a `Material`

with positive, real elastic modulus $E$, shear modulus $G$, yield stress $σ_{\max}$, and density $ρ$.

The default assignments for the named variables are set to the properties of aluminium?

**Arguments**

`elastic_modulus :: Real = 85e9`

: Elastic modulus.`shear_modulus :: Real = 25e9`

: Shear modulus.`yield_stress :: Real = 350e6`

: Yield stress.`density :: Real = 1.6e3`

: Density.

`AeroFuse.Beams.Tube`

— Type`Tube(material :: Material, length, radius, thickness)`

Define a hollow tube of fixed radius with a given material, length, and thickness.

`AeroFuse.Beams.tube_stiffness_matrix`

— Function```
tube_stiffness_matrix(E, G, A, Iyy, Izz, J, L)
tube_stiffness_matrix(E, G, A, Iyy, Izz, J, L, num)
tube_stiffness_matrix(tube :: Tube)
tube_stiffness_matrix(tube :: Vector{Tube})
tube_stiffness_matrix(x :: Matrix{Real})
```

Generate the stiffness matrix using the properties of a tube.

The required properties are the elastic modulus $E$, shear modulus $G$, area $A$, moments of inertia about the $y-$ and $z-$ axes $I_{yy}, I_{zz}$, polar moment of inertia $J$, length $L$. A composite stiffness matrix is generated with a specified number of elements.

`AeroFuse.Laplace.Freestream`

— Type```
Freestream(α, β, Ω)
Freestream(α, β, Ω_x, Ω_y, Ω_z)
Freestream(U, Ω)
Freestream(;
alpha = 0.,
beta = 0.,
omega = [0,0,0]
)
```

Define freestream conditions with angle of attack $α$ (degrees), sideslip angle $β$ (degrees), and (quasi-steady) rotation vector $Ω$ (in geometry axes).

Alternatively, provide the velocity vector $U$, which is normalized to determine the angles.

`AeroFuse.Laplace.cartesian_to_freestream`

— Method`cartesian_to_freestream(U)`

Convert Cartesian coordinates to freestream (spherical polar) flow coordinates.

`AeroFuse.Laplace.freestream_to_cartesian`

— Method`freestream_to_cartesian(r, θ, φ)`

Convert freestream flow (spherical polar) coordinates to Cartesian coordinates.

`AeroFuse.velocity`

— Method`velocity(freestream :: Freestream)`

Compute the velocity of a `Freestream`

.

`AeroFuse.VortexLattice.Horseshoe`

— Type`Horseshoe(panel :: Panel3D, normal, drift = zeros(3))`

Generate a `Horseshoe`

corresponding to a `Panel3D`

, an associated normal vector, and a "drift velocity".

`AeroFuse.VortexLattice.VortexRing`

— MethodConstructor for making a `VortexRing`

with a `Panel3D`

. The following convention is adopted:

```
p1 —front leg→ p4
| |
left leg right leg
↓ ↓
p2 —back leg-→ p3
```

`AeroFuse.VortexLattice.control_point`

— Method`control_point(panel :: Panel3D)`

Compute the control point of a `Panel3D`

for horseshoes/vortex rings, which is the average of the 3-quarter point on each side of the trailing legs.

`AeroFuse.bound_leg`

— Method`bound_leg(panel :: Panel3D)`

Compute the bound leg for a `Panel3D`

, for horseshoes/vortex rings, which quarter point on each side of the trailing legs.

`AeroFuse.form_factor`

— Method`form_factor(fuse :: HyperEllipseFuselage)`

Compute the form factor of `HyperEllipseFuselage`

for parasitic drag estimation based on the DATCOM formula (Raymer - Aircraft Design: A Conceptual Approach, 4th Ed., Eq. 12.31): $FF = 1 + 60 / f³ + f / 400$

`AeroFuse.form_factor`

— Method```
form_factor(wing :: Wing, M, num)
form_factor(wing_mesh :: WingMesh, M, num)
```

Compute the form factor $K_f$ of a `Wing`

or `WingMesh`

at Mach number $M$ for parasitic drag estimation based on Raymer's formula for wing, tail, strut, and pylon (Raymer - Aircraft Design: A Conceptual Approach, 4th Ed., Eq. 12.30): $FF = (1 + 0.6(t/c)ₘₐₓ / (x/c) + 100(t/c)ₘₐₓ^4) ⨯ 1.34M^0.18 × cos(Λ_m)^0.28$.

An integer `num`

is required for interpolating `Wing`

's airfoils' coordinates to determine their maximum thickness-to-chord ratios.

`AeroFuse.lateral_stability_derivatives`

— Method`lateral_stability_derivatives(dvs, U, m, Iyy, Q, S, c)`

Compute the stability derivatives for the lateral forces and moments with respect to the sideslip angle, roll and yaw rates: $[Y,L,N]_{β,p,r}$

The inputs are force and moment coefficient stability derivatives matrix `dvs`

, the freestream speed `U`

, the mass `m`

and lateral moment sof inertia $I_{xx}, I_{zz}$, the dynamic pressure Q, reference area $S$ and span length $b$.

`AeroFuse.longitudinal_stability_derivatives`

— Function`longitudinal_stability_derivatives(dvs, U₀, m, Iyy, Q, S, c)`

Compute the stability derivatives for the longitudinal forces and moments with resepct to speed, angle of attack, and pitch rate: $[X,Z,M]_{u,α,q}$

The inputs are force and moment coefficient stability derivatives matrix `dvs`

, the freestream speed `U`

, the mass `m`

and longitudinal moment of inertia $I_{yy}$, the dynamic pressure Q, reference area $S$ and chord length $c$.

`AeroFuse.make_horseshoes`

— Method`make_horseshoes(wing :: WingMesh)`

Generate an array of `Horseshoe`

s defined by the chord coordinates and normal vectors defined by the camber distribution of a `WingMesh`

.

`AeroFuse.make_vortex_rings`

— Method`make_vortex_rings(wing :: WingMesh)`

Generate an array of `VortexRing`

s defined by the camber coordinates and normal vectors of a `WingMesh`

.

`AeroFuse.parasitic_drag_coefficient`

— Function```
parasitic_drag_coefficient(
fuse :: HyperEllipseFuselage,
refs :: References,
x_tr :: Real,
ts = 0:0.01:1
)
```

Estimate the profile drag coefficient of a `HyperEllipseFuselage`

using the **wetted-area method** based on Schlichting's skin-friction coefficient formula with given `References`

, a specified transition location $xₜᵣ$ as a ratio of the fuselage length, and optionally the parametric distribution `t ∈ [0,1]`

for the discretization of the nose, cabin and rear sections.

`AeroFuse.parasitic_drag_coefficient`

— Method```
parasitic_drag_coefficient(
L, x_tr,
ρ, V, M, μ, S_ref,
S_wet, Kf, fM
)
```

Compute the parasitic drag coefficient $C_{D₀}$ with the following quantities. Uses a transition-based model from laminar to turbulent flow based on Schlichting's skin-friction coefficient formulas.

**Arguments**

- L = Reference length (m)
- x_tr = Transition location as ratio of reference length
- ρ = Density (kg/m³)
- V = Speed (m/s)
- M = Mach number
- S_ref = Reference area (m²)
- μ = Dynamic viscosity (kg/(m ⋅ s))
- S_wet = Wetted area (m²)
- Kf = Form factor
- fM = Mach number influence

`AeroFuse.parasitic_drag_coefficient`

— Method```
parasitic_drag_coefficient(
wing :: Wing,
refs :: References,
x_tr
)
```

Estimate the profile drag coefficient of a `Wing`

using the **wetted-area method** based on Schlichting's skin-friction coefficient formula with given `References`

, a specified transition location $xₜᵣ ∈ [0,1]$ as a ratio of the chord lengths.

`AeroFuse.parasitic_drag_coefficient`

— Method```
parasitic_drag_coefficient(
wing :: WingMesh,
refs :: References
x_tr :: Real,
u_es,
)
```

Estimate the profile drag coefficient of a `WingMesh`

using the **local-friction and local-dissipation method** based on Schlichting's skin-friction coefficient formula with given `References`

, a specified transition ratio $xₜᵣ$, and edge velocities $\mathbf u_e$.

At present, the edge velocities would be computed using the vortex lattice method via `VortexLatticeSystem`

. For this case, the panels corresponding to the camber distribution are used in the calculation.

`AeroFuse.plot_panels`

— Method`plot_panels(panels :: Array{Panel3D})`

Get the coordinates of an array of `Panel3D`

for plotting.

`AeroFuse.plot_planform`

— Method`plot_planform(wing :: AbstractWing)`

Get the planform coordinates of an `AbstractWing`

for plotting.

`AeroFuse.plot_surface`

— Method```
plot_surface(wing :: AbstractWing)
plot_surface(wing :: AbstractWing,
span_num :: Vector{Integer},
chord_num :: Integer)
```

Get the surface coordinates of an `AbstractWing`

for plotting, optionally with specified spanwise and chordwise discretizations.

`AeroFuse.print_info`

— Function`print_info(wing :: AbstractWing)`

Print the relevant geometric characteristics of an `AbstractWing`

.

`AeroFuse.solve_case`

— Method```
solve_case(
components :: Vector{Horseshoe},
fs :: Freestream,
refs :: References;
name = :aircraft :: Symbol,
compressible = false :: Boolean,
print = false :: Boolean,
print_components = false :: Boolean
)
```

Perform a vortex lattice analysis given a vector of `Horseshoe`

s, a `Freestream`

condition, and `References`

values.

`AeroFuse.solve_case`

— Method`solve_case(foil :: Foil, uniform :: Uniform2D; sources = false, wake_length = 1e3, num_panels :: Int64 = 60)`

Evaluate a doublet-source case given a `Foil`

with a `Uniform2D`

, with optional named arguments to specify whether the source terms are non-zero, the length of the wake, and the number of panels for the analysis.

`AeroFuse.spanwise_loading`

— Method```
spanwise_loading(panels :: Matrix{Panel3D}, CFs, S)
spanwise_loading(wing :: WingMesh, CFs, S)
```

Obtain the spanwise aerodynamic loads `(CDi, CY, CL)`

for a given matrix of `Panel3D`

s, surface coefficients `CFs`

over the panels, and reference area $S$.

If a `WingMesh`

is provided instead of the matrix, then it will compute the chordwise panel distribution over the surface.

`AeroFuse.spanwise_loading`

— Method`spanwise_loading(wing_mesh :: WingMesh, ref :: References, CFs, Γs)`

Obtain the spanwise aerodynamic loads `(CDi, CY, CL, CL_norm)`

for a given `WingMesh`

, reference values `ref`

, surface coefficients `CFs`

, and circulations $Γ$.

The chordwise normalized lift coefficient loading `CL_norm`

is calculated via the formula $C_L = 2Γ / ρVc$ based on the reference speed $V$ and chord $c$ from `ref`

.

Note that the surface coefficients `CFs`

should be computed in wind axes to match `CL_norm`

.

`AeroFuse.MathTools.:|>`

— Method"Lenses" to access subfields on lists of objects.

`AeroFuse.MathTools.weighted`

— Method`weighted(x1, x2, μ)`

Compute the weighted value between two values $x_1$ and $x_2$ with weight $\mu \in [0,1]$.

`AeroFuse.MathTools.weighted_vector`

— MethodCompute the weighted average (μ) of two vectors.

`AeroFuse.VortexLattice.Horseshoe`

— Type`Horseshoe(r1, r2, rc, normal, chord)`

Define a horseshoe vortex with a start and endpoints $r₁, r₂$ for the bound leg, a collocation point $r$, a normal vector $n̂$, and a finite core size.

The finite core setup is not implemented for now.

`AeroFuse.VortexLattice.References`

— Type```
References(V, ρ, μ, S, b, c, r)
References(;
speed, density, viscosity,
sound_speed, area, span,
chord, location
)
```

Define reference values with speed $V$, density $ρ$, dynamic viscosity $μ$, area $S$, span $b$, chord $c$, location $r$ for a vortex lattice analysis. A constructor with named arguments is provided for convenience:

**Arguments**

`speed :: Real = 1.`

: Speed (m/s)`density :: Real = 1.225`

: Density (m)`viscosity :: Real = 1.5e-5`

: Dynamic viscosity (kg/(m ⋅ s))`sound_speed :: Real = 330.`

: Speed of sound (m/s)`area :: Real = 1.`

: Area (m²)`span :: Real = 1.`

: Span length (m)`chord :: Real = 1.`

: Chord length (m)`location :: Vector{Real} = [0,0,0]`

: Position (m)

`AeroFuse.VortexLattice.VortexLatticeSystem`

— Type```
VortexLatticeSystem(
aircraft,
fs :: Freestream,
refs :: References,
compressible = false,
)
```

Construct a `VortexLatticeSystem`

for analyzing inviscid aerodynamics of an aircraft (must be a `ComponentArray`

of `Horseshoe`

s or `VortexRing`

s) with `Freestream`

conditions and `References`

for non-dimensionalization. Options are provided for compressibility corrections via the Prandtl-Glauert transformation (false by default) and axis system for computing velocities and forces (`Geometry`

by default).

`AeroFuse.VortexLattice.VortexLatticeSystem`

— Type`VortexLatticeSystem`

A system consisting of the relevant variables for a vortex lattice analysis for post-processing.

**Arguments**

The accessible fields are:

`vortices`

: The array of vortices, presently of`AbstractVortex`

types.`circulations`

: The circulation strengths of the vortices obtained by solving the linear system.`influence_matrix`

: The influence matrix of the linear system.`boundary_vector`

: The boundary condition corresponding to the right-hand-side of the linear system.`freestream :: Freestream`

: The freestream conditions.`reference :: References`

: The reference values.

`AeroFuse.VortexLattice.VortexRing`

— Type`VortexRing(r1, r2, r3, r4, r_c, n̂, ε)`

A vortex ring consisting of four points $r_i, i = 1,…,4$, a collocation point $r_c$, a normal vector $n̂$, and a core size $ε$. The following convention is adopted:

```
r1 —front leg→ r4
| |
left leg right leg
↓ ↓
r2 —back leg-→ r3
```

`AeroFuse.VortexLattice.bound_leg_center`

— Method`bound_leg_center(hs :: Horseshoe)`

Compute the midpoint of the bound leg of a `Horseshoe`

.

`AeroFuse.VortexLattice.bound_leg_vector`

— Method`bound_leg_vector(hs :: Horseshoe)`

Compute the direction vector of the bound leg of a `Horseshoe`

.

`AeroFuse.VortexLattice.bound_velocity`

— Method`bound_velocity(r, hs :: Horseshoe, Γ, u_hat)`

Compute the induced velocity at a point $r$ from the bound leg with constant strength $Γ$ of a given `Horseshoe`

.

`AeroFuse.VortexLattice.boundary_condition`

— Method`boundary_condition(vortices, U, Ω)`

Assemble the boundary condition vector given an array of `AbstractVortex`

, the freestream velocity $U$, and a quasi-steady rotation vector $Ω$.

`AeroFuse.VortexLattice.center_of_pressure`

— Method`center_of_pressure(system :: VortexLatticeSystem)`

Determine the center of pressure $x_{cp}$ of the `VortexLatticeSystem`

.

This is computed based on the nearfield lift $C_L$ and moment $Cₘ$ coefficients, and the reference location $xᵣ$ and chord length $cᵣ$ from `References`

: $x_{cp} = xᵣ -cᵣ(Cₘ / C_L)$

`AeroFuse.VortexLattice.farfield`

— Method`farfield(system :: VortexLatticeSystem)`

Compute the **total farfield** force coefficients of the `VortexLatticeSystem`

. These are in **wind axes** by definition.

`AeroFuse.VortexLattice.farfield_coefficients`

— Method`farfield_coefficients(system :: VortexLatticeSystem)`

Compute the **total farfield** force coefficients for all components of the `VortexLatticeSystem`

. These are in **wind axes** by definition.

`AeroFuse.VortexLattice.farfield_forces`

— Method`farfield_forces(system :: VortexLatticeSystem)`

Compute the **farfield** forces in **wind axes** for all components of the `VortexLatticeSystem`

.

`AeroFuse.VortexLattice.freestream_derivatives`

— Method```
freestream_derivatives(
system :: VortexLatticeSystem;
axes :: AbstractAxisSystem = Stability(),
name = :aircraft,
print = false,
print_components = false,
farfield = false
)
```

Compute the force and moment coefficients of the components of a `VortexLatticeSystem`

and their derivatives with respect to freestream values: Mach $M$ (if compressible), angles of attack $α$ and sideslip $β$, and non-dimensionalized rotation rates $p̄, q̄, r̄$ (in stability axes).

The axes of the force and moment coefficients can be changed by passing any `AbstractAxisSystem`

(such as `Body(), Geometry(), Wind(), Stability()`

) to the named `axes`

argument. The nearfield force and moment coefficients are reported in stability axes by default. Note that the derivatives with respect to the rotation rates will still refer to the rotation vector in stability axes $(p̄, q̄, r̄)$.

Optional printing arguments are provided for the components and the entire system, along with the corresponding farfield coefficients if needed.

`AeroFuse.VortexLattice.influence_matrix`

— Method```
influence_matrix(vortices)
influence_matrix(vortices, u_hat)
```

Assemble the Aerodynamic Influence Coefficient (AIC) matrix given an array of `AbstractVortex`

and the freestream direction $û$.

`AeroFuse.VortexLattice.nearfield`

— Method`nearfield(system :: VortexLatticeSystem)`

Compute the **total** nearfield force and moment coefficients for all components of the `VortexLatticeSystem`

. These are in **wind axes** by default.

`AeroFuse.VortexLattice.nearfield_coefficients`

— Method`nearfield_coefficients(system :: VortexLatticeSystem)`

Compute the nearfield force and moment coefficients for all components of the `VortexLatticeSystem`

. These are in **wind axes** by default.

`AeroFuse.VortexLattice.print_coefficients`

— Function```
print_coefficients(
system :: VortexLatticeSystem,
name = :aircraft;
components = false
)
```

Print a pretty table of the total nearfield and farfield coefficients of a `VortexLatticeSystem`

with an optional name.

A named Boolean argument `components`

is provided to also enable the printing of any possible components.

`AeroFuse.VortexLattice.print_coefficients`

— Function```
print_coefficients(
nf_coeffs, ff_coeffs,
name = ""
)
```

Print a pretty table of the nearfield and farfield coefficients with an optional name.

`AeroFuse.VortexLattice.print_derivatives`

— Function```
print_derivatives(
nf_coeffs, ff_coeffs, name = "";
farfield = false,
)
```

Print a pretty table of the aerodynamic coefficients and derivatives with an optional name, and a named argument for enabling printing of farfield coefficients.

`AeroFuse.VortexLattice.surface_dynamics`

— Method```
surface_dynamics(
system :: VortexLatticeSystem;
axes :: AbstractAxisSystem = Geometry()
)
```

Compute the forces and moments for all components of the `VortexLatticeSystem`

in a specified reference axis system as a named argument.

The reference axis system is set to the geometry axes defined in the construction of the `VortexLatticeSystem`

by default.

`AeroFuse.VortexLattice.surface_forces`

— Method```
surface_forces(
system :: VortexLatticeSystem;
axes :: AbstractAxisSystem = Geometry()
)
```

Compute the forces for all components of the `VortexLatticeSystem`

in a specified reference axis system as a named argument.

The reference axis system is set to the geometry axes defined in the construction of the `VortexLatticeSystem`

by default.

`AeroFuse.VortexLattice.surface_moments`

— Method```
surface_moments(
system :: VortexLatticeSystem;
axes :: AbstractAxisSystem = Geometry()
)
```

Compute the moments for all components of the `VortexLatticeSystem`

in a specified reference axis system as a named argument.

The reference axis system is set to the geometry axes defined in the construction of the `VortexLatticeSystem`

by default.

`AeroFuse.VortexLattice.trailing_velocity`

— Method`trailing_velocity(r, hs :: Horseshoes, Γ, u_hat)`

Compute the induced velocity at a point $r$ from the semi-infinite trailing legs with constant strength $Γ$ of a given `Horseshoe`

`hs`

.

`AeroFuse.VortexLattice.transform`

— Method`transform(hs :: Horseshoe, T :: LinearMap)`

Generate a new `Horseshoe`

with the points and normal vectors transformed by the `LinearMap`

$T$.

`AeroFuse.VortexLattice.transform`

— Method`transform(ring :: VortexRing, T :: LinearMap)`

Generate a new `VortexRing`

with the points and normal vectors transformed by the `LinearMap`

$T$.

`AeroFuse.solve_linear`

— Method`solve_linear(horseshoes, normals, U, Ω)`

Evaluate and return the vortex strengths $Γ$s given an array of `Horseshoes`

, their associated normal vectors, the velocity vector $U$, and the quasi-steady rotation vector $Ω$.

`AeroFuse.surface_coefficients`

— Method```
surface_coefficients(
system :: VortexLatticeSystem;
axes :: AbstractAxisSystem = Geometry()
)
```

Compute the force and moment coefficients of the surfaces over all components in a given `VortexLatticeSystem`

, in a specified reference axis system as a named argument.

`VortexLatticeSystem`

by default.

`AeroFuse.surface_velocities`

— Method```
surface_velocities(
system :: VortexLatticeSystem;
axes :: AbstractAxisSystem = Geometry()
)
```

Compute the induced velocities for all components of the `VortexLatticeSystem`

in a specified reference axis system as a named argument.

`VortexLatticeSystem`

by default.

`AeroFuse.velocity`

— Function`velocity(r, hs :: Horseshoe, Γ, u_hat = [1.,0.,0.])`

Compute the induced velocity at a point $r$ of a given `Horseshoe`

with a bound leg of constant strength $Γ$ and semi-infinite trailing legs pointing in a given direction $û$, by default `û = x̂`

.

`AeroFuse.velocity`

— Function`velocity(r, ring :: VortexRing, Γ)`

Computes the velocity at a point $r$ induced by a `VortexRing`

with constant strength $Γ$.

`AeroFuse.velocity`

— Method`velocity(freestream :: Freestream, ::Geometry)`

Compute the velocity of Freestream in the geometry axis system.

`AeroFuse.AircraftGeometry.AbstractSpacing`

— TypeAn abstract type to define custom spacing distributions.

`AeroFuse.AircraftGeometry.Foil`

— Type```
Foil(x, y, name = "")
Foil(coordinates, name = "")
```

Structure consisting of foil coordinates in 2 dimensions with an optional name.

The coordinates should be provided in counter-clockwise format, viz. from the trailing edge of the upper surface to the trailing edge of the lower surface.

`AeroFuse.AircraftGeometry.HyperEllipseFuselage`

— Method`HyperEllipseFuselage(;`

Define a fuselage based on the following hyperelliptical-cylindrical parameterization.

Nose: Hyperellipse $z(ξ) = (1 - ξ^a)^{(1/a)}$

Cabin: Cylindrical $z(ξ) = 1$

Rear: Hyperellipse $z(ξ) = (1 - ξ^b)^{(1/b)}$

**Arguments**

`radius :: Real = 1.`

: Fuselage radius (m)`length :: Real = 6.`

: Fuselage length (m)`x_a :: Real = 1.`

: Location of front of cabin as a ratio of fuselage length ∈ [0,1]`x_b :: Real = 0.`

: Location of rear of cabin as a ratio of fuselage length ∈ [0,1]`c_nose :: Real = 0.`

: Curvature of nose in terms of hyperellipse parameter $a$`c_rear :: Real = 1.`

: Curvature of rear in terms of hyperellipse parameter $b$`d_nose :: Real = 1.`

: "Droop" or "rise" of nose from front of cabin centerline (m)`d_rear :: Real = 1.`

: "Droop" or "rise" of rear from rear of cabin centerline (m)`position :: Vector{Real} = zeros(3)`

: Position (m)`angle :: Real = 0.`

: Angle of rotation (degrees)`axis :: Vector{Real} = [0, 1 ,0]`

: Axis of rotation, y-axis by default`affine :: AffineMap = AffineMap(AngleAxis(deg2rad(angle), axis...), position)`

: Affine mapping for the position and orientation via`CoordinateTransformations.jl`

(overrides`angle`

and`axis`

if specified)

`AeroFuse.AircraftGeometry.Wing`

— Method```
Wing(
chords,
foils :: Vector{Foil},
twists,
spans,
dihedrals,
sweeps,
symmetry = false,
flip = false,
position = zeros(3),
angle = 0.,
axis = [0.,1.,0.],
)
```

Definition for a `Wing`

consisting of $N+1$ `Foil`

s, their associated chord lengths $c$ and twist angles $ι$, for $N$ sections with span lengths $b$, dihedrals $δ$ and leading-edge sweep angles $Λ_{LE}$, with all angles in degrees. Optionally, specify translation and a rotation in angle-axis representation for defining coordinates in a global axis system. Additionally, specify Boolean arguments for symmetry or reflecting in the $x$-$z$ plane.

**Arguments**

`chords :: Vector{Real}`

: Chord lengths (m)`foils :: Vector{Foil} = fill(naca4(0,0,1,2), length(chords))`

:`Foil`

shapes, default is NACA 0012.`spans :: Vector{Real} = ones(length(chords) - 1) / (length(chords) - 1)`

: Span lengths (m), default yields total span length 1.`dihedrals :: Vector{Real} = zero(spans)`

: Dihedral angles (deg), default is zero.`sweeps :: Vector{Real} = zero(spans)`

: Sweep angles (deg), default is zero.`w_sweep :: Real = 0.`

: Chord ratio for sweep angle e.g., 0 = Leading-edge sweep, 1 = Trailing-edge sweep, 0.25 = Quarter-chord sweep`symmetry :: Bool = false`

: Symmetric in the $x$-$z$ plane`flip :: Bool = false`

: Flip coordinates in the $x$-$z$ plane`position :: Vector{Real} = zeros(3)`

: Position (m)`angle :: Real = 0.`

: Angle of rotation (degrees)`axis :: Vector{Real} = [0.,1.,0.]`

: Axis of rotation`affine :: AffineMap = AffineMap(AngleAxis(deg2rad(angle), axis...), position)`

: Affine mapping for the position and orientation via`CoordinateTransformations.jl`

(overrides`angle`

and`axis`

if specified)

`AeroFuse.AircraftGeometry.WingMesh`

— Type```
WingMesh(
wing :: AbstractWing,
n_span :: Vector{Integer}, n_chord :: Integer;
span_spacing :: AbstractSpacing = symmetric_spacing(wing)
)
```

Define a container to generate meshes and panels for a given `Wing`

with a specified distribution of number of spanwise panels, and a number of chordwise panels.

Optionally a combination of `AbstractSpacing`

types (`Sine(), Cosine(), Uniform()`

) can be provided to the **named argument** `span_spacing`

, either as a singleton or as a vector with length equal to the number of spanwise sections. By default, the combination is `[Sine(), Cosine(), ..., Cosine()]`

.

For surface coordinates, the wing mesh will have (n*chord - 1) * 2 chordwise panels from TE-LE-TE and (n*span * 2) spanwise panels.

`AeroFuse.AircraftGeometry.WingSection`

— Method```
WingSection(;
area, aspect, taper
dihedral, sweep, w_sweep,
root_twist, tip_twist,
position, angle, axis,
symmetry, flip,
root_foil, tip_foil,
root_control, tip_control,
)
```

Define a `Wing`

in the $x$-$z$ plane, with optional Boolean arguments for symmetry and flipping in the plane.

**Arguments**

`area :: Real = 1.`

: Area (m²)`aspect :: Real = 6.`

: Aspect ratio`taper :: Real = 1.`

: Taper ratio of tip to root chord`dihedral :: Real = 1.`

: Dihedral angle (degrees)`sweep :: Real = 0.`

: Sweep angle (degrees)`w_sweep :: Real = 0.`

: Chord ratio for sweep angle e.g., 0 = Leading-edge sweep, 1 = Trailing-edge sweep, 0.25 = Quarter-chord sweep`root_twist :: Real = 0.`

: Twist angle at root (degrees)`tip_twist :: Real = 0.`

: Twist angle at tip (degrees)`root_foil :: Foil = naca4((0,0,1,2))`

:`Foil`

at root`tip_foil :: Foil = root_foil`

:`Foil`

at tip. Defaults to root foil.`root_control :: NTuple{2} = (0., 0.75)`

: (Angle, hinge ratio) for adding a control surface at the root.`tip_control :: NTuple{2} = root_control`

: (Angle, hinge ratio) for adding a control surface at the tip. Defaults to root control's settings.`symmetry :: Bool = false`

: Symmetric in the $x$-$z$ plane`flip :: Bool = false`

: Flip coordinates in the $x$-$z$ plane`position :: Vector{Real} = zeros(3)`

: Position (m)`angle :: Real = 0.`

: Angle of rotation (degrees)`axis :: Vector{Real} = [0.,1.,0.]`

: Axis of rotation`affine :: AffineMap = AffineMap(AngleAxis(deg2rad(angle), axis...), position)`

: Affine mapping for the position and orientation via`CoordinateTransformations.jl`

(overrides`angle`

and`axis`

if specified)

`AeroFuse.AircraftGeometry.affine`

— Method```
affine(
foil :: Foil,
angle, vector
)
```

Perform an affine transformation on the coordinates of a `Foil`

by a 2-dimensional vector $\mathbf v$ and angle $θ$.

`AeroFuse.AircraftGeometry.arc_length`

— Method`arc_length(foil :: Foil)`

Compute the arc-length of a `Foil`

.

`AeroFuse.AircraftGeometry.aspect_ratio`

— Method`aspect_ratio(wing :: AbstractWing)`

Compute the aspect ratio of an `AbstractWing`

.

`AeroFuse.AircraftGeometry.camber`

— Method`camber(foil :: Foil, x_by_c)`

Obtain the camber value of a `Foil`

at a specified $(x/c)$.

`AeroFuse.AircraftGeometry.camber_CST`

— Function```
camber_CST(α_c, α_t,
Δz :: Real,
n :: Integer = 40)
```

Define a cosine-spaced foil with $2n$ points using the Class Shape Transformation method on a Bernstein polynomial basis for the camber and thickness coordinates.

The foil is defined by arrays of coefficients $(α_c,~ α_t)$ for the upper and lower surfaces, trailing-edge spacing values $(Δz_u,~Δz_l)$, and a coefficient for the leading edge modifications at the nose.

`AeroFuse.AircraftGeometry.camber_coordinates`

— Function`camber_coordinates(wing :: WingMesh, n_span = wing.num_span, n_chord = wing.num_chord)`

Generate the camber coordinates of a `WingMesh`

with default spanwise $n_s$ and chordwise $n_c$ panel distributions from the mesh.

`AeroFuse.AircraftGeometry.camber_line`

— Function`camber_line(foil :: Foil, n :: Integer = 40)`

Get the camber line of a `Foil`

. Optionally specify the number of points for linear interpolation, default is 40.

`AeroFuse.AircraftGeometry.camber_panels`

— Method`camber_panels(wing_mesh :: WingMesh)`

Generate the camber mesh as a matrix of `Panel3D`

from a `WingMesh`

.

`AeroFuse.AircraftGeometry.camber_thickness`

— Function`camber_thickness(foil :: Foil, num :: Integer)`

Compute the camber-thickness distribution of a `Foil`

with cosine interpolation. Optionally specify the number of points for interpolation, default is 40.

`AeroFuse.AircraftGeometry.camber_thickness`

— Method`camber_thickness(wing :: Wing, num :: Integer)`

Compute the camber-thickness distribution at each spanwise intersection of a `Wing`

. A `num`

must be specified to interpolate the internal `Foil`

coordinates, which affects the accuracy of $(t/c)ₘₐₓ$ accordingly.

`AeroFuse.AircraftGeometry.camber_thickness_to_CST`

— Method`camber_thickness_to_CST(coords, num_dvs)`

Convert camber-thickness coordinates to a specified number of Bernstein polynomial coefficients under a Class Shape Transformation by performing a least-squares solution.

`AeroFuse.AircraftGeometry.chord_coordinates`

— Function`chord_coordinates(wing :: WingMesh, n_span = wing.num_span, n_chord = wing.num_chord)`

Generate the chord coordinates of a `WingMesh`

with default spanwise $n_s$ and chordwise $n_c$ panel distributions from the mesh.

`AeroFuse.AircraftGeometry.chord_panels`

— Method`chord_panels(wing_mesh :: WingMesh)`

Generate the chord mesh as a matrix of `Panel3D`

from a `WingMesh`

.

`AeroFuse.AircraftGeometry.control_surface`

— Method```
control_surface(foil :: Foil, δ, xc_hinge)
control_surface(foil :: Foil; angle, hinge)
```

Modify a `Foil`

to mimic a control surface by specifying a deflection angle $δ$`(in degrees, clockwise-positive convention) and a normalized hinge`

`x`

`-coordinate`

`∈ [0,1]`

`in terms of the chord length. A constructor with named arguments`

angle, hinge` is provided for convenience.

`AeroFuse.AircraftGeometry.coordinates`

— Function`wetted_area(fuse :: HyperEllipseFuselage, t)`

Get the coordinates of a `HyperEllipseFuselage`

given the parameter distribution $t$. Note that the distribution must have endpoints `0`

and `1`

.

`AeroFuse.AircraftGeometry.coordinates`

— Method`coordinates(foil :: Foil)`

Generate the array of `Foil`

coordinates.

`AeroFuse.AircraftGeometry.coordinates_to_CST`

— Method`coordinates_to_CST(coords, num_dvs)`

Convert coordinates to a specified number of Bernstein polynomial coefficients under a Class Shape Transformation by performing a least-squares solution.

`AeroFuse.AircraftGeometry.cosine_interpolation`

— Function`cosine_interpolation(foil :: Foil, n :: Integer = 40)`

Interpolate a `Foil`

profile's coordinates to a cosine by projecting the x-coordinates of a circle onto the geometry with $2n$ points.

`AeroFuse.AircraftGeometry.interpolate`

— Method`interpolate(foil :: Foil, xs)`

Linearly interpolate the coordinates of a `Foil`

to a given $x ∈ [0,1]$ distribution.

`AeroFuse.AircraftGeometry.kulfan_CST`

— Function```
kulfan_CST(alpha_u, alpha_l,
(Δz_u, Δz_l) = (0., 0.),
(LE_u, LE_l) = (0., 0.),
n = 40)
```

Define a cosine-spaced foil with $2n$ points using the Class Shape Transformation method on a Bernstein polynomial basis for the upper and lower coordinates.

The foil is defined by arrays of coefficients $(α_u,~ α_l)$ for the upper and lower surfaces (not necessarily of the same lengths), trailing-edge displacement values $(Δz_u,~ Δz_l)$, and coefficients for leading edge modifications on the upper and lower surfaces at the nose.

`AeroFuse.AircraftGeometry.leading_edge`

— Method`leading_edge(wing :: Wing)`

Compute the leading edge coordinates of a `Wing`

.

`AeroFuse.AircraftGeometry.leading_edge_index`

— Method`leading_edge_index(foil :: Foil)`

Get the index of the leading edge of a `Foil`

. This will be the index of the point with the minimum $x$-coordinate.

`AeroFuse.AircraftGeometry.lower_surface`

— Method`lower_surface(foil :: Foil)`

Get the lower surface coordinates of a `Foil`

from leading to trailing edge.

`AeroFuse.AircraftGeometry.maximum_thickness_to_chord`

— Function`maximum_thickness_to_chord(foil :: Foil, num :: Integer)`

Compute the maximum thickness-to-chord ratio $(t/c)ₘₐₓ$ and its location $(x/c)$ of a `Foil`

. Returned as the pair $(x/c, (t/c)ₘₐₓ)$.

A `num`

must be specified to interpolate the `Foil`

coordinates, which affects the accuracy of $(t/c)ₘₐₓ$ accordingly, default is 40.

`AeroFuse.AircraftGeometry.maximum_thickness_to_chord`

— Method`maximum_thickness_to_chord(wing :: Wing, num :: Integer)`

Compute the maximum thickness-to-chord ratios $(t/c)ₘₐₓ$ and their locations $(x/c)$ at each spanwise intersection of a `Wing`

.

Returns an array of pairs $[(x/c),(t/c)ₘₐₓ]$, in which the first entry of each pair is the location (normalized to the local chord length at the spanwise intersection) and the corresponding maximum thickness-to-chord ratio at the intersection.

A `num`

must be specified to interpolate the internal `Foil`

coordinates, which affects the accuracy of $(t/c)ₘₐₓ$ accordingly.

`AeroFuse.AircraftGeometry.mean_aerodynamic_center`

— Function```
mean_aerodynamic_center(wing :: Wing,
factor = 0.25;
symmetry = wing.symmetry,
flip = wing.flip
)
```

Compute the mean aerodynamic center of a `Wing`

. By default, the factor is assumed to be at 25% from the leading edge, which can be adjusted. Similarly, options are provided to account for symmetry or to flip the location in the $x$-$z$ plane.

`AeroFuse.AircraftGeometry.mean_aerodynamic_chord`

— Method`mean_aerodynamic_chord(wing :: Wing)`

Compute the mean aerodynamic chord of a `Wing`

.

`AeroFuse.AircraftGeometry.naca4`

— Function```
naca4(digits :: NTuple{4, <: Real}, n :: Integer = 40; sharp_TE :: Bool)
naca4(a, b, c, d, n :: Integer = 40; sharp_TE :: Bool)
```

Generate a `Foil`

of a NACA 4-digit series profile with the specified digits, number of points (40 by default), and a named option to specify a sharp or blunt trailing edge.

Refer to the formula for the digits here: `http://airfoiltools.com/airfoil/naca4digit`

`AeroFuse.AircraftGeometry.naca4_coordinates`

— Method`naca4_coordinates(digits :: NTuple{4, <: Real}, n :: Integer, sharp_TE :: Bool)`

Generate the coordinates of a NACA 4-digit series profile with a specified number of points, and a Boolean flag to specify a sharp or blunt trailing edge.

`AeroFuse.AircraftGeometry.projected_area`

— Method`projected_area(wing :: Wing)`

Compute the projected area (onto the spanwise plane) of a `Wing`

.

`AeroFuse.AircraftGeometry.properties`

— Method`properties(wing :: AbstractWing)`

Compute the generic properties of interest (span, area, etc.) of an `AbstractWing`

.

`AeroFuse.AircraftGeometry.read_foil`

— Method```
read_foil(
path :: String;
header = true;
name = ""
)
```

Generate a `Foil`

from a file consisting of 2D coordinates with named arguments to skip the header (first line of the file) or assign a name.

By default, the header is assumed to exist and should contain the airfoil name, which is assigned to the name of the `Foil`

.

`AeroFuse.AircraftGeometry.reflect`

— Method`reflect(foil :: Foil)`

Reflect the $y$-coordinates of a `Foil`

about the $y = 0$ line.

`AeroFuse.AircraftGeometry.rotate`

— Method```
rotate(foil :: Foil;
angle,
center = zeros(2)
)
```

Rotate the coordinates of a `Foil`

about a 2-dimensional point (default is origin) by the angle $θ$ (in degrees).

`AeroFuse.AircraftGeometry.scale`

— Method`scale(foil :: Foil, scale)`

Scale the coordinates of a `Foil`

to a scaling value.

`AeroFuse.AircraftGeometry.span`

— Method`span(wing :: Wing)`

Compute the planform span of a `Wing`

.

`AeroFuse.AircraftGeometry.split_surface`

— Method`split_surface(foil :: Foil)`

Split the `Foil`

coordinates into upper and lower surfaces.

`AeroFuse.AircraftGeometry.surface_coordinates`

— Function`surface_coordinates(wing :: WingMesh, n_span = wing.num_span, n_chord = wing.num_chord)`

Generate the surface coordinates of a `WingMesh`

with default spanwise $n_s$ and chordwise $n_c$ panel distributions from the mesh.

`AeroFuse.AircraftGeometry.surface_panels`

— Function```
surface_panels(
wing_mesh :: WingMesh,
n_s = wing_mesh.num_span,
n_c = length(first(foils(wing_mesh.surface))).x
)
```

Generate the surface panel distribution from a `WingMesh`

with the default spanwise $n_s$ panel distribution from the mesh and the chordwise panel $n_c$ distribution from the number of points defining the root airfoil.

In case of strange results, provide a higher number of chordwise panels to represent the airfoils more accurately

`AeroFuse.AircraftGeometry.sweeps`

— Function`sweeps(wing :: Wing, w = 0.)`

Obtain the sweep angles (in radians) at the corresponding normalized chord length ratio $w ∈ [0,1]$.

`AeroFuse.AircraftGeometry.taper_ratio`

— Method`taper_ratio(wing :: Wing)`

Compute the taper ratio of a `Wing`

, defined as the tip chord length divided by the root chord length, independent of the number of sections.

`AeroFuse.AircraftGeometry.thickness_line`

— Function`thickness_line(foil :: Foil, n :: Integer = 40)`

Get the thickness line of a `Foil`

. Optionally specify the number of points for linear interpolation, default is 40.

`AeroFuse.AircraftGeometry.trailing_edge`

— Method`trailing_edge(wing :: Wing)`

Compute the trailing edge coordinates of a `Wing`

.

`AeroFuse.AircraftGeometry.translate`

— Method`translate(foil :: Foil, vector)`

Translate the coordinates of a `Foil`

by a 2-dimensional vector $\mathbf v$.

`AeroFuse.AircraftGeometry.upper_surface`

— Method`upper_surface(foil :: Foil)`

Get the upper surface coordinates of a `Foil`

from leading to trailing edge.

`AeroFuse.AircraftGeometry.volume`

— Method`volume(fuse :: HyperEllipseFuselage, ts)`

Compute the volume of a `HyperEllipseFuselage`

given the parameter distribution $t$. Note that the distribution must have endpoints `0`

and `1`

.

`AeroFuse.AircraftGeometry.wetted_area_ratio`

— Function```
wetted_area_ratio(
wing_mesh :: WingMesh,
n_s = wing_mesh.num_span,
n_c = length(first(foils(wing_mesh.surface))).x
)
```

Determine the wetted area ratio $S_{wet}/S$ of a `WingMesh`

by calculating the ratio of the total area of the surface panels to the projected area of the `Wing`

.

The wetted area ratio should be slightly above 2 for thin airfoils.

`AeroFuse.PanelGeometry.make_panels`

— Method```
make_panels(foil :: Foil)
make_panels(foil :: Foil, n :: Integer)
```

Generate a vector of `Panel2D`

s from a `Foil`

, additionally with cosine interpolation using (approximately) $n$ points if provided.

`AeroFuse.PanelGeometry.wetted_area`

— Function```
wetted_area(
wing_mesh :: WingMesh,
n_s = wing_mesh.num_span,
n_c = length(first(foils(wing_mesh.surface))).x
)
```

Determine the wetted area $S_{wet}$ of a `WingMesh`

by calculating the total area of the surface panels.

`AeroFuse.PanelGeometry.wetted_area`

— Method`wetted_area(fuse :: HyperEllipseFuselage, t)`

Compute the wetted area of a `HyperEllipseFuselage`

given the parameter distribution $t$. Note that the distribution must have endpoints `0`

and `1`

.