def _load_from_file(self, filename):
vsp.ClearVSPModel()
vsp.ReadVSPFile(filename)
for geom_id in vsp.FindGeoms():
geom_name_raw = vsp.GetGeomName(geom_id)
geom_name, geom_idx = regex_listname.findall(geom_name_raw)[0]
if geom_name not in self:
if geom_idx:
self[geom_name] = []
else:
self[geom_name] = VspElement()
if geom_idx != '':
geom = self._update_list(self[geom_name], geom_idx)
else:
geom = self[geom_name]
geom._id = geom_id
for param_id in vsp.GetGeomParmIDs(geom_id):
group_name_raw = vsp.GetParmDisplayGroupName(param_id)
group_name, group_idx = regex_listname.findall(
group_name_raw)[0]
if group_name not in EXCLUDE_GROUPS:
if group_name not in geom:
if group_idx:
geom[group_name] = []
else:
geom[group_name] = VspElement()
if group_idx != '':
geom[group_name], group = self._update_list(
geom[group_name], group_idx)
else:
group = geom[group_name]
param = self._make_parameter(param_id)
if param['name'] in group:
raise ValueError("{} already in <{}:{}>".format(
param.name, geom_name, group_name))
group[param['name']] = param
def vsp_read(tag, units_type='SI',specified_network=None):
"""This reads an OpenVSP vehicle geometry and writes it into a SUAVE vehicle format.
Includes wings, fuselages, and propellers.
Assumptions:
1. OpenVSP vehicle is composed of conventionally shaped fuselages, wings, and propellers.
1a. OpenVSP fuselage: generally narrow at nose and tail, wider in center).
1b. Fuselage is designed in VSP as it appears in real life. That is, the VSP model does not rely on
superficial elements such as canopies, stacks, or additional fuselages to cover up internal lofting oddities.
1c. This program will NOT account for multiple geometries comprising the fuselage. For example: a wingbox mounted beneath
is a separate geometry and will NOT be processed.
2. Fuselage origin is located at nose. VSP file origin can be located anywhere, preferably at the forward tip
of the vehicle or in front (to make all X-coordinates of vehicle positive).
3. Written for OpenVSP 3.21.1
Source:
N/A
Inputs:
1. A tag for an XML file in format .vsp3.
2. Units_type set to 'SI' (default) or 'Imperial'
3. User-specified network
Outputs:
Writes SUAVE vehicle with these geometries from VSP: (All values default to SI. Any other 2nd argument outputs Imperial.)
Wings.Wing. (* is all keys)
origin [m] in all three dimensions
spans.projected [m]
chords.root [m]
chords.tip [m]
aspect_ratio [-]
sweeps.quarter_chord [radians]
twists.root [radians]
twists.tip [radians]
thickness_to_chord [-]
dihedral [radians]
symmetric <boolean>
tag <string>
areas.reference [m^2]
areas.wetted [m^2]
Segments.
tag <string>
twist [radians]
percent_span_location [-] .1 is 10%
root_chord_percent [-] .1 is 10%
dihedral_outboard [radians]
sweeps.quarter_chord [radians]
thickness_to_chord [-]
airfoil <NACA 4-series, 6 series, or airfoil file>
Fuselages.Fuselage.
origin [m] in all three dimensions
width [m]
lengths.
total [m]
nose [m]
tail [m]
heights.
maximum [m]
at_quarter_length [m]
at_three_quarters_length [m]
effective_diameter [m]
fineness.nose [-] ratio of nose section length to fuselage effective diameter
fineness.tail [-] ratio of tail section length to fuselage effective diameter
areas.wetted [m^2]
tag <string>
segment[]. (segments are in ordered container and callable by number)
vsp.shape [point,circle,round_rect,general_fuse,fuse_file]
vsp.xsec_id <10 digit string>
percent_x_location
percent_z_location
height
width
length
effective_diameter
tag
vsp.xsec_num <integer of fuselage segment quantity>
vsp.xsec_surf_id <10 digit string>
Propellers.Propeller.
location[X,Y,Z] [radians]
rotation[X,Y,Z] [radians]
tip_radius [m]
hub_radius [m]
thrust_angle [radians]
Properties Used:
N/A
"""
vsp.ClearVSPModel()
vsp.ReadVSPFile(tag)
vsp_fuselages = []
vsp_wings = []
vsp_props = []
vsp_nacelles = []
vsp_nacelle_type = []
vsp_geoms = vsp.FindGeoms()
geom_names = []
vehicle = SUAVE.Vehicle()
vehicle.tag = tag
if units_type == 'SI':
units_type = 'SI'
elif units_type == 'inches':
units_type = 'inches'
else:
units_type = 'imperial'
# The two for-loops below are in anticipation of an OpenVSP API update with a call for GETGEOMTYPE.
# This print function allows user to enter VSP GeomID manually as first argument in vsp_read functions.
print("VSP geometry IDs: ")
# Label each geom type by storing its VSP geom ID.
for geom in vsp_geoms:
geom_name = vsp.GetGeomName(geom)
geom_names.append(geom_name)
print(str(geom_name) + ': ' + geom)
# --------------------------------
# AUTOMATIC VSP ENTRY & PROCESSING
# --------------------------------
for geom in vsp_geoms:
geom_name = vsp.GetGeomName(geom)
geom_type = vsp.GetGeomTypeName(str(geom))
if geom_type == 'Fuselage':
vsp_fuselages.append(geom)
if geom_type == 'Wing':
vsp_wings.append(geom)
if geom_type == 'Propeller':
vsp_props.append(geom)
if (geom_type == 'Stack') or (geom_type == 'BodyOfRevolution'):
vsp_nacelle_type.append(geom_type)
vsp_nacelles.append(geom)
# --------------------------------------------------
# Read Fuselages
# --------------------------------------------------
for fuselage_id in vsp_fuselages:
sym_planar = vsp.GetParmVal(fuselage_id, 'Sym_Planar_Flag', 'Sym') # Check for symmetry
sym_origin = vsp.GetParmVal(fuselage_id, 'Sym_Ancestor_Origin_Flag', 'Sym')
if sym_planar == 2. and sym_origin == 1.:
num_fus = 2
sym_flag = [1,-1]
else:
num_fus = 1
sym_flag = [1]
for fux_idx in range(num_fus): # loop through fuselages on aircraft
fuselage = read_vsp_fuselage(fuselage_id,fux_idx,sym_flag[fux_idx],units_type)
vehicle.append_component(fuselage)
# --------------------------------------------------
# Read Wings
# --------------------------------------------------
for wing_id in vsp_wings:
wing = read_vsp_wing(wing_id, units_type)
vehicle.append_component(wing)
# --------------------------------------------------
# Read Nacelles
# --------------------------------------------------
for nac_id, nacelle_id in enumerate(vsp_nacelles):
nacelle = read_vsp_nacelle(nacelle_id,vsp_nacelle_type[nac_id], units_type)
vehicle.append_component(nacelle)
# --------------------------------------------------
# Read Propellers/Rotors and assign to a network
# --------------------------------------------------
# Initialize rotor network elements
number_of_lift_rotor_engines = 0
number_of_propeller_engines = 0
lift_rotors = Data()
propellers = Data()
for prop_id in vsp_props:
prop = read_vsp_propeller(prop_id,units_type)
prop.tag = vsp.GetGeomName(prop_id)
if prop.orientation_euler_angles[1] >= 70 * Units.degrees:
lift_rotors.append(prop)
number_of_lift_rotor_engines += 1
else:
propellers.append(prop)
number_of_propeller_engines += 1
if specified_network == None:
# If no network specified, assign a network
if number_of_lift_rotor_engines>0 and number_of_propeller_engines>0:
net = Lift_Cruise()
else:
net = Battery_Propeller()
else:
net = specified_network
# Create the rotor network
if net.tag == "Lift_Cruise":
# Lift + Cruise network
for i in range(number_of_lift_rotor_engines):
net.lift_rotors.append(lift_rotors[list(lift_rotors.keys())[i]])
net.number_of_lift_rotor_engines = number_of_lift_rotor_engines
for i in range(number_of_propeller_engines):
net.propellers.append(propellers[list(propellers.keys())[i]])
net.number_of_propeller_engines = number_of_propeller_engines
elif net.tag == "Battery_Propeller":
# Append all rotors as propellers for the battery propeller network
for i in range(number_of_lift_rotor_engines):
# Accounts for multicopter configurations
net.propellers.append(lift_rotors[list(lift_rotors.keys())[i]])
for i in range(number_of_propeller_engines):
net.propellers.append(propellers[list(propellers.keys())[i]])
net.number_of_propeller_engines = number_of_lift_rotor_engines + number_of_propeller_engines
vehicle.networks.append(net)
return vehicle
def vsp_read_wing(wing_id, units_type='SI'):
"""This reads an OpenVSP wing vehicle geometry and writes it into a SUAVE wing format.
Assumptions:
1. OpenVSP wing is divided into segments ("XSecs" in VSP).
2. Written for OpenVSP 3.21.1
Source:
N/A
Inputs:
0. Pre-loaded VSP vehicle in memory, via vsp_read.
1. VSP 10-digit geom ID for wing.
2. units_type set to 'SI' (default) or 'Imperial'.
Outputs:
Writes SUAVE wing object, with these geometries, from VSP:
Wings.Wing. (* is all keys)
origin [m] in all three dimensions
spans.projected [m]
chords.root [m]
chords.tip [m]
aspect_ratio [-]
sweeps.quarter_chord [radians]
twists.root [radians]
twists.tip [radians]
thickness_to_chord [-]
dihedral [radians]
symmetric <boolean>
tag <string>
areas.exposed [m^2]
areas.reference [m^2]
areas.wetted [m^2]
Segments.
tag <string>
twist [radians]
percent_span_location [-] .1 is 10%
root_chord_percent [-] .1 is 10%
dihedral_outboard [radians]
sweeps.quarter_chord [radians]
thickness_to_chord [-]
airfoil <NACA 4-series, 6 series, or airfoil file>
Properties Used:
N/A
"""
# Check if this is vertical tail, this seems like a weird first step but it's necessary
# Get the initial rotation to get the dihedral angles
x_rot = vsp.GetParmVal(wing_id, 'X_Rotation', 'XForm')
if x_rot >= 70:
wing = SUAVE.Components.Wings.Vertical_Tail()
wing.vertical = True
x_rot = (90 - x_rot) * Units.deg
else:
# Instantiate a wing
wing = SUAVE.Components.Wings.Wing()
# Set the units
if units_type == 'SI':
units_factor = Units.meter * 1.
else:
units_factor = Units.foot * 1.
# Apply a tag to the wing
if vsp.GetGeomName(wing_id):
tag = vsp.GetGeomName(wing_id)
tag = tag.translate(t_table)
wing.tag = tag
else:
wing.tag = 'winggeom'
# Top level wing parameters
# Wing origin
wing.origin[0][0] = vsp.GetParmVal(wing_id, 'X_Location',
'XForm') * units_factor
wing.origin[0][1] = vsp.GetParmVal(wing_id, 'Y_Location',
'XForm') * units_factor
wing.origin[0][2] = vsp.GetParmVal(wing_id, 'Z_Location',
'XForm') * units_factor
# Wing Symmetry
sym_planar = vsp.GetParmVal(wing_id, 'Sym_Planar_Flag', 'Sym')
sym_origin = vsp.GetParmVal(wing_id, 'Sym_Ancestor', 'Sym')
# Check for symmetry
if sym_planar == 2. and sym_origin == 1.: #origin at wing, not vehicle
wing.symmetric = True
else:
wing.symmetric = False
#More top level parameters
total_proj_span = vsp.GetParmVal(wing_id, 'TotalProjectedSpan',
'WingGeom') * units_factor
wing.aspect_ratio = vsp.GetParmVal(wing_id, 'TotalAR', 'WingGeom')
wing.areas.reference = vsp.GetParmVal(wing_id, 'TotalArea',
'WingGeom') * units_factor**2
wing.spans.projected = total_proj_span
# Check if this is a single segment wing
xsec_surf_id = vsp.GetXSecSurf(wing_id,
0) # This is how VSP stores surfaces.
x_sec_1 = vsp.GetXSec(xsec_surf_id, 1)
x_sec_1_span_parm = vsp.GetXSecParm(x_sec_1, 'Span')
x_sec_1_span = vsp.GetParmVal(x_sec_1_span_parm) * (
1 + wing.symmetric) * units_factor
if x_sec_1_span == wing.spans.projected:
single_seg = True
else:
single_seg = False
segment_num = vsp.GetNumXSec(
xsec_surf_id
) # Get number of wing segments (is one more than the VSP GUI shows).
x_sec = vsp.GetXSec(xsec_surf_id, 0)
chord_parm = vsp.GetXSecParm(x_sec, 'Root_Chord')
total_chord = vsp.GetParmVal(chord_parm)
span_sum = 0. # Non-projected.
proj_span_sum = 0. # Projected.
segment_spans = [None] * (segment_num) # Non-projected.
segment_dihedral = [None] * (segment_num)
segment_sweeps_quarter_chord = [None] * (segment_num)
# Check for wing segment *inside* fuselage, then skip XSec_0 to start at first exposed segment.
if total_chord == 1.:
start = 1
xsec_surf_id = vsp.GetXSecSurf(wing_id, 1)
x_sec = vsp.GetXSec(xsec_surf_id, 0)
chord_parm = vsp.GetXSecParm(x_sec, 'Tip_Chord')
root_chord = vsp.GetParmVal(chord_parm) * units_factor
else:
start = 0
root_chord = total_chord * units_factor
# -------------
# Wing segments
# -------------
if single_seg == False:
# Convert VSP XSecs to SUAVE segments. (Wing segments are defined by outboard sections in VSP, but inboard sections in SUAVE.)
for i in range(start, segment_num + 1):
segment = SUAVE.Components.Wings.Segment()
segment.tag = 'Section_' + str(i)
thick_cord = vsp.GetParmVal(wing_id, 'ThickChord',
'XSecCurve_' + str(i - 1))
segment.thickness_to_chord = thick_cord # Thick_cord stored for use in airfoil, below.
segment_root_chord = vsp.GetParmVal(
wing_id, 'Root_Chord', 'XSec_' + str(i)) * units_factor
segment.root_chord_percent = segment_root_chord / root_chord
segment.percent_span_location = proj_span_sum / (total_proj_span /
2)
segment.twist = vsp.GetParmVal(wing_id, 'Twist',
'XSec_' + str(i - 1)) * Units.deg
if i == start:
wing.thickness_to_chord = thick_cord
if i < segment_num: # This excludes the tip xsec, but we need a segment in SUAVE to store airfoil.
sweep = vsp.GetParmVal(wing_id, 'Sweep',
'XSec_' + str(i)) * Units.deg
sweep_loc = vsp.GetParmVal(wing_id, 'Sweep_Location',
'XSec_' + str(i))
AR = vsp.GetParmVal(wing_id, 'Aspect', 'XSec_' + str(i))
taper = vsp.GetParmVal(wing_id, 'Taper', 'XSec_' + str(i))
segment_sweeps_quarter_chord[i] = convert_sweep(
sweep, sweep_loc, 0.25, AR, taper)
segment.sweeps.quarter_chord = segment_sweeps_quarter_chord[
i] # Used again, below
# Used for dihedral computation, below.
segment_dihedral[i] = vsp.GetParmVal(
wing_id, 'Dihedral', 'XSec_' + str(i)) * Units.deg + x_rot
segment.dihedral_outboard = segment_dihedral[i]
segment_spans[i] = vsp.GetParmVal(
wing_id, 'Span', 'XSec_' + str(i)) * units_factor
proj_span_sum += segment_spans[i] * np.cos(segment_dihedral[i])
span_sum += segment_spans[i]
else:
segment.root_chord_percent = (vsp.GetParmVal(
wing_id, 'Tip_Chord',
'XSec_' + str(i - 1))) * units_factor / total_chord
# XSec airfoil
jj = i - 1 # Airfoil index i-1 because VSP airfoils and sections are one index off relative to SUAVE.
xsec_id = str(vsp.GetXSec(xsec_surf_id, jj))
airfoil = Airfoil()
if vsp.GetXSecShape(
xsec_id
) == vsp.XS_FOUR_SERIES: # XSec shape: NACA 4-series
camber = vsp.GetParmVal(wing_id, 'Camber',
'XSecCurve_' + str(jj))
if camber == 0.:
camber_loc = 0.
else:
camber_loc = vsp.GetParmVal(wing_id, 'CamberLoc',
'XSecCurve_' + str(jj))
airfoil.thickness_to_chord = thick_cord
camber_round = int(np.around(camber * 100))
camber_loc_round = int(np.around(camber_loc * 10))
thick_cord_round = int(np.around(thick_cord * 100))
airfoil.tag = 'NACA ' + str(camber_round) + str(
camber_loc_round) + str(thick_cord_round)
elif vsp.GetXSecShape(
xsec_id) == vsp.XS_SIX_SERIES: # XSec shape: NACA 6-series
thick_cord_round = int(np.around(thick_cord * 100))
a_value = vsp.GetParmVal(wing_id, 'A', 'XSecCurve_' + str(jj))
ideal_CL = int(
np.around(
vsp.GetParmVal(wing_id, 'IdealCl',
'XSecCurve_' + str(jj)) * 10))
series_vsp = int(
vsp.GetParmVal(wing_id, 'Series', 'XSecCurve_' + str(jj)))
series_dict = {
0: '63',
1: '64',
2: '65',
3: '66',
4: '67',
5: '63A',
6: '64A',
7: '65A'
} # VSP series values.
series = series_dict[series_vsp]
airfoil.tag = 'NACA ' + series + str(ideal_CL) + str(
thick_cord_round) + ' a=' + str(np.around(a_value, 1))
elif vsp.GetXSecShape(
xsec_id
) == vsp.XS_FILE_AIRFOIL: # XSec shape: 12 is type AF_FILE
airfoil.thickness_to_chord = thick_cord
airfoil.points = vsp.GetAirfoilCoordinates(
wing_id, float(jj / segment_num))
# VSP airfoil API calls get coordinates and write files with the final argument being the fraction of segment position, regardless of relative spans.
# (Write the root airfoil with final arg = 0. Write 4th airfoil of 5 segments with final arg = .8)
vsp.WriteSeligAirfoil(
str(wing.tag) + '_airfoil_XSec_' + str(jj) + '.dat',
wing_id, float(jj / segment_num))
airfoil.coordinate_file = 'str(wing.tag)' + '_airfoil_XSec_' + str(
jj) + '.dat'
airfoil.tag = 'AF_file'
segment.append_airfoil(airfoil)
wing.Segments.append(segment)
# Wing dihedral
proj_span_sum_alt = 0.
span_sum_alt = 0.
sweeps_sum = 0.
for ii in range(start, segment_num):
span_sum_alt += segment_spans[ii]
proj_span_sum_alt += segment_spans[ii] * np.cos(
segment_dihedral[ii]
) # Use projected span to find total wing dihedral.
sweeps_sum += segment_spans[ii] * np.tan(
segment_sweeps_quarter_chord[ii])
wing.dihedral = np.arccos(proj_span_sum_alt / span_sum_alt)
wing.sweeps.quarter_chord = -np.arctan(
sweeps_sum / span_sum_alt) # Minus sign makes it positive sweep.
# Add a tip segment, all values are zero except the tip chord
tc = vsp.GetParmVal(wing_id, 'Tip_Chord',
'XSec_' + str(segment_num - 1)) * units_factor
segment = SUAVE.Components.Wings.Segment()
segment.percent_span_location = 1.0
segment.root_chord_percent = tc / root_chord
# Chords
wing.chords.root = vsp.GetParmVal(wing_id, 'Tip_Chord',
'XSec_0') * units_factor
wing.chords.tip = tc
wing.chords.mean_geometric = wing.areas.reference / wing.spans.projected
# Just double calculate and fix things:
wing = wing_segmented_planform(wing)
else:
# Single segment
# Get ID's
x_sec_1_dih_parm = vsp.GetXSecParm(x_sec_1, 'Dihedral')
x_sec_1_sweep_parm = vsp.GetXSecParm(x_sec_1, 'Sweep')
x_sec_1_sweep_loc_parm = vsp.GetXSecParm(x_sec_1, 'Sweep_Location')
x_sec_1_taper_parm = vsp.GetXSecParm(x_sec_1, 'Taper')
x_sec_1_rc_parm = vsp.GetXSecParm(x_sec_1, 'Root_Chord')
x_sec_1_tc_parm = vsp.GetXSecParm(x_sec_1, 'Tip_Chord')
# Calcs
sweep = vsp.GetParmVal(x_sec_1_sweep_parm) * Units.deg
sweep_loc = vsp.GetParmVal(x_sec_1_sweep_loc_parm)
taper = vsp.GetParmVal(x_sec_1_taper_parm)
c_4_sweep = convert_sweep(sweep, sweep_loc, 0.25, wing.aspect_ratio,
taper)
# Pull and pack
wing.sweeps.quarter_chord = c_4_sweep
wing.taper = taper
wing.dihedral = vsp.GetParmVal(x_sec_1_dih_parm) * Units.deg + x_rot
wing.chords.root = vsp.GetParmVal(x_sec_1_rc_parm) * units_factor
wing.chords.tip = vsp.GetParmVal(x_sec_1_tc_parm) * units_factor
wing.chords.mean_geometric = wing.areas.reference / wing.spans.projected
# Just double calculate and fix things:
wing = wing_planform(wing)
# Twists
wing.twists.root = vsp.GetParmVal(wing_id, 'Twist', 'XSec_0') * Units.deg
wing.twists.tip = vsp.GetParmVal(
wing_id, 'Twist', 'XSec_' + str(segment_num - 1)) * Units.deg
return wing
def vsp_read_fuselage(fuselage_id, units_type='SI', fineness=True):
"""This reads an OpenVSP fuselage geometry and writes it to a SUAVE fuselage format.
Assumptions:
1. OpenVSP fuselage is "conventionally shaped" (generally narrow at nose and tail, wider in center).
2. Fuselage is designed in VSP as it appears in real life. That is, the VSP model does not rely on
superficial elements such as canopies, stacks, or additional fuselages to cover up internal lofting oddities.
3. This program will NOT account for multiple geometries comprising the fuselage. For example: a wingbox mounted beneath
is a separate geometry and will NOT be processed.
4. Fuselage origin is located at nose. VSP file origin can be located anywhere, preferably at the forward tip
of the vehicle or in front (to make all X-coordinates of vehicle positive).
5. Written for OpenVSP 3.16.1
Source:
N/A
Inputs:
0. Pre-loaded VSP vehicle in memory, via vsp_read.
1. VSP 10-digit geom ID for fuselage.
2. Units_type set to 'SI' (default) or 'Imperial'.
3. Boolean for whether or not to compute fuselage finenesses (default = True).
4. Uses exterior function get_vsp_areas, in SUAVE/trunk/SUAVE/Input_Output/OpenVSP.
Outputs:
Writes SUAVE fuselage, with these geometries: (all defaults are SI, but user may specify Imperial)
Fuselages.Fuselage.
origin [m] in all three dimensions
width [m]
lengths.
total [m]
nose [m]
tail [m]
heights.
maximum [m]
at_quarter_length [m]
at_three_quarters_length [m]
effective_diameter [m]
fineness.nose [-] ratio of nose section length to fuselage effective diameter
fineness.tail [-] ratio of tail section length to fuselage effective diameter
areas.wetted [m^2]
tag <string>
segment[]. (segments are in ordered container and callable by number)
vsp.shape [point,circle,round_rect,general_fuse,fuse_file]
vsp.xsec_id <10 digit string>
percent_x_location
percent_z_location
height
width
length
effective_diameter
tag
vsp.xsec_num <integer of fuselage segment quantity>
vsp.xsec_surf_id <10 digit string>
Properties Used:
N/A
"""
fuselage = SUAVE.Components.Fuselages.Fuselage()
if units_type == 'SI':
units_factor = Units.meter * 1.
else:
units_factor = Units.foot * 1.
if vsp.GetGeomName(fuselage_id):
fuselage.tag = vsp.GetGeomName(fuselage_id)
else:
fuselage.tag = 'FuselageGeom'
fuselage.origin[0][0] = vsp.GetParmVal(fuselage_id, 'X_Location',
'XForm') * units_factor
fuselage.origin[0][1] = vsp.GetParmVal(fuselage_id, 'Y_Location',
'XForm') * units_factor
fuselage.origin[0][2] = vsp.GetParmVal(fuselage_id, 'Z_Location',
'XForm') * units_factor
fuselage.lengths.total = vsp.GetParmVal(fuselage_id, 'Length',
'Design') * units_factor
fuselage.vsp_data.xsec_surf_id = vsp.GetXSecSurf(
fuselage_id, 0) # There is only one XSecSurf in geom.
fuselage.vsp_data.xsec_num = vsp.GetNumXSec(
fuselage.vsp_data.xsec_surf_id) # Number of xsecs in fuselage.
x_locs = []
heights = []
widths = []
eff_diams = []
lengths = []
# -----------------
# Fuselage segments
# -----------------
for ii in range(0, fuselage.vsp_data.xsec_num):
segment = SUAVE.Components.Fuselages.Segment()
segment.vsp_data.xsec_id = vsp.GetXSec(fuselage.vsp_data.xsec_surf_id,
ii) # VSP XSec ID.
segment.tag = 'segment_' + str(ii)
segment.percent_x_location = vsp.GetParmVal(
fuselage_id, 'XLocPercent',
'XSec_' + str(ii)) # Along fuselage length.
segment.percent_z_location = vsp.GetParmVal(
fuselage_id, 'ZLocPercent',
'XSec_' + str(ii)) # Vertical deviation of fuselage center.
segment.height = vsp.GetXSecHeight(
segment.vsp_data.xsec_id) * units_factor
segment.width = vsp.GetXSecWidth(
segment.vsp_data.xsec_id) * units_factor
segment.effective_diameter = (segment.height + segment.width) / 2.
x_locs.append(segment.percent_x_location
) # Save into arrays for later computation.
heights.append(segment.height)
widths.append(segment.width)
eff_diams.append(segment.effective_diameter)
if ii != (
fuselage.vsp_data.xsec_num - 1
): # Segment length: stored as length since previous segment. (First segment will have length 0.0.)
segment.length = fuselage.lengths.total * (
fuselage.Segments[ii + 1].percent_x_location -
segment.percent_x_location) * units_factor
else:
segment.length = 0.0
lengths.append(segment.length)
shape = vsp.GetXSecShape(segment.vsp_data.xsec_id)
shape_dict = {
0: 'point',
1: 'circle',
2: 'ellipse',
3: 'super ellipse',
4: 'rounded rectangle',
5: 'general fuse',
6: 'fuse file'
}
segment.vsp_data.shape = shape_dict[shape]
fuselage.Segments.append(segment)
fuselage.heights.at_quarter_length = get_fuselage_height(
fuselage, .25) # Calls get_fuselage_height function (below).
fuselage.heights.at_three_quarters_length = get_fuselage_height(
fuselage, .75)
fuselage.heights.at_wing_root_quarter_chord = get_fuselage_height(
fuselage, .4)
fuselage.heights.maximum = max(heights) # Max segment height.
fuselage.width = max(widths) # Max segment width.
fuselage.effective_diameter = max(eff_diams) # Max segment effective diam.
fuselage.areas.front_projected = np.pi * (
(fuselage.effective_diameter) / 2)**2
eff_diam_gradients_fwd = np.array(eff_diams[1:]) - np.array(
eff_diams[:-1]) # Compute gradients of segment effective diameters.
eff_diam_gradients_fwd = np.multiply(eff_diam_gradients_fwd, lengths[:-1])
fuselage = compute_fuselage_fineness(fuselage, x_locs, eff_diams,
eff_diam_gradients_fwd)
return fuselage
def set_sources(geometry):
"""This sets meshing sources in a way similar to the OpenVSP default. Some source values can
also be optionally specified as below.
Assumptions:
None
Source:
https://github.com/OpenVSP/OpenVSP (with some modifications)
Inputs:
geometry.
wings.*. (passed to add_segment_sources())
tag <string>
Segments.*.percent_span_location [-] (.1 is 10%)
Segments.*.root_chord_percent [-] (.1 is 10%)
chords.root [m]
chords.tip [m]
vsp_mesh (optional) - This holds settings that are used in add_segment_sources
fuselages.*.
tag <string>
vsp_mesh. (optional)
length [m]
radius [m]
lengths.total (only used if vsp_mesh is not defined for the fuselage)
Outputs:
<tag>.stl
Properties Used:
N/A
"""
# Extract information on geometry type (for some reason it seems VSP doesn't have a simple
# way to do this)
comp_type_dict = dict()
comp_dict = dict()
for wing in geometry.wings:
comp_type_dict[wing.tag] = 'wing'
comp_dict[wing.tag] = wing
for fuselage in geometry.fuselages:
comp_type_dict[fuselage.tag] = 'fuselage'
comp_dict[fuselage.tag] = fuselage
# network sources have not been implemented
#for network in geometry.networks:
#comp_type_dict[network.tag] = 'turbojet'
#comp_dict[network.tag] = network
components = vsp.FindGeoms()
# The default source values are (mostly) based on the OpenVSP scripts, wing for example:
# https://github.com/OpenVSP/OpenVSP/blob/a5ac5302b320e8e318830663bb50ba0d4f2d6f64/src/geom_core/WingGeom.cpp
for comp in components:
comp_name = vsp.GetGeomName(comp)
if comp_name not in comp_dict:
continue
comp_type = comp_type_dict[comp_name]
# Nacelle sources are not implemented
#if comp_name[0:8] == 'turbofan':
#comp_type = comp_type_dict[comp_name[0:8]]
#else:
#comp_type = comp_type_dict[comp_name]
if comp_type == 'wing':
wing = comp_dict[comp_name]
if len(wing.Segments) == 0: # check if segments exist
num_secs = 1
use_base = True
else:
if wing.Segments[
0].percent_span_location == 0.: # check if first segment starts at the root
num_secs = len(wing.Segments)
use_base = False
else:
num_secs = len(wing.Segments) + 1
use_base = True
u_start = 0.
base_root = wing.chords.root
base_tip = wing.chords.tip
for ii in range(0, num_secs):
if (ii == 0) and (use_base
== True): # create sources on root segment
cr = base_root
if len(wing.Segments) > 0:
ct = base_root * wing.Segments[0].root_chord_percent
seg = wing.Segments[ii]
else:
if 'vsp_mesh' in wing:
custom_flag = True
else:
custom_flag = False
ct = base_tip
seg = wing
# extract CFD source parameters
if len(wing.Segments) == 0:
wingtip_flag = True
else:
wingtip_flag = False
add_segment_sources(comp, cr, ct, ii, u_start, num_secs,
custom_flag, wingtip_flag, seg)
elif (ii == 0) and (use_base == False):
cr = base_root * wing.Segments[0].root_chord_percent
if num_secs > 1:
ct = base_root * wing.Segments[1].root_chord_percent
else:
ct = base_tip
# extract CFD source parameters
seg = wing.Segments[ii]
if 'vsp_mesh' in wing.Segments[ii]:
custom_flag = True
else:
custom_flag = False
wingtip_flag = False
add_segment_sources(comp, cr, ct, ii, u_start, num_secs,
custom_flag, wingtip_flag, seg)
elif ii < num_secs - 1:
if use_base == True:
jj = 1
else:
jj = 0
cr = base_root * wing.Segments[ii - jj].root_chord_percent
ct = base_root * wing.Segments[ii + 1 -
jj].root_chord_percent
seg = wing.Segments[ii - jj]
if 'vsp_mesh' in wing.Segments[ii - jj]:
custom_flag = True
else:
custom_flag = False
wingtip_flag = False
add_segment_sources(comp, cr, ct, ii, u_start, num_secs,
custom_flag, wingtip_flag, seg)
else:
if use_base == True:
jj = 1
else:
jj = 0
cr = base_root * wing.Segments[ii - jj].root_chord_percent
ct = base_tip
seg = wing.Segments[ii - jj]
if 'vsp_mesh' in wing.Segments[ii - jj]:
custom_flag = True
else:
custom_flag = False
wingtip_flag = True
add_segment_sources(comp, cr, ct, ii, u_start, num_secs,
custom_flag, wingtip_flag, seg)
pass
elif comp_type == 'fuselage':
fuselage = comp_dict[comp_name]
if 'vsp_mesh' in fuselage:
len1 = fuselage.vsp_mesh.length
rad1 = fuselage.vsp_mesh.radius
else:
len1 = 0.1 * 0.5 # not sure where VSP is getting this value
rad1 = 0.2 * fuselage.lengths.total
uloc = 0.0
wloc = 0.0
vsp.AddCFDSource(vsp.POINT_SOURCE, comp, 0, len1, rad1, uloc, wloc)
uloc = 1.0
vsp.AddCFDSource(vsp.POINT_SOURCE, comp, 0, len1, rad1, uloc, wloc)
pass
def vsp_read(tag, units_type='SI'):
"""This reads an OpenVSP vehicle geometry and writes it into a SUAVE vehicle format.
Includes wings, fuselages, and propellers.
Assumptions:
1. OpenVSP vehicle is composed of conventionally shaped fuselages, wings, and propellers.
1a. OpenVSP fuselage: generally narrow at nose and tail, wider in center).
1b. Fuselage is designed in VSP as it appears in real life. That is, the VSP model does not rely on
superficial elements such as canopies, stacks, or additional fuselages to cover up internal lofting oddities.
1c. This program will NOT account for multiple geometries comprising the fuselage. For example: a wingbox mounted beneath
is a separate geometry and will NOT be processed.
2. Fuselage origin is located at nose. VSP file origin can be located anywhere, preferably at the forward tip
of the vehicle or in front (to make all X-coordinates of vehicle positive).
3. Written for OpenVSP 3.16.1
Source:
N/A
Inputs:
1. A tag for an XML file in format .vsp3.
2. Units_type set to 'SI' (default) or 'Imperial'
Outputs:
Writes SUAVE vehicle with these geometries from VSP: (All values default to SI. Any other 2nd argument outputs Imperial.)
Wings.Wing. (* is all keys)
origin [m] in all three dimensions
spans.projected [m]
chords.root [m]
chords.tip [m]
aspect_ratio [-]
sweeps.quarter_chord [radians]
twists.root [radians]
twists.tip [radians]
thickness_to_chord [-]
dihedral [radians]
symmetric <boolean>
tag <string>
areas.exposed [m^2]
areas.reference [m^2]
areas.wetted [m^2]
Segments.
tag <string>
twist [radians]
percent_span_location [-] .1 is 10%
root_chord_percent [-] .1 is 10%
dihedral_outboard [radians]
sweeps.quarter_chord [radians]
thickness_to_chord [-]
airfoil <NACA 4-series, 6 series, or airfoil file>
Fuselages.Fuselage.
origin [m] in all three dimensions
width [m]
lengths.
total [m]
nose [m]
tail [m]
heights.
maximum [m]
at_quarter_length [m]
at_three_quarters_length [m]
effective_diameter [m]
fineness.nose [-] ratio of nose section length to fuselage effective diameter
fineness.tail [-] ratio of tail section length to fuselage effective diameter
areas.wetted [m^2]
tag <string>
segment[]. (segments are in ordered container and callable by number)
vsp.shape [point,circle,round_rect,general_fuse,fuse_file]
vsp.xsec_id <10 digit string>
percent_x_location
percent_z_location
height
width
length
effective_diameter
tag
vsp.xsec_num <integer of fuselage segment quantity>
vsp.xsec_surf_id <10 digit string>
Propellers.Propeller.
location[X,Y,Z] [radians]
rotation[X,Y,Z] [radians]
tip_radius [m]
hub_radius [m]
thrust_angle [radians]
Properties Used:
N/A
"""
vsp.ClearVSPModel()
vsp.ReadVSPFile(tag)
vsp_fuselages = []
vsp_wings = []
vsp_props = []
vsp_geoms = vsp.FindGeoms()
geom_names = []
vehicle = SUAVE.Vehicle()
vehicle.tag = tag
if units_type == 'SI':
units_type = 'SI'
else:
units_type = 'Imperial'
# The two for-loops below are in anticipation of an OpenVSP API update with a call for GETGEOMTYPE.
# This print function allows user to enter VSP GeomID manually as first argument in vsp_read functions.
print("VSP geometry IDs: ")
# Label each geom type by storing its VSP geom ID. (The API call for GETGEOMTYPE was not released as of 8/9/18, v 3.16.1)
for geom in vsp_geoms:
geom_name = vsp.GetGeomName(geom)
geom_names.append(geom_name)
print(str(geom_name) + ': ' + geom)
# -----------------------------
# MANUAL VSP ENTRY & PROCESSING
# -----------------------------
#fuselage = read_vsp_fuselage(fuselage_id, units_type=units_type) # Replace fuselage_id manually.
#vehicle.append_component(fuselage)
#wing = read_vsp_wing(wing_id, units_type=units_type) # Replace wing_id manually.
#vehicle.append_component(wing)
#prop = read_vsp_prop(prop_id, units_type=units_type) # Replace prop_id manually.
#vehicle.append_component(prop)
# --------------------------------
# AUTOMATIC VSP ENTRY & PROCESSING
# --------------------------------
#for geom in vsp_geoms:
#if vsp.GETGEOMTYPE(str(geom)) == 'FUSELAGE':
#vsp_fuselages.append(geom)
#if vsp.GETGEOMTYPE(str(geom)) == 'WING':
#vsp_wings.append(geom)
#if vsp.GETGEOMTYPE(str(geom)) == 'PROP':
#vsp_props.append(geom)
# Read VSP geoms and store in SUAVE components.
#for vsp_fuselage in vsp_fuselages:
#fuselage_id = vsp_fuselages[vsp_fuselage]
#fuselage = read_vsp_fuselage(fuselage_id, units_type)
#vehicle.append_component(fuselage)
#for vsp_wing in vsp_wings:
#wing_id = vsp_wings[vsp_wing]
#wing = read_vsp_wing(wing_id, units_type)
#vehicle.append_component(wing)
#for vsp_prop in vsp_props:
#prop_id = vsp_props[vsp_prop]
#prop = read_vsp_prop(prop_id, units_type)
#vehicle.append_component(prop)
return vehicle
def read_vsp_wing(wing_id, units_type='SI',write_airfoil_file=True):
"""This reads an OpenVSP wing vehicle geometry and writes it into a SUAVE wing format.
Assumptions:
1. OpenVSP wing is divided into segments ("XSecs" in VSP).
2. Written for OpenVSP 3.21.1
Source:
N/A
Inputs:
1. VSP 10-digit geom ID for wing.
2. units_type set to 'SI' (default) or 'Imperial'.
Outputs:
Writes SUAVE wing object, with these geometries, from VSP:
Wings.Wing. (* is all keys)
origin [m] in all three dimensions
spans.projected [m]
chords.root [m]
chords.tip [m]
aspect_ratio [-]
sweeps.quarter_chord [radians]
twists.root [radians]
twists.tip [radians]
thickness_to_chord [-]
dihedral [radians]
symmetric <boolean>
tag <string>
areas.reference [m^2]
areas.wetted [m^2]
Segments.
tag <string>
twist [radians]
percent_span_location [-] .1 is 10%
root_chord_percent [-] .1 is 10%
dihedral_outboard [radians]
sweeps.quarter_chord [radians]
thickness_to_chord [-]
airfoil <NACA 4-series, 6 series, or airfoil file>
Properties Used:
N/A
"""
# Check if this is vertical tail, this seems like a weird first step but it's necessary
# Get the initial rotation to get the dihedral angles
x_rot = vsp.GetParmVal( wing_id,'X_Rotation','XForm')
if x_rot >=70:
wing = SUAVE.Components.Wings.Vertical_Tail()
wing.vertical = True
x_rot = (90-x_rot) * Units.deg
else:
# Instantiate a wing
wing = SUAVE.Components.Wings.Wing()
x_rot = x_rot * Units.deg
# Set the units
if units_type == 'SI':
units_factor = Units.meter * 1.
elif units_type == 'imperial':
units_factor = Units.foot * 1.
elif units_type == 'inches':
units_factor = Units.inch * 1.
# Apply a tag to the wing
if vsp.GetGeomName(wing_id):
tag = vsp.GetGeomName(wing_id)
tag = tag.translate(t_table)
wing.tag = tag
else:
wing.tag = 'winggeom'
scaling = vsp.GetParmVal(wing_id, 'Scale', 'XForm')
units_factor = units_factor*scaling
# Top level wing parameters
# Wing origin
wing.origin[0][0] = vsp.GetParmVal(wing_id, 'X_Location', 'XForm') * units_factor
wing.origin[0][1] = vsp.GetParmVal(wing_id, 'Y_Location', 'XForm') * units_factor
wing.origin[0][2] = vsp.GetParmVal(wing_id, 'Z_Location', 'XForm') * units_factor
# Wing Symmetry
sym_planar = vsp.GetParmVal(wing_id, 'Sym_Planar_Flag', 'Sym')
sym_origin = vsp.GetParmVal(wing_id, 'Sym_Ancestor_Origin_Flag', 'Sym')
# Check for symmetry
if sym_planar == 2. and sym_origin == 1.: #origin at wing, not vehicle
wing.symmetric = True
else:
wing.symmetric = False
#More top level parameters
total_proj_span = vsp.GetParmVal(wing_id, 'TotalProjectedSpan', 'WingGeom') * units_factor
wing.aspect_ratio = vsp.GetParmVal(wing_id, 'TotalAR', 'WingGeom')
wing.areas.reference = vsp.GetParmVal(wing_id, 'TotalArea', 'WingGeom') * units_factor**2
wing.spans.projected = total_proj_span
# Check if this is a single segment wing
xsec_surf_id = vsp.GetXSecSurf(wing_id, 0) # This is how VSP stores surfaces.
x_sec_1 = vsp.GetXSec(xsec_surf_id, 1)
if vsp.GetNumXSec(xsec_surf_id) == 2:
single_seg = True
else:
single_seg = False
segment_num = vsp.GetNumXSec(xsec_surf_id) # Get number of segments
span_sum = 0. # Non-projected.
proj_span_sum = 0. # Projected.
segment_spans = [None] * (segment_num) # Non-projected.
segment_dihedral = [None] * (segment_num)
segment_sweeps_quarter_chord = [None] * (segment_num)
# Necessary wing segment definitions start at XSec_1 (XSec_0 exists mainly to hold the root airfoil)
xsec_surf_id = vsp.GetXSecSurf(wing_id, 0)
x_sec = vsp.GetXSec(xsec_surf_id, 1)
chord_parm = vsp.GetXSecParm(x_sec,'Root_Chord')
root_chord = vsp.GetParmVal(chord_parm) * units_factor
# -------------
# Wing segments
# -------------
if single_seg == False:
# Convert VSP XSecs to SUAVE segments. (Wing segments are defined by outboard sections in VSP, but inboard sections in SUAVE.)
for i in range(1, segment_num+1):
# XSec airfoil
jj = i-1 # Airfoil index i-1 because VSP airfoils and sections are one index off relative to SUAVE.
segment = SUAVE.Components.Wings.Segment()
segment.tag = 'Section_' + str(i)
thick_cord = vsp.GetParmVal(wing_id, 'ThickChord', 'XSecCurve_' + str(jj))
segment.thickness_to_chord = thick_cord # Thick_cord stored for use in airfoil, below.
if i!=segment_num:
segment_root_chord = vsp.GetParmVal(wing_id, 'Root_Chord', 'XSec_' + str(i)) * units_factor
else:
segment_root_chord = 0.0
segment.root_chord_percent = segment_root_chord / root_chord
segment.percent_span_location = proj_span_sum / (total_proj_span/(1+wing.symmetric))
segment.twist = vsp.GetParmVal(wing_id, 'Twist', 'XSec_' + str(jj)) * Units.deg
if i==1:
wing.thickness_to_chord = thick_cord
if i < segment_num: # This excludes the tip xsec, but we need a segment in SUAVE to store airfoil.
sweep = vsp.GetParmVal(wing_id, 'Sweep', 'XSec_' + str(i)) * Units.deg
sweep_loc = vsp.GetParmVal(wing_id, 'Sweep_Location', 'XSec_' + str(i))
AR = 2*vsp.GetParmVal(wing_id, 'Aspect', 'XSec_' + str(i))
taper = vsp.GetParmVal(wing_id, 'Taper', 'XSec_' + str(i))
segment_sweeps_quarter_chord[i] = convert_sweep(sweep,sweep_loc,0.25,AR,taper)
segment.sweeps.quarter_chord = segment_sweeps_quarter_chord[i] # Used again, below
# Used for dihedral computation, below.
segment_dihedral[i] = vsp.GetParmVal(wing_id, 'Dihedral', 'XSec_' + str(i)) * Units.deg + x_rot
segment.dihedral_outboard = segment_dihedral[i]
segment_spans[i] = vsp.GetParmVal(wing_id, 'Span', 'XSec_' + str(i)) * units_factor
proj_span_sum += segment_spans[i] * np.cos(segment_dihedral[i])
span_sum += segment_spans[i]
else:
segment.root_chord_percent = (vsp.GetParmVal(wing_id, 'Tip_Chord', 'XSec_' + str(i-1))) * units_factor /root_chord
xsec_id = str(vsp.GetXSec(xsec_surf_id, jj))
airfoil = Airfoil()
if vsp.GetXSecShape(xsec_id) == vsp.XS_FOUR_SERIES: # XSec shape: NACA 4-series
camber = vsp.GetParmVal(wing_id, 'Camber', 'XSecCurve_' + str(jj))
if camber == 0.:
camber_loc = 0.
else:
camber_loc = vsp.GetParmVal(wing_id, 'CamberLoc', 'XSecCurve_' + str(jj))
airfoil.thickness_to_chord = thick_cord
camber_round = int(np.around(camber*100))
camber_loc_round = int(np.around(camber_loc*10))
thick_cord_round = int(np.around(thick_cord*100))
airfoil.tag = 'NACA ' + str(camber_round) + str(camber_loc_round) + str(thick_cord_round)
elif vsp.GetXSecShape(xsec_id) == vsp.XS_SIX_SERIES: # XSec shape: NACA 6-series
thick_cord_round = int(np.around(thick_cord*100))
a_value = vsp.GetParmVal(wing_id, 'A', 'XSecCurve_' + str(jj))
ideal_CL = int(np.around(vsp.GetParmVal(wing_id, 'IdealCl', 'XSecCurve_' + str(jj))*10))
series_vsp = int(vsp.GetParmVal(wing_id, 'Series', 'XSecCurve_' + str(jj)))
series_dict = {0:'63',1:'64',2:'65',3:'66',4:'67',5:'63A',6:'64A',7:'65A'} # VSP series values.
series = series_dict[series_vsp]
airfoil.tag = 'NACA ' + series + str(ideal_CL) + str(thick_cord_round) + ' a=' + str(np.around(a_value,1))
elif vsp.GetXSecShape(xsec_id) == vsp.XS_FILE_AIRFOIL: # XSec shape: 12 is type AF_FILE
airfoil.thickness_to_chord = thick_cord
# VSP airfoil API calls get coordinates and write files with the final argument being the fraction of segment position, regardless of relative spans.
# (Write the root airfoil with final arg = 0. Write 4th airfoil of 5 segments with final arg = .8)
if write_airfoil_file==True:
vsp.WriteSeligAirfoil(str(wing.tag) + '_airfoil_XSec_' + str(jj) +'.dat', wing_id, float(jj/segment_num))
airfoil.coordinate_file = str(wing.tag) + '_airfoil_XSec_' + str(jj) +'.dat'
airfoil.tag = 'airfoil'
segment.append_airfoil(airfoil)
wing.Segments.append(segment)
# Wing dihedral
proj_span_sum_alt = 0.
span_sum_alt = 0.
sweeps_sum = 0.
for ii in range(1, segment_num):
span_sum_alt += segment_spans[ii]
proj_span_sum_alt += segment_spans[ii] * np.cos(segment_dihedral[ii]) # Use projected span to find total wing dihedral.
sweeps_sum += segment_spans[ii] * np.tan(segment_sweeps_quarter_chord[ii])
wing.dihedral = np.arccos(proj_span_sum_alt / span_sum_alt)
wing.sweeps.quarter_chord = -np.arctan(sweeps_sum / span_sum_alt) # Minus sign makes it positive sweep.
# Add a tip segment, all values are zero except the tip chord
tc = vsp.GetParmVal(wing_id, 'Tip_Chord', 'XSec_' + str(segment_num-1)) * units_factor
# Chords
wing.chords.root = vsp.GetParmVal(wing_id, 'Tip_Chord', 'XSec_0') * units_factor
wing.chords.tip = tc
wing.chords.mean_geometric = wing.areas.reference / wing.spans.projected
# Just double calculate and fix things:
wing = wing_segmented_planform(wing)
else:
# Single segment
# Get ID's
x_sec_1_dih_parm = vsp.GetXSecParm(x_sec_1,'Dihedral')
x_sec_1_sweep_parm = vsp.GetXSecParm(x_sec_1,'Sweep')
x_sec_1_sweep_loc_parm = vsp.GetXSecParm(x_sec_1,'Sweep_Location')
x_sec_1_taper_parm = vsp.GetXSecParm(x_sec_1,'Taper')
x_sec_1_rc_parm = vsp.GetXSecParm(x_sec_1,'Root_Chord')
x_sec_1_tc_parm = vsp.GetXSecParm(x_sec_1,'Tip_Chord')
x_sec_1_t_parm = vsp.GetXSecParm(x_sec_1,'ThickChord')
# Calcs
sweep = vsp.GetParmVal(x_sec_1_sweep_parm) * Units.deg
sweep_loc = vsp.GetParmVal(x_sec_1_sweep_loc_parm)
taper = vsp.GetParmVal(x_sec_1_taper_parm)
c_4_sweep = convert_sweep(sweep,sweep_loc,0.25,wing.aspect_ratio,taper)
# Pull and pack
wing.sweeps.quarter_chord = c_4_sweep
wing.taper = taper
wing.dihedral = vsp.GetParmVal(x_sec_1_dih_parm) * Units.deg + x_rot
wing.chords.root = vsp.GetParmVal(x_sec_1_rc_parm)* units_factor
wing.chords.tip = vsp.GetParmVal(x_sec_1_tc_parm) * units_factor
wing.chords.mean_geometric = wing.areas.reference / wing.spans.projected
wing.thickness_to_chord = vsp.GetParmVal(x_sec_1_t_parm)
# Just double calculate and fix things:
wing = wing_planform(wing)
# Twists
wing.twists.root = vsp.GetParmVal(wing_id, 'Twist', 'XSec_0') * Units.deg
wing.twists.tip = vsp.GetParmVal(wing_id, 'Twist', 'XSec_' + str(segment_num-1)) * Units.deg
# check if control surface (sub surfaces) are defined
tags = []
LE_flags = []
span_fraction_starts = []
span_fraction_ends = []
chord_fractions = []
num_cs = vsp.GetNumSubSurf(wing_id)
# loop through wing and get all control surface parameters
for cs_idx in range(num_cs):
cs_id = vsp.GetSubSurf(wing_id,cs_idx)
param_names = vsp.GetSubSurfParmIDs(cs_id)
tags.append(vsp.GetSubSurfName(cs_id))
for p_idx in range(len(param_names)):
if 'LE_Flag' == vsp.GetParmName(param_names[p_idx]):
LE_flags.append(vsp.GetParmVal(param_names[p_idx]))
if 'UStart' == vsp.GetParmName(param_names[p_idx]):
span_fraction_starts.append(vsp.GetParmVal(param_names[p_idx]))
if 'UEnd' == vsp.GetParmName(param_names[p_idx]):
span_fraction_ends.append(vsp.GetParmVal(param_names[p_idx]))
if 'Length_C_Start' == vsp.GetParmName(param_names[p_idx]):
chord_fractions.append(vsp.GetParmVal(param_names[p_idx]))
# assign control surface parameters to wings. Outer most control surface on main/horizontal wing is assigned a aileron
for cs_idx in range(num_cs):
aileron_present = False
if num_cs > 1:
aileron_loc = np.argmax(np.array(span_fraction_starts))
if cs_idx == aileron_loc:
aileron_present = True
if LE_flags[cs_idx] == 1.0:
CS = SUAVE.Components.Wings.Control_Surfaces.Slat()
else:
if wing.vertical == True:
CS = SUAVE.Components.Wings.Control_Surfaces.Rudder()
else:
if aileron_present:
CS = SUAVE.Components.Wings.Control_Surfaces.Aileron()
else:
CS = SUAVE.Components.Wings.Control_Surfaces.Flap()
CS.tag = tags[cs_idx]
CS.span_fraction_start = span_fraction_starts[cs_idx]*3 - 1
CS.span_fraction_end = span_fraction_ends[cs_idx]*3 - 1
CS.chord_fraction = chord_fractions[cs_idx]
CS.span = (CS.span_fraction_end - CS.span_fraction_start)*wing.spans.projected
wing.append_control_surface(CS)
return wing
def read_vsp_nacelle(nacelle_id, vsp_nacelle_type, units_type='SI'):
"""This reads an OpenVSP stack geometry or body of revolution and writes it to a SUAVE nacelle format.
If an airfoil is defined in body-of-revolution, its coordinates are not read in due to absence of
API functions in VSP.
Assumptions:
Source:
N/A
Inputs:
0. Pre-loaded VSP vehicle in memory, via vsp_read.
1. VSP 10-digit geom ID for nacelle.
2. Units_type set to 'SI' (default) or 'Imperial'.
Outputs:
Writes SUAVE nacelle, with these geometries: (all defaults are SI, but user may specify Imperial)
Nacelles.Nacelle.
origin [m] in all three dimensions
width [m]
lengths [m]
heights [m]
tag <string>
segment[]. (segments are in ordered container and callable by number)
percent_x_location [unitless]
percent_z_location [unitless]
height [m]
width [m]
Properties Used:
N/A
"""
nacelle = SUAVE.Components.Nacelles.Nacelle()
if units_type == 'SI':
units_factor = Units.meter * 1.
elif units_type == 'imperial':
units_factor = Units.foot * 1.
elif units_type == 'inches':
units_factor = Units.inch * 1.
if vsp.GetGeomName(nacelle_id):
nacelle.tag = vsp.GetGeomName(nacelle_id)
else:
nacelle.tag = 'NacelleGeom'
nacelle.origin[0][0] = vsp.GetParmVal(nacelle_id, 'X_Location',
'XForm') * units_factor
nacelle.origin[0][1] = vsp.GetParmVal(nacelle_id, 'Y_Location',
'XForm') * units_factor
nacelle.origin[0][2] = vsp.GetParmVal(nacelle_id, 'Z_Location',
'XForm') * units_factor
nacelle.x_rotation = vsp.GetParmVal(nacelle_id, 'X_Rotation',
'XForm') * units_factor
nacelle.y_rotation = vsp.GetParmVal(nacelle_id, 'Y_Rotation',
'XForm') * units_factor
nacelle.z_rotation = vsp.GetParmVal(nacelle_id, 'Z_Rotation',
'XForm') * units_factor
if vsp_nacelle_type == 'Stack':
xsec_surf_id = vsp.GetXSecSurf(
nacelle_id, 0) # There is only one XSecSurf in geom.
num_segs = vsp.GetNumXSec(xsec_surf_id) # Number of xsecs in nacelle.
abs_x_location = 0
abs_y_location = 0
abs_z_location = 0
abs_x_location_vec = []
abs_y_location_vec = []
abs_z_location_vec = []
for i in range(num_segs):
# Create the segment
xsec_id = vsp.GetXSec(xsec_surf_id, i) # VSP XSec ID.
segment = SUAVE.Components.Lofted_Body_Segment.Segment()
segment.tag = 'segment_' + str(i)
# Pull out Parms that will be needed
X_Loc_P = vsp.GetXSecParm(xsec_id, 'XDelta')
Y_Loc_P = vsp.GetXSecParm(xsec_id, 'YDelta')
Z_Loc_P = vsp.GetXSecParm(xsec_id, 'XDelta')
del_x = vsp.GetParmVal(X_Loc_P)
del_y = vsp.GetParmVal(Y_Loc_P)
del_z = vsp.GetParmVal(Z_Loc_P)
abs_x_location = abs_x_location + del_x
abs_y_location = abs_y_location + del_y
abs_z_location = abs_z_location + del_z
abs_x_location_vec.append(abs_x_location)
abs_y_location_vec.append(abs_y_location)
abs_z_location_vec.append(abs_z_location)
shape = vsp.GetXSecShape(xsec_id)
shape_dict = {
0: 'point',
1: 'circle',
2: 'ellipse',
3: 'super ellipse',
4: 'rounded rectangle',
5: 'general fuse',
6: 'fuse file'
}
if shape_dict[shape] == 'point':
segment.height = 0.0
segment.width = 0.0
if i == 0:
nacelle.flow_through = False
else:
segment.height = vsp.GetXSecHeight(xsec_id) * units_factor
segment.width = vsp.GetXSecWidth(xsec_id) * units_factor
if i == 0:
nacelle.flow_through = True
nacelle.Segments.append(segment)
nacelle.length = abs_x_location_vec[-1]
segs = nacelle.Segments
for seg in range(num_segs):
segs[seg].percent_x_location = np.array(
abs_x_location_vec) / abs_x_location_vec[-1]
segs[seg].percent_y_location = np.array(
abs_y_location_vec) / abs_x_location_vec[-1]
segs[seg].percent_z_location = np.array(
abs_z_location_vec) / abs_x_location_vec[-1]
elif vsp_nacelle_type == 'BodyOfRevolution':
diameter = vsp.GetParmVal(nacelle_id, "Diameter",
"Design") * units_factor
angle = vsp.GetParmVal(nacelle_id, "Diameter",
"Design") * Units.degrees
ft_flag_idx = vsp.GetParmVal(nacelle_id, "Mode", "Design")
if ft_flag_idx == 0.0:
ft_flag = True
else:
ft_flag = False
nacelle.flow_through = ft_flag
shape = vsp.GetBORXSecShape(nacelle_id)
shape_dict = {0:'point',1:'circle',2:'ellipse',3:'super ellipse',4:'rounded rectangle',5:'general fuse',6:'fuse file',\
7:'four series',8:'six series',9:'biconvex',10:'wedge',11:'editcurve',12:'file airfoil'}
if shape_dict[shape] == 'four series':
naf = SUAVE.Components.Airfoils.Airfoil()
length = vsp.GetParmVal(nacelle_id, "Chord", "XSecCurve")
thickness = int(
round(
vsp.GetParmVal(nacelle_id, "ThickChord", "XSecCurve") * 10,
0))
camber = int(
round(
vsp.GetParmVal(nacelle_id, "Camber", "XSecCurve") * 100,
0))
camber_loc = int(
round(
vsp.GetParmVal(nacelle_id, "CamberLoc", "XSecCurve") * 10,
0))
airfoil = str(camber) + str(camber_loc) + str(thickness)
height = thickness
naf.naca_4_series_airfoil = str(airfoil)
naf.thickness_to_chord = thickness
nacelle.append_airfoil(naf)
elif shape_dict[shape] == 'super ellipse':
if ft_flag:
height = vsp.GetParmVal(nacelle_id, "Super_Height",
"XSecCurve")
diameter = vsp.GetParmVal(nacelle_id, "Diameter", "Design")
length = vsp.GetParmVal(nacelle_id, "Super_Width", "XSecCurve")
else:
diameter = vsp.GetParmVal(nacelle_id, "Super_Height",
"XSecCurve")
length = vsp.GetParmVal(nacelle_id, "Super_Width", "XSecCurve")
height = diameter / 2
elif shape_dict[shape] == 'file airfoil':
naf = SUAVE.Components.Airfoils.Airfoil()
thickness_to_chord = vsp.GetParmVal(nacelle_id, "ThickChord",
"XSecCurve") * units_factor
length = vsp.GetParmVal(nacelle_id, "Chord",
"XSecCurve") * units_factor
height = thickness_to_chord * length * units_factor
if ft_flag:
diameter = vsp.GetParmVal(nacelle_id, "Diameter",
"Design") * units_factor
else:
diameter = 0
naf.thickness_to_chord = thickness_to_chord
nacelle.append_airfoil(naf)
nacelle.length = length
nacelle.diameter = diameter + height / 2
nacelle.inlet_diameter = nacelle.diameter - height
nacelle.cowling_airfoil_angle = angle
return nacelle
def read_vsp_propeller(prop_id, units_type='SI',write_airfoil_file=True):
"""This reads an OpenVSP propeller geometry and writes it into a SUAVE propeller format.
Assumptions:
1. Written for OpenVSP 3.24.0
Source:
N/A
Inputs:
1. VSP 10-digit geom ID for prop.
2. units_type set to 'SI' (default) or 'Imperial'.
3. write_airfoil_file set to True (default) or False
4. number_of_radial_stations is the radial discretization used to extract the propeller design from OpenVSP
Outputs:
Writes SUAVE propeller/rotor object, with these geometries, from VSP:
prop.
origin [m] in all three dimensions
orientation [deg] in all three dimensions
number_of_blades [-]
tip_radius [m]
hub_radius [m]
twist_distribution [deg]
chord_distribution [m]
radius_distribution [m]
sweep_distribution [deg]
mid_chord_alignment [m]
max_thickness_distribution [m]
thickness_to_chord [-]
blade_solidity [-]
rotation [-]
thickness_to_chord [-]
beta34 [radians]
pre_cone [radians]
rake [radians]
skew [radians]
axial [radians]
tangential [radians]
dihedral [radians]
symmetric <boolean>
tag <string>
Segments.
tag <string>
twist [radians]
percent_span_location [-] .1 is 10%
root_chord_percent [-] .1 is 10%
dihedral_outboard [radians]
sweeps.quarter_chord [radians]
thickness_to_chord [-]
airfoil <NACA 4-series, 6 series, or airfoil file>
Properties Used:
N/A
"""
# Check if this is a propeller or a lift rotor
# Check if the thrust angle is > 70 deg in pitch
if vsp.GetParmVal( prop_id,'Y_Rotation','XForm') >= 70:
# Assume lift rotor
prop = SUAVE.Components.Energy.Converters.Lift_Rotor()
else:
# Instantiate a propeller
prop = SUAVE.Components.Energy.Converters.Propeller()
# Set the units
if units_type == 'SI':
units_factor = Units.meter * 1.
elif units_type == 'imperial':
units_factor = Units.foot * 1.
elif units_type == 'inches':
units_factor = Units.inch * 1.
# Apply a tag to the prop
if vsp.GetGeomName(prop_id):
tag = vsp.GetGeomName(prop_id)
tag = tag.translate(t_table)
prop.tag = tag
else:
prop.tag = 'propgeom'
scaling = vsp.GetParmVal(prop_id, 'Scale', 'XForm')
units_factor = units_factor*scaling
# Propeller location (absolute)
prop.origin = [[0.0,0.0,0.0]]
prop.origin[0][0] = vsp.GetParmVal(prop_id, 'X_Location', 'XForm') * units_factor
prop.origin[0][1] = vsp.GetParmVal(prop_id, 'Y_Location', 'XForm') * units_factor
prop.origin[0][2] = vsp.GetParmVal(prop_id, 'Z_Location', 'XForm') * units_factor
# Propeller orientation
prop.orientation_euler_angles = [0.0,0.0,0.0]
prop.orientation_euler_angles[0] = vsp.GetParmVal(prop_id, 'X_Rotation', 'XForm') * Units.degrees
prop.orientation_euler_angles[1] = vsp.GetParmVal(prop_id, 'Y_Rotation', 'XForm') * Units.degrees
prop.orientation_euler_angles[2] = vsp.GetParmVal(prop_id, 'Z_Rotation', 'XForm') * Units.degrees
# Get the propeller parameter IDs
parm_id = vsp.GetGeomParmIDs(prop_id)
parm_names = []
for i in range(len(parm_id)):
parm_name = vsp.GetParmName(parm_id[i])
parm_names.append(parm_name)
# Run the vsp Blade Element analysis
vsp.SetStringAnalysisInput( "BladeElement" , "PropID" , (prop_id,) )
rid = vsp.ExecAnalysis( "BladeElement" )
Nc = len(vsp.GetDoubleResults(rid,"YSection_000"))
prop.number_points_around_airfoil = 2*Nc
prop.CLi = vsp.GetParmVal(parm_id[parm_names.index('CLi')])
prop.blade_solidity = vsp.GetParmVal(parm_id[parm_names.index('Solidity')])
prop.number_of_blades = int(vsp.GetParmVal(parm_id[parm_names.index('NumBlade')]))
prop.tip_radius = vsp.GetDoubleResults(rid, "Diameter" )[0] / 2 * units_factor
prop.radius_distribution = np.array(vsp.GetDoubleResults(rid, "Radius" )) * prop.tip_radius
prop.radius_distribution[-1] = 0.99 * prop.tip_radius # BEMT requires max nondimensional radius to be less than 1.0
prop.hub_radius = prop.radius_distribution[0]
prop.chord_distribution = np.array(vsp.GetDoubleResults(rid, "Chord" )) * prop.tip_radius # vsp gives c/R
prop.twist_distribution = np.array(vsp.GetDoubleResults(rid, "Twist" )) * Units.degrees
prop.sweep_distribution = np.array(vsp.GetDoubleResults(rid, "Sweep" ))
prop.mid_chord_alignment = np.tan(prop.sweep_distribution*Units.degrees) * prop.radius_distribution
prop.thickness_to_chord = np.array(vsp.GetDoubleResults(rid, "Thick" ))
prop.max_thickness_distribution = prop.thickness_to_chord*prop.chord_distribution * units_factor
prop.Cl_distribution = np.array(vsp.GetDoubleResults(rid, "CLi" ))
# Extra data from VSP BEM for future use in BEMT
prop.beta34 = vsp.GetDoubleResults(rid, "Beta34" )[0] # pitch at 3/4 radius
prop.pre_cone = vsp.GetDoubleResults(rid, "Pre_Cone")[0]
prop.rake = np.array(vsp.GetDoubleResults(rid, "Rake"))
prop.skew = np.array(vsp.GetDoubleResults(rid, "Skew"))
prop.axial = np.array(vsp.GetDoubleResults(rid, "Axial"))
prop.tangential = np.array(vsp.GetDoubleResults(rid, "Tangential"))
# Set prop rotation
prop.rotation = 1
# ---------------------------------------------
# Rotor Airfoil
# ---------------------------------------------
if write_airfoil_file:
print("Airfoil write not yet implemented. Defaulting to NACA 4412 airfoil for propeller cross section.")
return prop
