Provides structural weight correlations for aircraft components based on the FLOPS method.
More...
|
| def | SUAVE.Methods.Weights.Correlations.FLOPS.fuselage.fuselage_weight_FLOPS (vehicle) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.landing_gear.landing_gear_FLOPS (vehicle) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.operating_items.operating_items_FLOPS (vehicle) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.payload.payload_FLOPS (vehicle, weight_per_passenger=165. *Units.lb) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.total_prop_flops (vehicle, prop) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.nacelle_FLOPS (prop, nacelle) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.thrust_reverser_FLOPS (prop) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.misc_engine_FLOPS (vehicle, prop, nacelle) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.fuel_system_FLOPS (vehicle, NENG) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.engine_FLOPS (vehicle, prop) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.systems.systems_FLOPS (vehicle) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.tail.tail_vertical_FLOPS (vehicle, wing) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.wing_weight_FLOPS (vehicle, wing, WPOD, complexity, settings, num_main_wings) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.generate_wing_stations (fuselage_width, wing) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.generate_int_stations (NSD, ETA) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.calculate_load (ETA) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.find_sweep (y, lst_y, swp) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.get_spanwise_engine (networks, SEMISPAN) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.wing_weight_constants_FLOPS (ac_type) |
| |
| def | SUAVE.Methods.Weights.Correlations.FLOPS.wing.determine_fuselage_chord (fuselage_width, wing) |
| |
Provides structural weight correlations for aircraft components based on the FLOPS method.
◆ calculate_load()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.calculate_load |
( |
|
ETA | ) |
|
Returns load factor assuming elliptical load distribution
Assumptions:
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
ETA: list of spanwise locations of all sections of the wing
Outputs:
PS: load factor at every location in ETA assuming elliptical load distribution
Properties Used:
N/A
◆ determine_fuselage_chord()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.determine_fuselage_chord |
( |
|
fuselage_width, |
|
|
|
wing |
|
) |
| |
Determine chord at wing and fuselage intersection
Assumptions:
Fuselage side of body is between first and second wing segments.
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
fuselage_width: width of fuselage [m]
wing: data dictionary with wing properties
-.taper: taper ratio
-.sweeps.quarter_chord: quarter chord sweep angle [deg]
-.thickness_to_chord: thickness to chord
-.spans.projected: wing span [m]
-.chords.root: root chord [m]
-.fuselages.fuselage.width: fuselage width [m]
Outputs:
chord: chord length of wing where wing intersects the fuselage wall [ft]
Properties Used:
N/A
◆ engine_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.engine_FLOPS |
( |
|
vehicle, |
|
|
|
prop |
|
) |
| |
Calculates the dry engine weight based on the FLOPS method
Assumptions:
Rated thrust per scaled engine and rated thurst for baseline are the same
Engine weight scaling parameter is 1.15
Enginge inlet weight scaling exponent is 1
Baseline inlet weight is 0 lbs as in example files FLOPS
Baseline nozzle weight is 0 lbs as in example files FLOPS
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.systems.accessories: type of aircraft (short-range, commuter
medium-range, long-range,
sst, cargo)
prop - data dictionary for the specific network that is being estimated [dimensionless]
-.sealevel_static_thrust: sealevel static thrust of engine [N]
Outputs:
WENG: dry engine weight [kg]
Properties Used:
N/A
◆ find_sweep()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.find_sweep |
( |
|
y, |
|
|
|
lst_y, |
|
|
|
swp |
|
) |
| |
Finds sweep angle for a certain y-location along the wing
Assumptions:
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
y: spanwise location
lst_y: list of spanwise stations where sweep is known (eg sections)
swp: list of quarter chord sweep angles at the locations listed in lst_y
Outputs:
swps: sweep angle at y
Properties Used:
N/A
◆ fuel_system_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.fuel_system_FLOPS |
( |
|
vehicle, |
|
|
|
NENG |
|
) |
| |
Calculates the weight of the fuel system based on the FLOPS method
Assumptions:
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.design_mach_number: design mach number
-.mass_properties.max_zero_fuel: maximum zero fuel weight [kg]
Outputs:
WFSYS: Fuel system weight [kg]
Properties Used:
N/A
◆ fuselage_weight_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.fuselage.fuselage_weight_FLOPS |
( |
|
vehicle | ) |
|
Calculate the weight of the fuselage of a transport aircraft
Assumptions:
NFUSE = 1, only one fuselage (it's possible to modify this in future work)
delta_isa = 0, for pressure calculations
Fuselage is tagged as 'fuselage'
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.networks: data dictionary containing all propulsion properties
-.fuselages['fuselage'].lengths.total: fuselage total length [meters]
-.fuselages['fuselage'].width: fuselage width [meters]
-.fuselages['fuselage'].heights.maximum: fuselage maximum height [meters]
-.envelope.ultimate_load: ultimate load factor (default: 3.75)
-.systems.accessories: type of aircraft (short-range, commuter
medium-range, long-range,
sst, cargo)
-.mass_properties.max_takeoff: MTOW [kilograms]
-.design_mach_number: design mach number for cruise flight
Outputs:
WFUSE - weight of the fuselage [kilograms]
Properties Used:
N/A
◆ generate_int_stations()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.generate_int_stations |
( |
|
NSD, |
|
|
|
ETA |
|
) |
| |
Divides half of the wing in integration stations
Assumptions:
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
NSD: number of integration stations requested
ETA: list of spanwise locations of all sections of the wing
Outputs:
NS: actual number of integration stations
Y: spanwise locations of the integrations stations normalized by half span
Properties Used:
N/A
◆ generate_wing_stations()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.generate_wing_stations |
( |
|
fuselage_width, |
|
|
|
wing |
|
) |
| |
Divides half the wing in sections, using the defined sections
and adding a section at the intersection of wing and fuselage
Assumptions:
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
fuselage_width: fuselage width [m]
wing: data dictionary with wing properties
-.taper: taper ration wing
-.sweeps.quarter_chord: quarter chord sweep angle [deg]
-.thickness_to_chord: thickness to chord
-.spans.projected: wing span [m]
-.chords.root: root chord [m]
-.tip.root: tip chord [m]
-.twists.root: twist of wing at root [deg]
-.twists.tip: twist of wing at tip [deg]
-.Segments: trapezoidal segments of the wing
Outputs:
ETA: spanwise location of the sections normalized by half span
C: chord lengths at every spanwise location in ETA normalized by half span
T: thickness to chord ratio at every span wise location in ETA
SWP: quarter chord sweep angle at every span wise location in ETA
Properties Used:
N/A
◆ get_spanwise_engine()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.get_spanwise_engine |
( |
|
networks, |
|
|
|
SEMISPAN |
|
) |
| |
Returns EETA for the engine locations along the wing
Assumptions:
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
networks: data dictionary with all the engine properties
-.wing_mounted: list of boolean if engine is mounted to wing
-.number_of_engines: number of engines
-.origin: origin of the engine
SEMISPAN: half span [m]
Outputs:
EETA: span wise locations of the engines mounted to the wing normalized by the half span
Properties Used:
N/A
◆ landing_gear_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.landing_gear.landing_gear_FLOPS |
( |
|
vehicle | ) |
|
Calculate the weight of the main and nose landing gear of a transport aircraft
Assumptions:
No fighter jet, change DFTE to 1 for a fighter jet
Aircraft is not meant for carrier operations, change CARBAS to 1 for carrier-based aircraft
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.networks: data dictionary containing all propulsion properties
-.design_range: design range of aircraft [nmi]
-.systems.accessories: type of aircraft (short-range, commuter
medium-range, long-range,
sst, cargo)
-.mass_properties.max_takeoff: MTOW [kilograms]
-.nacelles['nacelle'] [meters]
-.wings['main_wing'].dihedral [radians]
-.fuselages['fuselage'].width: fuselage width [meters]
-.fuselages['fuselage'].lengths.total: fuselage total length [meters]
Outputs:
output - data dictionary with main and nose landing gear weights [kilograms]
output.main, output.nose
Properties Used:
N/A
◆ misc_engine_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.misc_engine_FLOPS |
( |
|
vehicle, |
|
|
|
prop, |
|
|
|
nacelle |
|
) |
| |
Calculates the miscellaneous engine weight based on the FLOPS method, electrical control system weight
and starter engine weight
Assumptions:
1) All nacelles are identical
2) The number of nacelles is the same as the number of engines
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.design_mach_number: design mach number
prop - data dictionary for the specific network that is being estimated [dimensionless]
-.number_of_engines: number of engines
-.sealevel_static_thrust: sealevel static thrust of engine [N]
nacelle
-.diameter: diameter of nacelle [m]
Outputs:
WEC: electrical engine control system weight [kg]
WSTART: starter engine weight [kg]
Properties Used:
N/A
◆ nacelle_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.nacelle_FLOPS |
( |
|
prop, |
|
|
|
nacelle |
|
) |
| |
Calculates the nacelle weight based on the FLOPS method
Assumptions:
1) All nacelles are identical
2) The number of nacelles is the same as the number of engines
Source:
Aircraft Design: A Conceptual Approach
Inputs:
prop - data dictionary for the specific network that is being estimated [dimensionless]
-.number_of_engines: number of engines
-.engine_lenght: total length of engine [m]
-.sealevel_static_thrust: sealevel static thrust of engine [N]
nacelle.
-.diameter: diameter of nacelle [m]
WENG - dry engine weight [kg]
Outputs:
WNAC: nacelle weight [kg]
Properties Used:
N/A
◆ operating_items_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.operating_items.operating_items_FLOPS |
( |
|
vehicle | ) |
|
Calculate the weight of operating items, including:
- crew
- baggage
- unusable fuel
- engine oil
- passenger service
- ammunition and non-fixed weapons
- cargo containers
Assumptions:
If no tanks are specified, 5 fuel tanks are assumed (includes main and auxiliary tanks)
If the number of coach seats is not defined, then it assumed that 5% of
of the seats are first class and an additional 10 % are business class.
If the number of coach seats is defined, then the additional seats are 1/4 first class
and 3/4 business class
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.networks: data dictionary containing all propulsion properties
-.number_of_engines: number of engines
-.sealevel_static_thrust: thrust at sea level [N]
-.reference_area: wing surface area [m^2]
-.mass_properties.max_takeoff: MTOW [kilograms]
-.passengers: number of passengers in aircraft
-.design_mach_number: design mach number for cruise flight
-.design_range: design range of aircraft [nmi]
-.mass_properties.cargo: weight of cargo carried [kilograms]
Outputs:
output - data dictionary with weights [kilograms]
- output.oper_items: unusable fuel, engine oil, passenger service weight and cargo containers
- output.flight_crew: flight crew weight
- output.flight_attendants: flight attendants weight
- output.total: total operating items weight
Properties Used:
N/A
◆ payload_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.payload.payload_FLOPS |
( |
|
vehicle, |
|
|
|
weight_per_passenger = 165. * Units.lb |
|
) |
| |
Calculate the payload weight, including:
- passenger and carry-on weight
- baggage weight
- cargo weight
Assumptions:
None
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.passengers: number of passengers in aircraft
-.design_range: design range of aircraft [nmi]
-.mass_properties.cargo: weight of cargo carried [kilograms]
Outputs:
output - data dictionary with weights [kilograms]
- output.passengers: passenger weight
- output.baggage: baggage weight
- output.cargo: cargo weight
- output.total: total payload weight
Properties Used:
N/A
◆ systems_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.systems.systems_FLOPS |
( |
|
vehicle | ) |
|
Calculate the system weight of the aircraft including:
- flight control system
- apu weight
- hydraulics and pneumatics weight
- intstrumentation weight
- avionics weight
- electrical system weight
- air-condtioning weight
- furnishing weight
- anti-ice weight
Assumptions:
1) No variable sweep, change VARSWP to 1 is variable sweep in aicraft
2) Hydraulic pressure is 3000 psf (HYDR)
3) 1 fuselage named fuselage. Function could be modified to allow multiple fuselages by
relaxing this assumption.
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.networks: data dictionary containing all propulsion properties
-.number_of_engines: number of engines
-.sealevel_static_thrust: thrust at sea level [N]
-.fuselages['fuselage'].lengths.total: fuselage total length [meters]
-.fuselages['fuselage'].width: fuselage width [meters]
-.fuselages['fuselage'].heights.maximum: fuselage maximum height[meters]
-.mass_properties.max_takeoff: MTOW [kilograms]
-.design_mach_number: design mach number for cruise flight
-.design_range: design range of aircraft [nmi]
-.passengers: number of passengers in aircraft
-.wings['main_wing']: data dictionary with main wing properties
-.sweeps.quarter_chord: quarter chord sweep [deg]
-.areas.reference: wing surface area [m^2]
-.spans.projected: projected span of wing [m]
-.flap_ratio: flap surface area over wing surface area
Outputs:
output - a data dictionary with fields:
wt_flt_ctrl - weight of the flight control system [kilograms]
wt_apu - weight of the apu [kilograms]
wt_hyd_pnu - weight of the hydraulics and pneumatics [kilograms]
wt_instruments - weight of the instruments and navigational equipment [kilograms]
wt_avionics - weight of the avionics [kilograms]
wt_elec - weight of the electrical items [kilograms]
wt_ac - weight of the air conditioning and anti-ice system [kilograms]
wt_furnish - weight of the furnishings in the fuselage [kilograms]
wt_anti_ice - weight of anti-ice system [kilograms]
Properties Used:
N/A
◆ tail_vertical_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.tail.tail_vertical_FLOPS |
( |
|
vehicle, |
|
|
|
wing |
|
) |
| |
Calculate the vertical tail weight
Assumptions:
Conventional tail configuration
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.mass_properties.max_takeoff: MTOW [kilograms]
wing - data dictionary with vertical tail properties [dimensionless]
-.taper: taper of wing
-.areas.reference: surface area of wing [m^2]
Outputs:
WVT - vertical tail weight [kilograms]
Properties Used:
N/A
◆ thrust_reverser_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.thrust_reverser_FLOPS |
( |
|
prop | ) |
|
Calculates the weight of the thrust reversers of the aircraft
Assumptions:
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
prop - data dictionary for the specific network that is being estimated [dimensionless]
-.number_of_engines: number of engines
-.sealevel_static_thrust: sealevel static thrust of engine [N]
Outputs:
WTHR: Thrust reversers weight [kg]
Properties Used:
N/A
◆ total_prop_flops()
| def SUAVE.Methods.Weights.Correlations.FLOPS.prop_system.total_prop_flops |
( |
|
vehicle, |
|
|
|
prop |
|
) |
| |
Calculate the weight of propulsion system, including:
- dry engine weight
- fuel system weight
- thurst reversers weight
- electrical system weight
- starter engine weight
- nacelle weight
- cargo containers
Assumptions:
1) Rated thrust per scaled engine and rated thurst for baseline are the same
2) Engine weight scaling parameter is 1.15
3) Enginge inlet weight scaling exponent is 1
4) Baseline inlet weight is 0 lbs as in example files FLOPS
5) Baseline nozzle weight is 0 lbs as in example files FLOPS
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.design_mach_number: design mach number for cruise flight
-.mass_properties.max_zero_fuel: zero fuel weight [kg]
-.systems.accessories: type of aircraft (short-range, commuter
medium-range, long-range,
sst, cargo)
nacelle - data dictionary with propulsion system properties
-.diameter: diameter of nacelle [meters]
-.length: length of complete engine assembly [meters]
prop.
-.sealevel_static_thrust: thrust at sea level [N]
Outputs:
output - data dictionary with weights [kilograms]
- output.wt_prop: total propulsive system weight
- output.wt_thrust_reverser: thurst reverser weight
- output.starter: starter engine weight
- output.wt_engine_controls: engine controls weight
- output.fuel_system: fuel system weight
- output.nacelle: nacelle weight
- output.wt_eng: dry engine weight
Properties Used:
N/A
◆ wing_weight_constants_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.wing_weight_constants_FLOPS |
( |
|
ac_type | ) |
|
Defines wing weight constants as defined by FLOPS
Inputs: ac_type - determines type of instruments, electronics, and operating items based on types:
"short-range", "medium-range", "long-range", "business", "cargo", "commuter", "sst"
Outputs: list of coefficients used in weight estimations
◆ wing_weight_FLOPS()
| def SUAVE.Methods.Weights.Correlations.FLOPS.wing.wing_weight_FLOPS |
( |
|
vehicle, |
|
|
|
wing, |
|
|
|
WPOD, |
|
|
|
complexity, |
|
|
|
settings, |
|
|
|
num_main_wings |
|
) |
| |
Calculate the wing weight based on the flops method. The wing weight consists of:
- Total Wing Shear Material and Control Surface Weight
- Total Wing Miscellaneous Items Weight
- Total Wing Bending Material Weight
Assumptions:
Wing is elliptically loaded
Gloved wing area is 0
Load between multiple main wings is distributed equally
Wing sweep is fixed
Source:
The Flight Optimization System Weight Estimation Method
Inputs:
vehicle - data dictionary with vehicle properties [dimensionless]
-.reference_area: wing surface area [m^2]
-.mass_properties.max_takeoff: MTOW [kilograms]
-.envelope.ultimate_load: ultimate load factor (default: 3.75)
-.systems.accessories: type of aircraft (short-range, commuter
medium-range, long-range,
sst, cargo)
-.fuselages.fuselage.width: width of the fuselage [m]
-wing: data dictionary with wing properties
-.taper: taper ratio
-.sweeps.quarter_chord: quarter chord sweep angle [deg]
-.thickness_to_chord: thickness to chord
-.spans.projected: wing span [m]
-.chords.root: root chord [m]
-.tip.root: tip chord [m]
-.twists.root: twist of wing at root [deg]
-.twists.tip: twist of wing at tip [deg]
-.flap_ratio: flap surface area over wing surface area
-.networks: data dictionary containing all propulsion properties
-.number_of_engines: number of engines
-.sealevel_static_thrust: thrust at sea level [N]
WPOD - weight of engine pod including the nacelle [kilograms]
complexity - "simple" or "complex" depending on the wing weight method chosen
Outputs:
WWING - wing weight [kilograms]
Properties Used:
N/A
1.8.15