Fuselage - Spline or Cubic bezier as cross sections geometry

[gabriel-ces]

Hello everyone,

Firstly I would like to thank all the team for this amazing tool and to provide it for free.

I am currently following an eVTOL aircraft tutorial and I am facing a challenge regarding the geometry definition and simulation of an eVTOL aircraft. Specifically, I am using one of the NASA UAM references, namely the Lift plus Cruise configuration. While I have successfully defined the wings and rotors of the aircraft, I am now faced with the task of defining the fuselage.

Typically, in the vsp3 file format, fuselage sections are defined using Cubic Bezier curves. However, I have not been able to find this option for defining cross sections. The only available method seems to be gt.conic_cross_section(Ps, CPs, rhos, ss). I am seeking assistance in this endeavor.
Please find attached the images of the obtained points for the cross section and the target cross section.

Is there a way to convert a geometry defined using Cubic Bezier curves to conic cross sections?
Maybe even read the cross section points from a .csv file?

Alternatively, I would be even more interested to know if there are ongoing efforts to streamline the generation of components such as the airframe, including the possibility of direct import from any of the OpenVSP files export formats.

For those, like me, who are trying to understand the conic cross section and its results, here is a code snippet that can be helpful in providing clarity:

# after defining Ps, CPs, rhos, ss and scaling
# using Plots 
points = gt.conic_cross_section(Ps, CPs, rhos, ss)
points = scaling*points
sections[1] = points;
scatter(Tuple.(sections[1]),size=(2600,1800),markersize=13,markercolor=:black,reuse=false)
Plots.title!("Section 1")
scalefontsizes()
scalefontsizes(5)
scatter!(Tuple.(Ps),size=(2600,1800),markersize=15,markercolor=:blue)
scatter!(Tuple.(CPs),size=(2600,1800),markersize=15,markercolor=:red)

Thank you for your help!

[EdoAlvarezR]

Hi Gabriel!

If you already have your Bezier curves, I would recommend just exporting them as points and using those points instead. Meaning, instead of using

points = gt.conic_cross_section(Ps, CPs, rhos, ss)

simply do

points = <----- here just give your points (read from a CSV file, etc)

[EdoAlvarezR]

Regarding OpenVSP capabilities, @cibinjoseph has been working on integrating OpenVSP into FLOWUnsteady for the last few months. More info to come! =]

[gabriel-ces]

Hello @EdoAlvarezR,

Absolutely! The recent upgrade, especially the enhanced functionality for importing geometries from OpenVSP, has made the process of adding geometries to FLOWUnsteady incredibly straightforward. Big thanks to @cibinjoseph for this valuable contribution!

For completeness of this discussion, I attempted to develop a script to retrieve points defined in a CSV file and correctly create an object that can be read in FLOWUnsteady. The code is presented below:

function transform_to_crosssections(input_tuple::Tuple{Float64, Vector{Vector{Float64}}}) :: Tuple{Float64, Matrix{Float64}}
    y, points = input_tuple
    matrix = transpose(hcat(points...))
    return y, matrix
end

function read_and_process_sections(csv_filename, bscale)
    # Construct the full path to the CSV file
    # Set the directory for reading files (two levels below the script)
    current_dir = @__DIR__
    full_path = joinpath(current_dir, "..", "data", csv_filename)
    println("data_directory: $full_path")
    
    if isfile(full_path)
        points = readdlm(full_path, ',', header=false, skipstart=1, Float64)
        # Rest of your code...
    else
        println("File not found: $full_path")
    end
    
    # Extract unique lsec values
    lsec_values = unique(points[:, 1])
    
    # Initialize a vector to store lsec and corresponding groups of points
    sections = Vector{Tuple{Float64, Matrix{Float64}}}()

    # Iterate over unique lsec values
    for lsec in lsec_values
        # Filter points based on the current lsec value
        current_group = points[points[:, 1] .== lsec, 2:3]
        
        # Convert the matrix to a vector of vectors
        current_group = [current_group[x, :] for x in 1:size(current_group, 1)]

        # Convert the current group to a cross-section
        current_section = transform_to_crosssections((lsec / bscale, current_group))

        # Append the tuple to the result vector
        push!(sections, current_section)
    end

    # Sort sections based on lsec values
    sort!(sections, by=x->x[1])

    # Accessing the results
    #println("Number of sections: $(length(sections))")
    #for (lsec, matrix) in sections
        #println("lsec: $lsec, Number of points in the group: $(size(matrix, 1))")
    #end
    
    return sections
end

"""
    Returns a loft of the LPC fuselage.
"""
function generate_fuselage_lpc(fuselage_length=9.13; verbose=true, v_lvl=0)
    # Example usage
    csv_filename = "LPC_vertices.csv"
    bscale = fuselage_length
    sections = read_and_process_sections(csv_filename, bscale)
    
    # Dummy parameters
    b_pos = [sec[1] for sec in sections]
    chords = (1 / bscale) * ones(size(b_pos))
    twists = zeros(size(b_pos))
    LE_x = zeros(size(b_pos))
    LE_z = zeros(size(b_pos))
    tilt_y = zeros(size(b_pos))
    
    # Generate fuselage grid
    grid_fuselage = gt.generate_loft(sections, bscale, b_pos, chords, twists, LE_x, LE_z;
                                    tilt_y=tilt_y, symmetric=false, loop_dim=0)

    # Aligns the grid with the x-axis
    rotation = gt.rotation_matrix2(0, 0, 90)
    gt.lintransform!(grid_fuselage, rotation, zeros(3))

    return grid_fuselage
end

The file that I was using:

LPC_vertices.csv

The resulting geometry was not okay because the connection of the points in the section follows an order that I still do not understand. Due to the functionality provided by OpenVSP, I have decided to discontinue the development of this code. However, this information might be helpful for someone not using OpenVSP.

[EdoAlvarezR]

Great! Thanks for sharing