def empty(config,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
motor_efficiency = 0.85 * 0.98):
"""weight = SUAVE.Methods.Weights.Buildups.Electric_Stopped_Rotor.empty(
config,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
motor_efficiency = 0.85 * 0.98)
Calculates the empty fuselage mass for an electric stopped rotor including
seats, avionics, servomotors, ballistic recovery system, rotor and hub
assembly, transmission, and landing gear. Additionally incorporates
results of the following common buildup scripts:
fuselage,py
prop.py
wing.py
wiring.py
Originally written as part of an AA 290 project inteded for trade study
of the Electric Stopped Rotor along with the following defined SUAVE config types:
Electric Helicopter
Electric Tiltrotor
Sources:
Project Vahana Conceptual Trade Study
Inputs:
config SUAVE Config Data Structure
speed_of_sound Local Speed of Sound [m/s]
maximumTipMach Allowable Tip Mach Number [Unitless]
disk_area_factor Inverse of Disk Area Efficiency [Unitless]
max_thrust_to_weight_ratio Allowable Thrust to Weight Ratio [Unitless]
motor_efficiency Motor Efficiency [Unitless]
Outputs:
output: Data Dictionary of Component Masses [kg]
"""
output = Data()
#-------------------------------------------------------------------------------
# Unpack Inputs
#-------------------------------------------------------------------------------
rProp = config.propulsors.network.propeller.prop_attributes.tip_radius
mBattery = config.propulsors.network.battery.mass_properties.mass
mPayload = config.propulsors.network.payload.mass_properties.mass
MTOW = config.mass_properties.max_takeoff
nLiftProps = config.propulsors.network.number_of_engines/2
nThrustProps = config.propulsors.network.number_of_engines/2
nLiftBlades = config.propulsors.network.propeller.prop_attributes.number_blades
nThrustBlades = config.propulsors.network.propeller.prop_attributes.number_blades
fLength = config.fuselages.fuselage.lengths.total
fWidth = config.fuselages.fuselage.width
fHeight = config.fuselages.fuselage.heights.maximum
maxSpan = config.wings['main_wing'].spans.projected
sound = speed_of_sound
tipMach = max_tip_mach
k = disk_area_factor
ToverW = max_thrust_to_weight_ratio
etaMotor = motor_efficiency
output.payload = mPayload * Units.kg
output.seats = 30. *Units.kg
output.avionics = 15. *Units.kg
output.motors = config.propulsors.network.number_of_engines * 10. *Units.kg
output.battery = mBattery *Units.kg
output.servos = config.propulsors.network.number_of_engines * 0.65 *Units.kg
output.brs = 16. *Units.kg
output.hubs = config.propulsors.network.number_of_engines * 2. *Units.kg
output.landing_gear = MTOW * 0.02 *Units.kg
#-------------------------------------------------------------------------------
# Calculated Weights
#-------------------------------------------------------------------------------
# Preparatory Calculations
Vtip = sound * tipMach # Prop Tip Velocity
omega = Vtip/0.8 # Prop Ang. Velocity
maxLift = config.mass_properties.max_takeoff * ToverW # Maximum Thrust
Ct = maxLift/(1.225*np.pi*0.8**2*Vtip**2) # Thrust Coefficient
bladeSol = 0.1 # Blade Solidity
AvgCL = 6 * Ct / bladeSol # Average Blade CL
AvgCD = 0.012 # Average Blade CD
maxLiftPower = 1.15*maxLift*(
k*np.sqrt(maxLift/(2*1.225*np.pi*0.8**2)) +
bladeSol*AvgCD/8*Vtip**3/(maxLift/(1.225*np.pi*0.8**2))
)
maxTorque = maxLiftPower/omega
# Component Weight Calculations
output.lift_rotors = (prop(config.propulsors.network.propeller, maxLift)
* (len(config.wings['main_wing'].motor_spanwise_locations)
+ len(config.wings['main_wing'].motor_spanwise_locations))) *Units.kg
output.thrust_rotors = prop(config.propulsors.network.thrust_propeller, maxLift/5) *Units.kg
output.fuselage = fuselage(config) *Units.kg
output.wiring = wiring(config,
np.ones(8)**0.25,
maxLiftPower/etaMotor) *Units.kg
output.main_wing = wing(config.wings['main_wing'],
config,
maxLift/5) *Units.kg
output.sec_wing = wing(config.wings['secondary_wing'],
config,
maxLift/5) *Units.kg
#-------------------------------------------------------------------------------
# Weight Summations
#-------------------------------------------------------------------------------
output.structural = (output.lift_rotors +
output.thrust_rotors +
output.hubs +
output.fuselage +
output.landing_gear +
output.main_wing +
output.sec_wing
) *Units.kg
output.empty = 1.1 * (
output.structural +
output.seats +
output.avionics +
output.battery +
output.motors +
output.servos +
output.wiring +
output.brs
) *Units.kg
output.total = (output.empty +
output.payload) *Units.kg
return output
def empty(config,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
motor_efficiency = 0.85 * 0.98):
"""weight = SUAVE.Methods.Weights.Buildups.electricVectored_Thrust.empty(
config,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
motor_efficience = 0.85 * 0.98)
Calculates the empty fuselage mass for an electric tiltrotor including
seats, avionics, servomotors, ballistic recovery system, rotor and hub
assembly, transmission, and landing gear. Additionally incorporates
results of the following correlation scripts:
fuselage,py
prop.py
wing.py
wiring.py
Originally written as part of an AA 290 project inteded for trade study
of the Electric Vectored_Thrust along with the following defined SUAVE vehicle types:
Electric Multicopter
Electric Stopped Rotor
Sources:
Project Vahana Conceptual Trade Study
https://github.com/VahanaOpenSource
Inputs:
config SUAVE Config Data Structure
speed_of_sound Local Speed of Sound [m/s]
max_tip_mach Allowable Tip Mach Number [Unitless]
disk_area_factor Inverse of Disk Area Efficiency [Unitless]
max_thrust_to_weight_ratio Allowable Thrust to Weight Ratio [Unitless]
motor_efficiency Motor Efficiency [Unitless]
Outputs:
output: Data Dictionary of Component Masses [kg]
"""
#-------------------------------------------------------------------------------
# Unpack Inputs
#-------------------------------------------------------------------------------
rRotor = config.propulsors.propulsor.rotor.tip_radius
bladeSol = config.propulsors.propulsor.rotor.blade_solidity
tipMach = max_tip_mach
k = disk_area_factor
ToverW = max_thrust_to_weight_ratio
etaMotor = motor_efficiency
#-------------------------------------------------------------------------------
# Assumed Weights
#-------------------------------------------------------------------------------
output = Data()
output.payload = config.propulsors.propulsor.payload.mass_properties.mass
output.seats = 30.
output.avionics = 15.
output.motors = 10 * config.propulsors.propulsor.number_of_engines
output.battery = config.propulsors.propulsor.battery.mass_properties.mass
output.servos = 0.65 * config.propulsors.propulsor.number_of_engines
output.brs = 16.
output.hubs = 2 * config.propulsors.propulsor.number_of_engines
output.landing_gear = config.mass_properties.max_takeoff * 0.02
#-------------------------------------------------------------------------------
# Calculated Weights
#-------------------------------------------------------------------------------
# Preparatory Calculations
rho_ref = 1.225
Vtip = speed_of_sound * tipMach # Prop Tip Velocity
omega = Vtip/rRotor # Prop Ang. Velocity
maxLift = config.mass_properties.max_takeoff * ToverW # Maximum Thrust
Ct = maxLift/(rho_ref*np.pi*rRotor**2*Vtip**2) # Thrust Coefficient
AvgCL = 6 * Ct / bladeSol # Average Blade CL
AvgCD = 0.012 # Average Blade CD
maxLiftPower = 1.15*maxLift*(k*np.sqrt(maxLift/(2*rho_ref*np.pi*rRotor**2)) +
bladeSol*AvgCD/8*Vtip**3/(maxLift/(rho_ref*np.pi*rRotor**2)))
maxTorque = maxLiftPower/omega
# Component Weight Calculations
num_motors = 0
rotor_servos = 0
for w in config.wings:
num_motors += num_motors + len(w.motor_spanwise_locations)
rotor_servos += 2*len(w.motor_spanwise_locations)
output.rotor_servos = rotor_servos
output.lift_rotors = (prop(config.propulsors.propulsor.rotor, maxLift)* (num_motors)) # make more generic ash jordan about this
output.fuselage = fuselage(config)
output.wiring = wiring(config, np.ones(8)**0.25, maxLiftPower/etaMotor)
total_wing_weight = 0.
for w in config.wings:
wing_tag = w.tag
if (wing_tag.find('main_wing') != -1):
wing_weight = wing(config.wings[w.tag], config, maxLift/5) *Units.kg
total_wing_weight = total_wing_weight + wing_weight
output.total_wing_weight = total_wing_weight
#-------------------------------------------------------------------------------
# Weight Summations
#-------------------------------------------------------------------------------
output.structural = (output.lift_rotors +
output.hubs +
output.fuselage +
output.landing_gear +
output.total_wing_weight
)
output.empty = 1.1 * (
output.structural +
output.seats +
output.avionics +
output.battery +
output.motors +
output.servos +
output.rotor_servos +
output.wiring +
output.brs
)
output.total = (output.empty +
output.payload)
return output
def empty(config,
contingency_factor=1.1,
speed_of_sound=340.294,
max_tip_mach=0.65,
disk_area_factor=1.15,
safety_factor=1.5,
max_thrust_to_weight_ratio=1.1,
max_g_load=3.8,
motor_efficiency=0.85 * 0.98):
"""mass = SUAVE.Methods.Weights.Buildups.EVTOL.empty(
config,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
motor_efficiency = 0.85 * 0.98)
Calculates the empty vehicle mass for an EVTOL-type aircraft including seats,
avionics, servomotors, ballistic recovery system, rotor and hub assembly,
transmission, and landing gear. Incorporates the results of the following
common-use buildups:
fuselage.py
prop.py
wing.py
wiring.py
Sources:
Project Vahana Conceptual Trade Study
https://github.com/VahanaOpenSource
Inputs:
config: SUAVE Config Data Stucture
speed_of_sound: Local Speed of Sound [m/s]
max_tip_mach: Allowable Tip Mach Number [Unitless]
disk_area_factor: Inverse of Disk Area Efficiency [Unitless]
max_thrust_to_weight_ratio: Allowable Thrust to Weight Ratio [Unitless]
motor_efficiency: Motor Efficiency [Unitless]
Outpus:
outputs: Data Dictionary of Component Masses [kg]
Output data dictionary has the following book-keeping hierarchical structure:
Output
Total.
Empty.
Structural.
Fuselage
Wings
Landing Gear
Rotors
Hubs
Seats
Battery
Motors
Servo
Systems.
Avionics
ECS - Environmental Control System
BRS - Ballistic Recovery System
Wiring - Aircraft Electronic Wiring
Payload
"""
# Set up data structures for SUAVE weight methods
output = Data()
output.lift_rotors = 0.0
output.propellers = 0.0
output.lift_rotor_motors = 0.0
output.propeller_motors = 0.0
output.battery = 0.0
output.payload = 0.0
output.servos = 0.0
output.hubs = 0.0
output.BRS = 0.0
config.payload.passengers = SUAVE.Components.Physical_Component()
config.payload.baggage = SUAVE.Components.Physical_Component()
config.payload.cargo = SUAVE.Components.Physical_Component()
control_systems = SUAVE.Components.Physical_Component()
electrical_systems = SUAVE.Components.Physical_Component()
furnishings = SUAVE.Components.Physical_Component()
air_conditioner = SUAVE.Components.Physical_Component()
fuel = SUAVE.Components.Physical_Component()
apu = SUAVE.Components.Physical_Component()
hydraulics = SUAVE.Components.Physical_Component()
avionics = SUAVE.Components.Energy.Peripherals.Avionics()
optionals = SUAVE.Components.Physical_Component()
# assign components to vehicle
config.systems.control_systems = control_systems
config.systems.electrical_systems = electrical_systems
config.systems.avionics = avionics
config.systems.furnishings = furnishings
config.systems.air_conditioner = air_conditioner
config.systems.fuel = fuel
config.systems.apu = apu
config.systems.hydraulics = hydraulics
config.systems.optionals = optionals
#-------------------------------------------------------------------------------
# Fixed Weights
#-------------------------------------------------------------------------------
MTOW = config.mass_properties.max_takeoff
output.seats = config.passengers * 15. * Units.kg
output.passengers = config.passengers * 70. * Units.kg
output.avionics = 15. * Units.kg
output.landing_gear = MTOW * 0.02 * Units.kg
output.ECS = config.passengers * 7. * Units.kg
# Inputs and other constants
tipMach = max_tip_mach
k = disk_area_factor
ToverW = max_thrust_to_weight_ratio
eta = motor_efficiency
rho_ref = 1.225
maxVTip = speed_of_sound * tipMach # Prop Tip Velocity
maxLift = MTOW * ToverW * 9.81 # Maximum Thrust
AvgBladeCD = 0.012 # Average Blade CD
# Select a length scale depending on what kind of vehicle this is
length_scale = 1.
nose_length = 0.
# Check if there is a fuselage
C = SUAVE.Components
if len(config.fuselages) == 0.:
for w in config.wings:
if isinstance(w, C.Wings.Main_Wing):
b = w.chords.root
if b > length_scale:
length_scale = b
nose_length = 0.25 * b
else:
for fuse in config.fuselages:
nose = fuse.lengths.nose
length = fuse.lengths.total
if length > length_scale:
length_scale = length
nose_length = nose
#-------------------------------------------------------------------------------
# Environmental Control System
#-------------------------------------------------------------------------------
config.systems.air_conditioner.origin[0][0] = 0.51 * length_scale
config.systems.air_conditioner.mass_properties.mass = output.ECS
#-------------------------------------------------------------------------------
# Network Weight
#-------------------------------------------------------------------------------
for network in config.networks:
#-------------------------------------------------------------------------------
# Battery Weight
#-------------------------------------------------------------------------------
network.battery.origin[0][0] = 0.51 * length_scale
network.battery.mass_properties.center_of_gravity[0][0] = 0.0
output.battery += network.battery.mass_properties.mass * Units.kg
#-------------------------------------------------------------------------------
# Payload Weight
#-------------------------------------------------------------------------------
network.payload.origin[0][0] = 0.51 * length_scale
network.payload.mass_properties.center_of_gravity[0][0] = 0.0
output.payload += network.payload.mass_properties.mass * Units.kg
#-------------------------------------------------------------------------------
# Avionics Weight
#-------------------------------------------------------------------------------
network.avionics.origin[0][0] = 0.4 * nose_length
network.avionics.mass_properties.center_of_gravity[0][0] = 0.0
network.avionics.mass_properties.mass = output.avionics
#-------------------------------------------------------------------------------
# Servo, Hub and BRS Weights
#-------------------------------------------------------------------------------
lift_rotor_hub_weight = 4. * Units.kg
prop_hub_weight = MTOW * 0.04 * Units.kg
lift_rotor_BRS_weight = 16. * Units.kg
#-------------------------------------------------------------------------------
# Rotor, Propeller, parameters for sizing
#-------------------------------------------------------------------------------
if isinstance(network, Lift_Cruise):
# Total number of rotors and propellers
nLiftRotors = network.number_of_lift_rotor_engines
nThrustProps = network.number_of_propeller_engines
props = network.propellers
rots = network.lift_rotors
prop_motors = network.propeller_motors
rot_motors = network.lift_rotor_motors
elif isinstance(network, Battery_Propeller):
# Total number of rotors and propellers
if network.number_of_lift_rotor_engines == None:
nLiftRotors = 0
else:
nLiftRotors = network.number_of_lift_rotor_engines
rots = network.lift_rotors
rot_motors = network.lift_rotor_motors
if network.number_of_propeller_engines == None:
nThrustProps = 0
else:
nThrustProps = network.number_of_propeller_engines
props = network.propellers
prop_motors = network.propeller_motors
else:
raise NotImplementedError(
"""eVTOL weight buildup only supports the Battery Propeller and Lift Cruise energy networks.\n
Weight buildup will not return information on propulsion system.""",
RuntimeWarning)
nProps = int(nLiftRotors + nThrustProps)
if nProps > 1:
prop_BRS_weight = 16. * Units.kg
else:
prop_BRS_weight = 0. * Units.kg
prop_servo_weight = 0.0
if nThrustProps > 0:
if network.identical_propellers:
# Get reference properties for sizing from first propeller (assumes identical)
proprotor = props[list(props.keys())[0]]
propmotor = prop_motors[list(prop_motors.keys())[0]]
rTip_ref = proprotor.tip_radius
bladeSol_ref = proprotor.blade_solidity
if proprotor.variable_pitch:
prop_servo_weight = 5.2 * Units.kg
# Compute and add propeller weights
propeller_mass = prop(proprotor, maxLift / 5.) * Units.kg
output.propellers += nThrustProps * propeller_mass
output.propeller_motors += nThrustProps * propmotor.mass_properties.mass
proprotor.mass_properties.mass = propeller_mass + prop_hub_weight + prop_servo_weight
else:
for idx, propeller in enumerate(network.propellers):
proprotor = propeller
propmotor = prop_motors[list(prop_motors.keys())[idx]]
rTip_ref = proprotor.tip_radius
bladeSol_ref = proprotor.blade_solidity
if proprotor.variable_pitch:
prop_servo_weight = 5.2 * Units.kg
# Compute and add propeller weights
propeller_mass = prop(proprotor, maxLift / 5.) * Units.kg
output.propellers += propeller_mass
output.propeller_motors += propmotor.mass_properties.mass
proprotor.mass_properties.mass = propeller_mass + prop_hub_weight + prop_servo_weight
lift_rotor_servo_weight = 0.0
if nLiftRotors > 0:
if network.identical_lift_rotors:
# Get reference properties for sizing from first lift_rotor (assumes identical)
liftrotor = rots[list(rots.keys())[0]]
liftmotor = rot_motors[list(rot_motors.keys())[0]]
rTip_ref = liftrotor.tip_radius
bladeSol_ref = liftrotor.blade_solidity
if liftrotor.variable_pitch:
lift_rotor_servo_weight = 0.65 * Units.kg
# Compute and add lift_rotor weights
lift_rotor_mass = prop(
liftrotor, maxLift / max(nLiftRotors - 1, 1)) * Units.kg
output.lift_rotors += nLiftRotors * lift_rotor_mass
output.lift_rotor_motors += nLiftRotors * liftmotor.mass_properties.mass
liftrotor.mass_properties.mass = lift_rotor_mass + lift_rotor_hub_weight + lift_rotor_servo_weight
else:
for idx, lift_rotor in enumerate(network.lift_rotors):
liftrotor = lift_rotor
liftmotor = rot_motors[list(rot_motors.keys())[idx]]
rTip_ref = liftrotor.tip_radius
bladeSol_ref = liftrotor.blade_solidity
if liftrotor.variable_pitch:
lift_rotor_servo_weight = 0.65 * Units.kg
# Compute and add lift_rotor weights
lift_rotor_mass = prop(liftrotor, maxLift /
max(nLiftRotors - 1, 1)) * Units.kg
output.lift_rotors += lift_rotor_mass
output.lift_rotor_motors += liftmotor.mass_properties.mass
liftrotor.mass_properties.mass = lift_rotor_mass + lift_rotor_hub_weight + lift_rotor_servo_weight
# Add associated weights
output.servos += (nLiftRotors * lift_rotor_servo_weight +
nThrustProps * prop_servo_weight)
output.hubs += (nLiftRotors * lift_rotor_hub_weight +
nThrustProps * prop_hub_weight)
output.BRS += (prop_BRS_weight + lift_rotor_BRS_weight)
maxLiftPower = 1.15 * maxLift * (
k * np.sqrt(maxLift / (2 * rho_ref * np.pi * rTip_ref**2)) +
bladeSol_ref * AvgBladeCD / 8 * maxVTip**3 /
(maxLift / (rho_ref * np.pi * rTip_ref**2)))
# Tail Rotor
if nLiftRotors == 1: # this assumes that the vehicle is an electric helicopter with a tail rotor
maxLiftOmega = maxVTip / rTip_ref
maxLiftTorque = maxLiftPower / maxLiftOmega
tailrotor = next(iter(network.lift_rotors))
output.tail_rotor = prop(tailrotor, 1.5 * maxLiftTorque /
(1.25 * rTip_ref)) * 0.2 * Units.kg
output.lift_rotors += output.tail_rotor
# sum motor weight
output.motors = output.lift_rotor_motors + output.propeller_motors
#-------------------------------------------------------------------------------
# Wing and Motor Wiring Weight
#-------------------------------------------------------------------------------
total_wing_weight = 0.0
total_wiring_weight = 0.0
output.wings = Data()
output.wiring = Data()
for w in config.wings:
if w.symbolic:
wing_weight = 0
else:
wing_weight = wing(w,
config,
maxLift / 5,
safety_factor=safety_factor,
max_g_load=max_g_load)
wing_tag = w.tag
output.wings[wing_tag] = wing_weight
w.mass_properties.mass = wing_weight
total_wing_weight = total_wing_weight + wing_weight
# wiring weight
wiring_weight = wiring(w, config, maxLiftPower /
(eta * nProps)) * Units.kg
total_wiring_weight = total_wiring_weight + wiring_weight
output.wiring = total_wiring_weight
output.total_wing_weight = total_wing_weight
#-------------------------------------------------------------------------------
# Landing Gear Weight
#-------------------------------------------------------------------------------
if not hasattr(config.landing_gear, 'nose'):
config.landing_gear.nose = SUAVE.Components.Landing_Gear.Nose_Landing_Gear(
)
config.landing_gear.nose.mass = 0.0
if not hasattr(config.landing_gear, 'main'):
config.landing_gear.main = SUAVE.Components.Landing_Gear.Main_Landing_Gear(
)
config.landing_gear.main.mass = output.landing_gear
#-------------------------------------------------------------------------------
# Fuselage Weight
#-------------------------------------------------------------------------------
output.fuselage = fuselage(config) * Units.kg
config.fuselages.fuselage.mass_properties.center_of_gravity[0][
0] = .45 * config.fuselages.fuselage.lengths.total
config.fuselages.fuselage.mass_properties.mass = output.fuselage + output.passengers + output.seats +\
output.wiring + output.BRS
#-------------------------------------------------------------------------------
# Pack Up Outputs
#-------------------------------------------------------------------------------
output.structural = (output.lift_rotors + output.propellers + output.hubs +
output.fuselage + output.landing_gear +
output.total_wing_weight) * Units.kg
output.empty = (contingency_factor * (output.structural + output.seats + output.avionics +output.ECS +\
output.motors + output.servos + output.wiring + output.BRS) + output.battery) *Units.kg
output.total = output.empty + output.payload + output.passengers
return output
def empty(config,
contingency_factor = 1.1,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
safety_factor = 1.5,
max_g_load = 3.8,
motor_efficiency = 0.85 * 0.98):
"""weight = SUAVE.Methods.Weights.Buildups.Electric_Lift_Cruise.empty(
config,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
motor_efficiency = 0.85 * 0.98)
Calculates the empty fuselage mass for an electric stopped rotor including
seats, avionics, servomotors, ballistic recovery system, rotor and hub
assembly, transmission, and landing gear. Additionally incorporates
results of the following common buildup scripts:
fuselage,py
prop.py
wing.py
wiring.py
Originally written as part of an AA 290 project inteded for trade study
of the Electric Stopped Rotor along with the following defined SUAVE config types:
Electric Multicopter
Electric Vectored_Thrust
Sources:
Project Vahana Conceptual Trade Study
https://github.com/VahanaOpenSource
Inputs:
config SUAVE Config Data Structure
speed_of_sound Local Speed of Sound [m/s]
maximumTipMach Allowable Tip Mach Number [Unitless]
disk_area_factor Inverse of Disk Area Efficiency [Unitless]
max_thrust_to_weight_ratio Allowable Thrust to Weight Ratio [Unitless]
motor_efficiency Motor Efficiency [Unitless]
Outputs:
output: Data Dictionary of Component Masses [kg]
"""
output = Data()
#-------------------------------------------------------------------------------
# Unpack Inputs
#-------------------------------------------------------------------------------
rRotor = config.propulsors.propulsor.rotor.tip_radius
rotor_bladeSol = config.propulsors.propulsor.rotor.blade_solidity
rPropThrust = config.propulsors.propulsor.propeller.tip_radius
mBattery = config.propulsors.propulsor.battery.mass_properties.mass
mPayload = config.propulsors.propulsor.payload.mass_properties.mass
MTOW = config.mass_properties.max_takeoff
nLiftProps = config.propulsors.propulsor.number_of_engines_lift
nThrustProps = config.propulsors.propulsor.number_of_engines_forward
nLiftBlades = config.propulsors.propulsor.rotor.number_blades
nThrustBlades = config.propulsors.propulsor.propeller.number_blades
fLength = config.fuselages.fuselage.lengths.total
fWidth = config.fuselages.fuselage.width
fHeight = config.fuselages.fuselage.heights.maximum
maxSpan = config.wings['main_wing'].spans.projected
tipMach = max_tip_mach
k = disk_area_factor
ToverW = max_thrust_to_weight_ratio
etaMotor = motor_efficiency
output.payload = mPayload * Units.kg
output.seats = 30. *Units.kg
output.avionics = 15. *Units.kg
output.motors = (config.propulsors.propulsor.number_of_engines_lift * 10. *Units.kg
+ config.propulsors.propulsor.number_of_engines_forward * 25. *Units.kg)
output.battery = mBattery *Units.kg
output.servos = config.propulsors.propulsor.number_of_engines_lift * 0.65 *Units.kg
output.brs = 16. *Units.kg
output.hubs = (config.propulsors.propulsor.number_of_engines_lift * 2. *Units.kg
+ config.propulsors.propulsor.number_of_engines_forward * 5. *Units.kg)
output.landing_gear = MTOW * 0.02 *Units.kg
#-------------------------------------------------------------------------------
# Calculated Weights
#-------------------------------------------------------------------------------
# Preparatory Calculations
rho_ref = 1.225
Vtip = speed_of_sound * tipMach # Prop Tip Velocity
omega = Vtip/rRotor # Prop Ang. Velocity
maxLift = config.mass_properties.max_takeoff * ToverW # Maximum Thrust
Ct = maxLift/(rho_ref*np.pi*rRotor**2*Vtip**2) # Thrust Coefficient
AvgCL = 6 * Ct / rotor_bladeSol # Average Blade CL
AvgCD = 0.012 # Average Blade CD
maxLiftPower = 1.15*maxLift*(k*np.sqrt(maxLift/(2*rho_ref*np.pi*rRotor**2)) +
rotor_bladeSol*AvgCD/8*Vtip**3/(maxLift/(rho_ref*np.pi*rRotor**2)))
maxTorque = maxLiftPower/omega
# Component Weight Calculations
output.lift_rotors = (prop(config.propulsors.propulsor.rotor, maxLift) * (len(config.wings['main_wing'].motor_spanwise_locations)))*Units.kg
output.thrust_rotors = prop(config.propulsors.propulsor.propeller, maxLift/5) *Units.kg
output.fuselage = fuselage(config) *Units.kg
output.wiring = wiring(config, np.ones(8)**0.25, maxLiftPower/etaMotor) *Units.kg
output.wings = Data()
total_wing_weight = 0.
for w in config.wings:
wing_tag = w.tag
if (wing_tag.find('main_wing') != -1):
wing_weight = wing(config.wings[w.tag], config, maxLift/5, safety_factor= safety_factor, max_g_load = max_g_load ) *Units.kg
tag = wing_tag
output.wings[tag] = wing_weight
total_wing_weight = total_wing_weight + wing_weight
output.total_wing_weight = total_wing_weight
#-------------------------------------------------------------------------------
# Weight Summations
#-------------------------------------------------------------------------------
output.structural = (output.lift_rotors +
output.thrust_rotors +
output.hubs +
output.fuselage +
output.landing_gear +
output.total_wing_weight
) *Units.kg
output.empty = (contingency_factor * (
output.structural +
output.seats +
output.avionics +
output.motors +
output.servos +
output.wiring +
output.brs
) + output.battery) *Units.kg
output.total = (output.empty +
output.payload) *Units.kg
return output
def empty(config,
speed_of_sound=340.294,
max_tip_mach=0.65,
disk_area_factor=1.15,
max_thrust_to_weight_ratio=1.1,
motor_efficiency=0.85 * 0.98):
"""weight = SUAVE.Methods.Weights.Buildups.electricTiltrotor.empty(
config,
speed_of_sound = 340.294,
max_tip_mach = 0.65,
disk_area_factor = 1.15,
max_thrust_to_weight_ratio = 1.1,
motor_efficience = 0.85 * 0.98)
Calculates the empty fuselage mass for an electric tiltrotor including
seats, avionics, servomotors, ballistic recovery system, rotor and hub
assembly, transmission, and landing gear. Additionally incorporates
results of the following correlation scripts:
fuselage,py
prop.py
wing.py
wiring.py
Originally written as part of an AA 290 project inteded for trade study
of the Electric Tiltrotor along with the following defined SUAVE vehicle types:
Electric Helicopter
Electric Stopped Rotor
Sources:
Project Vahana Conceptual Trade Study
Inputs:
config SUAVE Config Data Structure
speed_of_sound Local Speed of Sound [m/s]
max_tip_mach Allowable Tip Mach Number [Unitless]
disk_area_factor Inverse of Disk Area Efficiency [Unitless]
max_thrust_to_weight_ratio Allowable Thrust to Weight Ratio [Unitless]
motor_efficiency Motor Efficiency [Unitless]
Outputs:
output: Data Dictionary of Component Masses [kg]
"""
output = Data()
#-------------------------------------------------------------------------------
# Assumed Weights
#-------------------------------------------------------------------------------
output.payload = config.propulsors.network.payload.mass_properties.mass
output.seats = 30.
output.avionics = 15.
output.motors = 10 * config.propulsors.network.number_of_engines
output.battery = config.propulsors.network.battery.mass_properties.mass
output.servos = 0.65 * config.propulsors.network.number_of_engines
output.rotor_servos = 2 * (
len(config.wings['main_wing'].motor_spanwise_locations) +
len(config.wings['main_wing'].motor_spanwise_locations))
output.brs = 16.
output.hubs = 2 * config.propulsors.network.number_of_engines
output.landing_gear = config.mass_properties.max_takeoff * 0.02
#-------------------------------------------------------------------------------
# Calculated Weights
#-------------------------------------------------------------------------------
# Preparatory Calculations
sound = speed_of_sound
tipMach = max_tip_mach
k = disk_area_factor
ToverW = max_thrust_to_weight_ratio
etaMotor = motor_efficiency
Vtip = sound * tipMach # Prop Tip Velocity
omega = Vtip / 0.8 # Prop Ang. Velocity
maxLift = config.mass_properties.max_takeoff * ToverW # Maximum Thrust
Ct = maxLift / (1.225 * np.pi * 0.8**2 * Vtip**2) # Thrust Coefficient
bladeSol = 0.1 # Blade Solidity
AvgCL = 6 * Ct / bladeSol # Average Blade CL
AvgCD = 0.012 # Average Blade CD
maxLiftPower = 1.15 * maxLift * (k * np.sqrt(maxLift /
(2 * 1.225 * np.pi * 0.8**2))
+ bladeSol * AvgCD / 8 * Vtip**3 /
(maxLift / (1.225 * np.pi * 0.8**2)))
maxTorque = maxLiftPower / omega
# Component Weight Calculations
output.lift_rotors = (
prop(config.propulsors.network.propeller, maxLift) *
(len(config.wings['main_wing'].motor_spanwise_locations) +
len(config.wings['main_wing'].motor_spanwise_locations)))
output.fuselage = fuselage(config)
output.wiring = wiring(config, np.ones(8)**0.25, maxLiftPower / etaMotor)
output.main_wing = wing(config.wings['main_wing'], config, maxLift / 5)
output.sec_wing = wing(config.wings['secondary_wing'], config, maxLift / 5)
#-------------------------------------------------------------------------------
# Weight Summations
#-------------------------------------------------------------------------------
output.structural = (output.lift_rotors + output.hubs + output.fuselage +
output.landing_gear + output.main_wing +
output.sec_wing)
output.empty = 1.1 * (output.structural + output.seats + output.avionics +
output.battery + output.motors + output.servos +
output.rotor_servos + output.wiring + output.brs)
output.total = (output.empty + output.payload)
return output