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 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 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 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