RCAIDE.Library.Methods.Aerodynamics.Vortex_Lattice_Method.make_VLM_wings

make_VLM_wings

make_VLM_wings(geometry, settings)

This parses through geometry.wings to create a Container of Data objects.

Relevant VLM attributes are copied from geometry.wings to the Container. After, the wing data objects are reformatted. All control surfaces are also added to the Container as Data objects representing full wings. Helper variables are then computed (most notably span_breaks) for later.

see make_span_break() for further details

Assumptions: All control surfaces are appended directly to the wing, not wing segments. If a given wing has no segments, it must have either .taper or .chords.root

and .chords.tip defined

Source: None

Inputs: geometry.

wings.wing.

twists.root twists.tip dihedral sweeps.quarter_chord OR sweeps.leading_edge thickness_to_chord taper chord.root chords.tip

control_surface.

tag span_fraction_start span_fraction_end deflection chord_fraction

settings.discretize_control_surfaces –> set to True to generate control surface panels

Properties Used: N/A

copy_wings(original_wings)

This copies VLM attributes for every wing object in original_wings into a new wings container with new Data objects

Inputs: original_wings - the original wings container

copy_large_container(large_container, type_str)

This function helps avoid copying a container of large objects directly, especially if those objects are Physical_Components

Inputs: objects - a Container of large objects

copy_data_from_paths(old_object, paths)

This copies the attributes specified by ‘paths’ from old_object into a new Data() object

Inputs: old_object - an object to copy

recursive_set(data_obj, path, val)

This is similar to the deep_set function, but also creates intermediate Data() objects for keys that do not yet exist. Special copy cases are made for paths that lead to large class objects

get_paths(type_str)

This returns a list of the paths to the attributes needed in VLM for a given type of object.

Note that if any element in the paths array is the same as the array’s correponding type_str, this will cause copy_large_container() to recurse infinitely. It will also recurse infinitely if any element in the current array is the same as a type_str that corresponds to a different array which itself has an element that is the same as the current type_str.

Inputs: type_str - “wings”, “control_surfaces” or “Segments”

make_cs_wing_from_cs(cs, seg_a, seg_b, wing, cs_ID)

This uses a control surface and the segment it lies between to create an equilvalent wing object. The wing has a couple of non-standard attributes that contain information about the control surface it came from

Assumptions: None

Source: None

Inputs: cs - a control surface object seg_a - the segment object inboard of the cs seg_b - the segment object outboard of the cs. The cs is also attached to this wing - the wing object which owns seg_a and seg_b cs_ID - a unique identifier for the cs_wing

Outputs: cs_wing - a Data object with relevant Wing and Control_Surface attributes

Properties Used: N/A

convert_to_segmented_wing(wing)

This turns a non-segmented wing into a segmented wing

Assumptions: If a given wing has no segments, it must have either .taper or .chords.tip defined

Source: None

Inputs: VD - vortex distribution geometry.

wings.wing.

twists.root twists.tip dihedral sweeps.quarter_chord thickness_to_chord taper chord.root chords.tip

Properties Used: N/A

add_span_break(span_break, span_breaks)

This is a helper function that appends or superimposes a span_break into span_breaks

Assumptions: None

Source: None

Inputs: span_break span_breaks

Properties Used: N/A

reprocess_span_breaks(span_breaks)

This reprocesses the tags in a newly superimposed set of span_breaks and creates a new object so that the new keys match the new tags

Inputs: span_breaks

make_span_break_from_segment(seg)

This creates a span_break Data() object from a segment

Assumptions: None

Source: None

Inputs: seg - a segment object with standard attributes except for:

.chord

Properties Used: N/A

make_span_breaks_from_cs(cs, seg_a, seg_b, cs_wing, cs_ID)

This creates span_break Data() objects from a control surface, its owning segments, and their owning cs_wing

Assumptions: None

Source: None

Inputs: cs - a control surface object seg_a - the segment object inboard of the cs seg_b - the segment object outboard of the cs. The cs is also attached to this cs_wing - the wing object which owns seg_a and seg_b cs_ID - a unique identifier for the cs_wing

Properties Used: N/A

make_span_break(cs_ID, LE_TE, ib_ob, span_frac, chord_cut, airfoil, dihedral_ob, sweep_ob_QC, sweep_ob_LE, twist, local_chord, x_offset, dih_offset)

This gathers information related to a span break into one Data() object.

A span break is the spanwise location of a discontinuity in the discretization of the panels. These can be caused by segments and by the inboard and outboard edges of a control surface. The inboard and outboard sides of a span break can have different chords due to cuts made by control surfaces. Ultimately, the attributes of the span_breaks of the wing will provide the discretization function generate_wing_vortex_distribution() with the necessary values to make VLM panels as well as reshape those panels to make the control surface cuts dipicted below.

A diagram is given below:

nominal local chord

fuselage inboard LE | | . outboard LE <— | | .

| .

| . <– cut from a slat

| |

| |

| |

| |

| |

| |

| |

| . <– cut from a non-slat control surface with a different chord

cut from a non-slat control surface | | . fraction than the control surface on the inboard side

–> . | .

. | .

inboard TE . | . outboard TE

|_______________________|

there is 0 spanwise distance between inboard and outboard sides

Outputs: span_break

Properties Used: N/A

make_span_break_tag(span_break)