diff --git a/.buildinfo b/.buildinfo new file mode 100644 index 000000000..fa2122c30 --- /dev/null +++ b/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. +config: 7ab6931bf2e95e45747a13bb53f460b5 +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 000000000..e69de29bb diff --git a/_images/N2_phases.PNG b/_images/N2_phases.PNG new file mode 100644 index 000000000..225a77297 Binary files /dev/null and b/_images/N2_phases.PNG differ diff --git a/_images/N2_phases_links.PNG b/_images/N2_phases_links.PNG new file mode 100644 index 000000000..e7ead84f3 Binary files /dev/null and b/_images/N2_phases_links.PNG differ diff --git a/_images/N2_start.PNG b/_images/N2_start.PNG new file mode 100644 index 000000000..757ecd2d5 Binary files /dev/null and b/_images/N2_start.PNG differ diff --git a/_images/N2_top.PNG b/_images/N2_top.PNG new file mode 100644 index 000000000..62a74ccf8 Binary files /dev/null and b/_images/N2_top.PNG differ diff --git a/_images/advanced_results.png b/_images/advanced_results.png new file mode 100644 index 000000000..2b703df10 Binary files /dev/null and b/_images/advanced_results.png differ diff --git a/_images/aircraft_force_diagram.png b/_images/aircraft_force_diagram.png new file mode 100644 index 000000000..08898fefe Binary files /dev/null and b/_images/aircraft_force_diagram.png differ diff --git a/_images/aviary_process.png b/_images/aviary_process.png new file mode 100644 index 000000000..29598bfc5 Binary files /dev/null and b/_images/aviary_process.png differ diff --git a/_images/blank_flight_profile.png b/_images/blank_flight_profile.png new file mode 100644 index 000000000..7780a8421 Binary files /dev/null and b/_images/blank_flight_profile.png differ diff --git a/_images/cubic_advanced_results.png b/_images/cubic_advanced_results.png new file mode 100644 index 000000000..dffa657d9 Binary files /dev/null and b/_images/cubic_advanced_results.png differ diff --git a/_images/dashboard.png b/_images/dashboard.png new file mode 100644 index 000000000..02d3eaca1 Binary files /dev/null and b/_images/dashboard.png differ diff --git a/_images/driver_scaling_report_top.PNG b/_images/driver_scaling_report_top.PNG new file mode 100644 index 000000000..27ec57d25 Binary files /dev/null and b/_images/driver_scaling_report_top.PNG differ diff --git a/_images/expected_user_knowledge.svg b/_images/expected_user_knowledge.svg new file mode 100644 index 000000000..6196377f6 --- /dev/null +++ b/_images/expected_user_knowledge.svg @@ -0,0 +1 @@ +Aircraft DesignOptimizationProgrammingDependenciesRelative knowledge expectedAircraft DesignOptimizationProgrammingDependenciesAircraft DesignOptimizationProgrammingDependenciesLevel 1Level 2Level 3 \ No newline at end of file diff --git a/_images/external_subsystem_methods.png b/_images/external_subsystem_methods.png new file mode 100644 index 000000000..66f41af4e Binary files /dev/null and b/_images/external_subsystem_methods.png differ diff --git a/_images/failing_pr.png b/_images/failing_pr.png new file mode 100644 index 000000000..1039e6eca Binary files /dev/null and b/_images/failing_pr.png differ diff --git a/_images/flight_profile.png b/_images/flight_profile.png new file mode 100644 index 000000000..4fca40787 Binary files /dev/null and b/_images/flight_profile.png differ diff --git a/_images/gh_actions.png b/_images/gh_actions.png new file mode 100644 index 000000000..d9b4b4158 Binary files /dev/null and b/_images/gh_actions.png differ diff --git a/_images/gui.png b/_images/gui.png new file mode 100644 index 000000000..c088f0126 Binary files /dev/null and b/_images/gui.png differ diff --git a/_images/input_list_top.PNG b/_images/input_list_top.PNG new file mode 100644 index 000000000..76063cfb4 Binary files /dev/null and b/_images/input_list_top.PNG differ diff --git a/_images/inputs_html_top.PNG b/_images/inputs_html_top.PNG new file mode 100644 index 000000000..ce9890636 Binary files /dev/null and b/_images/inputs_html_top.PNG differ diff --git a/_images/levels.png b/_images/levels.png new file mode 100644 index 000000000..2cabafc0e Binary files /dev/null and b/_images/levels.png differ diff --git a/_images/mission_simple.png b/_images/mission_simple.png new file mode 100644 index 000000000..93b5dfd8c Binary files /dev/null and b/_images/mission_simple.png differ diff --git a/_images/more_levels.png b/_images/more_levels.png new file mode 100644 index 000000000..6d035677d Binary files /dev/null and b/_images/more_levels.png differ diff --git a/_images/multiphase_flight_profile.png b/_images/multiphase_flight_profile.png new file mode 100644 index 000000000..62b009c9c Binary files /dev/null and b/_images/multiphase_flight_profile.png differ diff --git a/_images/multiple_phases_gui.png b/_images/multiple_phases_gui.png new file mode 100644 index 000000000..304343118 Binary files /dev/null and b/_images/multiple_phases_gui.png differ diff --git a/_images/opt_report_top.PNG b/_images/opt_report_top.PNG new file mode 100644 index 000000000..56118d7fd Binary files /dev/null and b/_images/opt_report_top.PNG differ diff --git a/_images/pre_mission_and_mission.svg b/_images/pre_mission_and_mission.svg new file mode 100644 index 000000000..31533b430 --- /dev/null +++ b/_images/pre_mission_and_mission.svg @@ -0,0 +1 @@ +Pre-missionValues do not vary with timeGeometryWeightsAerodynamics pre-calculationsMissionValues can vary across the missionPropulsionAerodynamicsEquations of motion \ No newline at end of file diff --git a/_images/sample_aviary_xdsm.PNG b/_images/sample_aviary_xdsm.PNG new file mode 100644 index 000000000..8a2a59d18 Binary files /dev/null and b/_images/sample_aviary_xdsm.PNG differ diff --git a/_images/subsystems.png b/_images/subsystems.png new file mode 100644 index 000000000..875b338b3 Binary files /dev/null and b/_images/subsystems.png differ diff --git a/_images/tool_stack.svg b/_images/tool_stack.svg new file mode 100644 index 000000000..e023725d8 --- /dev/null +++ b/_images/tool_stack.svg @@ -0,0 +1 @@ +OpenMDAODymosAviary:modelsAviary: platform and toolFLOPS-inspiredGASP-inspired \ No newline at end of file diff --git a/_images/traj_linkage_report_top.PNG b/_images/traj_linkage_report_top.PNG new file mode 100644 index 000000000..97c8a6fdf Binary files /dev/null and b/_images/traj_linkage_report_top.PNG differ diff --git a/_images/traj_results.png b/_images/traj_results.png new file mode 100644 index 000000000..625534814 Binary files /dev/null and b/_images/traj_results.png differ diff --git a/_images/traj_results_report_altitude.PNG b/_images/traj_results_report_altitude.PNG new file mode 100644 index 000000000..8e2185eb7 Binary files /dev/null and b/_images/traj_results_report_altitude.PNG differ diff --git a/_images/traj_results_report_top.PNG b/_images/traj_results_report_top.PNG new file mode 100644 index 000000000..f0b3210d4 Binary files /dev/null and b/_images/traj_results_report_top.PNG differ diff --git a/_images/traj_results_report_top_ascent.PNG b/_images/traj_results_report_top_ascent.PNG new file mode 100644 index 000000000..519434c8d Binary files /dev/null and b/_images/traj_results_report_top_ascent.PNG differ diff --git a/_modules/aviary/interface/cmd_entry_points.html b/_modules/aviary/interface/cmd_entry_points.html new file mode 100644 index 000000000..47712cd7e --- /dev/null +++ b/_modules/aviary/interface/cmd_entry_points.html @@ -0,0 +1,634 @@ + + + + + + + + + + + aviary.interface.cmd_entry_points + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.interface.cmd_entry_points

+import argparse
+import os
+import sys
+
+import aviary
+from aviary.interface.methods_for_level1 import _exec_level1, _setup_level1_parser
+from aviary.utils.Fortran_to_Aviary import _exec_F2A, _setup_F2A_parser
+from aviary.visualization.dashboard import _dashboard_setup_parser, _dashboard_cmd
+from aviary.interface.graphical_input import IntegratedPlottingApp
+
+
+def _setup_flight_profile_parser(parser):
+    """
+    Set up the command line options for the Flight Profile plotting tool.
+
+    Parameters
+    ----------
+    parser : argparse.ArgumentParser
+        The parser instance.
+    """
+    pass
+
+
+def _exec_flight_profile(options, user_args):
+    """
+    Run the Flight Profile plotting tool.
+
+    Parameters
+    ----------
+    options : argparse.Namespace
+        Command line options.
+    user_args : list of str
+        Args to be passed to the user script.
+    """
+    app = IntegratedPlottingApp()
+    app.mainloop()
+
+
+def _load_and_exec(script_name, user_args):
+    """
+    Load and exec the given script as __main__.
+
+    Parameters
+    ----------
+    script_name : str
+        The name of the script to load and exec.
+    user_args : list of str
+        Args to be passed to the user script.
+    """
+
+    sys.path.insert(0, os.path.dirname(script_name))
+
+    sys.argv[:] = [script_name] + user_args
+
+    with open(script_name, 'rb') as fp:
+        code = compile(fp.read(), script_name, 'exec')
+
+    globals_dict = {
+        '__file__': script_name,
+        '__name__': '__main__',
+        '__package__': None,
+        '__cached__': None,
+    }
+
+    exec(code, globals_dict)  # nosec: private, internal use only
+
+
+_command_map = {
+    'fortran_to_aviary': (_setup_F2A_parser, _exec_F2A,
+                          "Converts legacy Fortran input decks to Aviary csv based decks"),
+    'run_mission': (_setup_level1_parser, _exec_level1,
+                    "Runs Aviary using a provided input deck"),
+    'draw_mission': (_setup_flight_profile_parser, _exec_flight_profile,
+                     "Allows users to draw a mission profile for use in Aviary."),
+    'dashboard': (_dashboard_setup_parser, _dashboard_cmd,
+                  "Run the Dashboard tool"),
+}
+
+
+
[docs]def aviary_cmd():
+    """
+    Run an 'aviary' sub-command or list help info for 'aviary' command or sub-commands.
+    """
+    # pre-parse sys.argv to split between before and after '--'
+    if '--' in sys.argv:
+        idx = sys.argv.index('--')
+        sys_args = sys.argv[:idx]
+        user_args = sys.argv[idx + 1:]
+        sys.argv[:] = sys_args
+    else:
+        user_args = []
+
+    parser = argparse.ArgumentParser(description='aviary Command Line Tools',
+                                     #  epilog='Use -h after any sub-command for sub-command help, '
+                                     #  'for example, "openmdao tree -h" for help on the "tree" '
+                                     #  'command. If using a tool on a script that takes its own '
+                                     #  'command line arguments, place those arguments after a "--". '
+                                     #  'For example: '
+                                     #  '"openmdao n2 -o foo.html myscript.py -- -x --myarg=bar"'
+                                     )
+
+    # Adding the --version argument
+    parser.add_argument('--version', action='store_true', help='show version and exit')
+
+    subs = parser.add_subparsers(title='Tools', metavar='', dest="subparser_name")
+    for p, (parser_setup_func, executor, help_str) in sorted(_command_map.items()):
+        subp = subs.add_parser(p, help=help_str)
+        parser_setup_func(subp)
+        subp.set_defaults(executor=executor)
+
+    args = [a for a in sys.argv[1:] if not a.startswith('-')]
+    # '--version', '--dependency_versions')]
+    cmdargs = [a for a in sys.argv[1:] if a not in ('-h',)]
+
+    if len(args) == 1 and len(user_args) == 0:
+        if args[0] != 'draw_mission' and args[0] != 'run_mission':
+            parser.parse_args([args[0], '-h'])
+
+    if not set(args).intersection(subs.choices) and len(args) == 1 and os.path.isfile(cmdargs[0]):
+        _load_and_exec(args[0], user_args)
+    else:
+        options, unknown = parser.parse_known_args()
+
+        # Check if --version was passed
+        if options.version:
+            print(f"Aviary version: {aviary.__version__}")
+            return
+
+        if unknown:
+            msg = 'unrecognized arguments: ' + ', '.join(unknown)
+            try:
+                sub = subs.choices[options.subparser_name]
+            except KeyError:
+                parser.error(msg)
+            else:
+                print(sub.format_usage(), file=sys.stderr)
+                print(msg, file=sys.stderr)
+            parser.exit(2)
+
+        if hasattr(options, 'executor'):
+            options.executor(options, user_args)
+        else:
+            os.system('aviary -h')

+
+
+if __name__ == '__main__':
+    aviary_cmd()
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/interface/graphical_input.html b/_modules/aviary/interface/graphical_input.html new file mode 100644 index 000000000..d193e9848 --- /dev/null +++ b/_modules/aviary/interface/graphical_input.html @@ -0,0 +1,1051 @@ + + + + + + + + + + + aviary.interface.graphical_input + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.interface.graphical_input

+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import shutil
+from tkinter import messagebox
+import tkinter as tk
+from tkinter import messagebox, font as tkFont
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backend_bases import MouseButton
+import subprocess
+import os
+
+
+
[docs]class DraggablePoints:
+
[docs]    def __init__(self, points, ax, canvas):
+        self.points = points
+        self.ax = ax
+        self.canvas = canvas
+        self.current_point = None
+        self.lines, = ax.plot([p[0] for p in points], [p[1] for p in points],
+                              linestyle='-', marker='o', color='b', markersize=8)
+
+        self.cid_click = ax.figure.canvas.mpl_connect(
+            'button_press_event', self.on_click)
+        self.cid_release = ax.figure.canvas.mpl_connect(
+            'button_release_event', self.on_release)
+        self.cid_motion = ax.figure.canvas.mpl_connect(
+            'motion_notify_event', self.on_motion)

+
+
[docs]    def on_click(self, event):
+        if event.inaxes != self.ax or event.button is not MouseButton.LEFT:
+            return
+        for i, point in enumerate(self.points):
+            if abs(point[0] - event.xdata) < 5.0 and abs(point[1] - event.ydata) < 5.0:
+                self.current_point = i
+                return

+
+
[docs]    def on_release(self, event):
+        self.current_point = None

+
+
[docs]    def on_motion(self, event):
+        if self.current_point is not None and event.xdata is not None and event.ydata is not None:
+            self.points[self.current_point] = (
+                self.points[self.current_point][0], event.ydata)
+            self.update_points(self.ax, self.points)

+
+
[docs]    def update_points(self, ax, data):
+        color = 'b'
+        label = 'Mach Number'
+        ax.clear()
+        ax.plot([p[0] for p in data], [p[1] for p in data], linestyle='-',
+                marker='o', color=color, markersize=8, label=label)
+
+        ax.set_xlim(0, 360)
+        ax.set_ylim(0, 1.0)
+
+        ax.figure.canvas.draw()

+
+
+
[docs]def create_phase_info(times, altitudes, mach_values,
+                      polynomial_order, num_segments, optimize_mach_phase_vars, optimize_altitude_phase_vars, user_choices):
+    """
+    Creates a dictionary containing the information about different flight phases
+    based on input times, altitudes, and Mach values.
+
+    The information includes details such as duration bounds, initial guesses,
+    and various options for optimization and control for each phase.
+
+    Parameters
+    ----------
+    times : list of float
+        The times at which phase changes occur, given in minutes.
+    altitudes : list of float
+        The altitudes corresponding to each phase, given in feet.
+    mach_values : list of float
+        The Mach numbers corresponding to each phase.
+
+    Returns
+    -------
+    dict
+        A dictionary with all the phase information, including bounds and initial guesses.
+    """
+    num_phases = len(times) - 1  # Number of phases is one less than the number of points
+    phase_info = {}
+
+    times = np.round(np.array(times)).astype(int)
+    altitudes = np.round(np.array(altitudes) / 500) * 500
+    mach_values = np.round(np.array(mach_values), 2)
+
+    # Utility function to create bounds
+    def create_bounds(center):
+        lower_bound = max(center / 2, 0.1)  # Ensuring lower bound is not less than 0.1
+        upper_bound = center * 1.5
+        return (lower_bound, upper_bound)
+
+    # Calculate duration bounds for each phase
+    duration_bounds = [create_bounds(times[i+1] - times[i])
+                       for i in range(num_phases)]
+
+    # Initialize the cumulative initial bounds
+    cumulative_initial_bounds = [(0., 0.)]  # Initial bounds for the first phase
+
+    # Calculate the cumulative initial bounds for subsequent phases
+    for i in range(1, num_phases):
+        previous_duration_bounds = duration_bounds[i-1]
+        previous_initial_bounds = cumulative_initial_bounds[-1]
+        new_initial_bound_min = previous_initial_bounds[0] + previous_duration_bounds[0]
+        new_initial_bound_max = previous_initial_bounds[1] + previous_duration_bounds[1]
+        cumulative_initial_bounds.append((new_initial_bound_min, new_initial_bound_max))
+
+    # Add pre_mission and post_mission phases
+    phase_info['pre_mission'] = {
+        'include_takeoff': False,
+        'optimize_mass': True,
+    }
+
+    climb_count = 1
+    cruise_count = 1
+    descent_count = 1
+
+    for i in range(num_phases):
+        initial_altitude = altitudes[i]
+        final_altitude = altitudes[i+1]
+
+        # Determine phase type: climb, cruise, or descent
+        if final_altitude > initial_altitude:
+            phase_type = 'climb'
+            phase_count = climb_count
+            climb_count += 1
+        elif final_altitude == initial_altitude:
+            phase_type = 'cruise'
+            phase_count = cruise_count
+            cruise_count += 1
+        else:
+            phase_type = 'descent'
+            phase_count = descent_count
+            descent_count += 1
+
+        phase_name = f'{phase_type}_{phase_count}'
+
+        phase_info[phase_name] = {
+            'subsystem_options': {
+                'core_aerodynamics': {'method': 'computed'}
+            },
+            'user_options': {
+                'optimize_mach': optimize_mach_phase_vars[i].get(),
+                'optimize_altitude': optimize_altitude_phase_vars[i].get(),
+                'polynomial_control_order': polynomial_order,
+                'use_polynomial_control': True,
+                'num_segments': num_segments,
+                'order': 3,
+                'solve_for_range': False,
+                'initial_mach': (mach_values[i], 'unitless'),
+                'final_mach': (mach_values[i+1], 'unitless'),
+                'mach_bounds': ((np.min(mach_values[i:i+2]) - 0.02, np.max(mach_values[i:i+2]) + 0.02), 'unitless'),
+                'initial_altitude': (altitudes[i], 'ft'),
+                'final_altitude': (altitudes[i+1], 'ft'),
+                'altitude_bounds': ((max(np.min(altitudes[i:i+2]) - 500., 0.), np.max(altitudes[i:i+2]) + 500.), 'ft'),
+                'throttle_enforcement': 'path_constraint' if (i == (num_phases - 1) or i == 0) else 'boundary_constraint',
+                'fix_initial': True if i == 0 else False,
+                'constrain_final': True if i == (num_phases - 1) else False,
+                'fix_duration': False,
+                'initial_bounds': (cumulative_initial_bounds[i], 'min'),
+                'duration_bounds': (duration_bounds[i], 'min'),
+            },
+            'initial_guesses': {
+                'times': ([times[i], times[i+1]-times[i]], 'min'),
+            }
+        }
+
+    phase_info['post_mission'] = {
+        'include_landing': False,
+        'constrain_range': True,
+        'target_range': (0., 'nmi'),
+    }
+
+    # Apply user choices to each phase
+    for phase_name, phase_data in phase_info.items():
+        if 'pre_mission' in phase_name or 'post_mission' in phase_name:
+            continue
+        phase_info[phase_name]['user_options'].update({
+            'solve_for_range': user_choices.get('solve_for_range', False),
+        })
+
+    # Apply global settings if required
+    phase_info['post_mission']['constrain_range'] = user_choices.get(
+        'constrain_range', True)
+
+    # Calculate the total range
+    total_range = estimate_total_range_trapezoidal(times, mach_values)
+    print(
+        f"Total range is estimated to be {total_range} nautical miles")
+
+    phase_info['post_mission']['target_range'] = (total_range, 'nmi')
+
+    filename = os.path.join(os.getcwd(), 'outputted_phase_info.py')
+
+    # write a python file with the phase information
+    with open(filename, 'w') as f:
+        f.write(f'phase_info = {phase_info}')
+
+    # Check for 'black' and format the file
+    if shutil.which('black'):
+        subprocess.run(['black', filename])
+    else:
+        if shutil.which('autopep8'):
+            subprocess.run(['autopep8', '--in-place', '--aggressive', filename])
+            print("File formatted using 'autopep8'")
+        else:
+            print("'black' and 'autopep8' are not installed. Please consider installing one of them for better formatting.")
+
+    print(f"Phase info has been saved and formatted in {filename}")
+
+    return phase_info

+
+
+
[docs]def estimate_total_range_trapezoidal(times, mach_numbers):
+    speed_of_sound = 343  # Speed of sound in meters per second
+
+    # Convert times to seconds from minutes
+    times_sec = np.array(times) * 60
+
+    # Calculate the speeds at each Mach number
+    speeds = np.array(mach_numbers) * speed_of_sound
+
+    # Use numpy's trapz function to integrate
+    total_range = np.trapz(speeds, times_sec)
+
+    total_range_nautical_miles = total_range / 1000 / 1.852
+    return int(round(total_range_nautical_miles))

+
+
+
[docs]class Tooltip:
+
[docs]    def __init__(self, ax, tooltip_func):
+        self.ax = ax
+        self.tooltip_func = tooltip_func
+        self.tooltip_widget = None
+        self._id = None

+
+    def __call__(self, event):
+        if event.inaxes == self.ax:
+            x, y = event.xdata, event.ydata
+            label = self.tooltip_func(x, y)
+            if label:
+                if not self.tooltip_widget:
+                    self.tooltip_widget = tk.Toplevel()
+                    self.tooltip_widget.wm_overrideredirect(True)
+                    self.label = tk.Label(self.tooltip_widget, text="", justify='left',
+                                          background='white', relief='solid', borderwidth=2,
+                                          font=("tahoma", "14", "normal"))
+                    self.label.pack(ipadx=1)
+                self.label.config(text=label)
+                self.tooltip_widget.geometry(
+                    f"+{event.guiEvent.x_root+10}+{event.guiEvent.y_root+10}")
+                self.tooltip_widget.deiconify()
+            else:
+                if self.tooltip_widget:
+                    self.tooltip_widget.withdraw()
+        else:
+            if self.tooltip_widget:
+                self.tooltip_widget.withdraw()

+
+
+
[docs]class IntegratedPlottingApp(tk.Tk):
+
+
[docs]    def __init__(self):
+        super().__init__()
+        self.title('Flight Profile Utility')
+        self.geometry('1200x900')
+
+        # Set default font for the application
+        default_font = tkFont.nametofont("TkDefaultFont")
+        default_font.configure(size=18)  # You can adjust the size as needed
+        self.option_add("*Font", default_font)
+
+        # You might also want to adjust the font of the Matplotlib plots:
+        plt.rc('font', size=12)  # Adjust the size as needed for Matplotlib plots
+
+        # Initialize data
+        self.altitude_data = [(0, 0)]
+        self.mach_data = [(0, 0.2)]
+
+        # Frame for plots
+        plot_frame = tk.Frame(self)
+        plot_frame.pack(side='left', fill='both', expand=True)
+
+        # Create Altitude Plot
+        self.fig_altitude, self.ax_altitude = plt.subplots()
+        self.setup_plot(self.ax_altitude)
+        self.canvas_altitude = FigureCanvasTkAgg(self.fig_altitude, master=plot_frame)
+        self.canvas_altitude.get_tk_widget().pack(side='top', fill='both', expand=1)
+
+        # Create Mach Plot
+        self.fig_mach, self.ax_mach = plt.subplots()
+        self.setup_plot(self.ax_mach)
+        self.canvas_mach = FigureCanvasTkAgg(self.fig_mach, master=plot_frame)
+        self.canvas_mach.get_tk_widget().pack(side='top', fill='both', expand=1)
+        self.draggable_points_mach = DraggablePoints(
+            self.mach_data, self.ax_mach, self.canvas_mach)
+
+        # Frame for checkboxes
+        checkbox_frame = tk.Frame(self)
+        checkbox_frame.pack(side='right', fill='y', expand=False)
+
+        # Checkboxes
+        self.optimize_mach_var = tk.BooleanVar()
+        self.constrain_range_var = tk.BooleanVar()
+        tk.Checkbutton(checkbox_frame, text="Constrain Range",
+                       variable=self.constrain_range_var).pack(anchor="w")
+        self.constrain_range_var.set(True)
+        self.solve_for_range_var = tk.BooleanVar()
+        tk.Checkbutton(checkbox_frame, text="Solve for Range",
+                       variable=self.solve_for_range_var).pack(anchor="w")
+
+        # Textbox for Polynomial Control Order
+        self.polynomial_order_var = tk.StringVar()
+        tk.Label(checkbox_frame, text="Polynomial Control Order").pack(anchor="w")
+        self.polynomial_order_entry = tk.Entry(
+            checkbox_frame, textvariable=self.polynomial_order_var)
+        self.polynomial_order_entry.pack(anchor="w")
+        self.polynomial_order_entry.insert(0, "1")
+
+        # Textbox for Number of Segments
+        self.num_segments_var = tk.StringVar(value="2")  # Default value set to "2"
+        tk.Label(checkbox_frame, text="Number of Segments").pack(anchor="w")
+        self.num_segments_entry = tk.Entry(
+            checkbox_frame, textvariable=self.num_segments_var)
+        self.num_segments_entry.pack(anchor="w")
+
+        self.cid_click_altitude = self.fig_altitude.canvas.mpl_connect(
+            'button_press_event', self.on_click)
+        self.cid_motion_altitude = self.fig_altitude.canvas.mpl_connect(
+            'motion_notify_event', self.on_motion)
+        self.cid_release_altitude = self.fig_altitude.canvas.mpl_connect(
+            'button_release_event', self.on_release)
+
+        # Done button
+        self.done_button = tk.Button(checkbox_frame, text="Done", command=self.on_done)
+        self.done_button.pack(side='top', pady=10)
+
+        # Help button
+        self.help_button = tk.Button(checkbox_frame, text="Help", command=self.show_help)
+        self.help_button.pack(side='top', pady=10)
+
+        # Frame for point entries
+        self.point_entry_frame = tk.Frame(checkbox_frame)
+        self.point_entry_frame.pack(side='top', expand=False)
+        self.altitude_entries = []
+        self.mach_entries = []
+
+        # Column labels
+        tk.Label(self.point_entry_frame, text="Altitude").grid(row=0, column=1)
+        tk.Label(self.point_entry_frame, text="Mach").grid(row=0, column=3)
+
+        # Frame for phase-specific checkboxes
+        self.phase_option_frame = tk.Frame(checkbox_frame)
+        self.phase_option_frame.pack(side='top', expand=False)
+
+        self.optimize_mach_phase_vars = []
+        self.optimize_altitude_phase_vars = []
+
+        # Tooltips for both plots
+        self.tooltip_altitude = Tooltip(self.ax_altitude, self.tooltip_func)
+        self.tooltip_mach = Tooltip(self.ax_mach, self.tooltip_func)
+
+        self.cid_motion_altitude = self.fig_altitude.canvas.mpl_connect(
+            'motion_notify_event', self.tooltip_altitude)
+        self.cid_motion_mach = self.fig_mach.canvas.mpl_connect(
+            'motion_notify_event', self.tooltip_mach)
+
+        # Bind Enter key to the on_done function
+        self.bind("<Return>", self.on_done)
+
+        self.update_point_entries()
+
+        self.current_point = None

+
+
[docs]    def tooltip_func(self, x, y):
+        # Function to generate tooltip text
+        for point in self.altitude_data:
+            if abs(point[0] - x) < 5.0 and abs(point[1] - y) < 1000.0:
+                return f"Time: {int(point[0])} min, Altitude: {int(point[1])} ft"
+        for point in self.mach_data:
+            if abs(point[0] - x) < 5.0 and abs(point[1] - y) < 0.1:
+                return f"Time: {int(point[0])} min, Mach: {round(point[1], 2)}"
+        return None

+
+
[docs]    def update_point_entries(self):
+        # Clear existing entries
+        for entry in self.altitude_entries + self.mach_entries:
+            entry.destroy()
+        self.altitude_entries.clear()
+        self.mach_entries.clear()
+
+        # Update phase-specific checkboxes
+        self.update_phase_options()
+
+        # Create new entries for each point
+        for i, (alt, mach) in enumerate(zip(self.altitude_data, self.mach_data)):
+            # Altitude Entry
+            tk.Label(self.point_entry_frame,
+                     text=f"Pt. {i+1}").grid(row=i+1, column=0, sticky="w")
+            alt_var = tk.StringVar(value=str(alt[1]))
+            alt_entry = tk.Entry(self.point_entry_frame,
+                                 textvariable=alt_var, width=10)  # Width set to 10
+            alt_entry.grid(row=i+1, column=1)
+            alt_entry.bind("<KeyRelease>", lambda e, i=i,
+                           var=alt_var: self.update_point_data(i, 'altitude', var.get()))
+
+            # Mach Entry
+            tk.Label(self.point_entry_frame,
+                     text=f"Pt. {i+1}").grid(row=i+1, column=2, sticky="w")
+            mach_var = tk.StringVar(value=str(mach[1]))
+            mach_entry = tk.Entry(self.point_entry_frame,
+                                  textvariable=mach_var, width=10)  # Width set to 10
+            mach_entry.grid(row=i+1, column=3)
+            mach_entry.bind("<KeyRelease>", lambda e, i=i,
+                            var=mach_var: self.update_point_data(i, 'mach', var.get()))
+
+            self.altitude_entries.append(alt_entry)
+            self.mach_entries.append(mach_entry)

+
+
[docs]    def update_phase_options(self):
+        tk.Label(self.phase_option_frame, text=f"Optimize:").grid(
+            row=0, column=0, columnspan=3, sticky="s")
+        # Create new checkboxes for each phase
+        for i in range(len(self.altitude_data) - 1):
+            if i >= len(self.optimize_mach_phase_vars):
+                mach_var = tk.BooleanVar(value=False)
+                alt_var = tk.BooleanVar(value=False)
+                self.optimize_mach_phase_vars.append(mach_var)
+                self.optimize_altitude_phase_vars.append(alt_var)
+
+            tk.Label(self.phase_option_frame,
+                     text=f"Phase {i + 1}").grid(row=i+1, column=0, sticky="w")
+            tk.Checkbutton(self.phase_option_frame, text="Altitude",
+                           variable=self.optimize_altitude_phase_vars[i]).grid(row=i+1, column=1)
+            tk.Checkbutton(self.phase_option_frame, text="Mach",
+                           variable=self.optimize_mach_phase_vars[i]).grid(row=i+1, column=2)

+
+
[docs]    def update_point_data(self, index, point_type, value):
+        try:
+            value = float(value)
+        except ValueError:
+            messagebox.showerror("Input Error", "Please enter a valid number.")
+            return
+
+        if point_type == 'altitude':
+            self.altitude_data[index] = (self.altitude_data[index][0], value)
+            self.update_plot(self.ax_altitude, self.altitude_data, 'Altitude', 'g')
+        elif point_type == 'mach':
+            self.mach_data[index] = (self.mach_data[index][0], value)
+            self.update_plot(self.ax_mach, self.mach_data, 'Mach Number', 'b')

+
+
[docs]    def on_done(self, event=None):  # event=None to handle both button click and keypress
+        times, altitudes = zip(*self.altitude_data)
+        _, mach_values = zip(*self.mach_data)
+
+        # Retrieve user choices from checkboxes
+        user_choices = {
+            "constrain_range": self.constrain_range_var.get(),
+            "solve_for_range": self.solve_for_range_var.get()
+        }
+
+        polynomial_order = int(self.polynomial_order_var.get())
+        num_segments = int(self.num_segments_var.get())
+
+        # Call create_phase_info and close the window
+        # Modify the phase_info creation to include phase-specific options
+        create_phase_info(times, altitudes, mach_values, polynomial_order, num_segments,
+                          self.optimize_mach_phase_vars, self.optimize_altitude_phase_vars, user_choices)
+
+        self.destroy()

+
+
[docs]    def show_help(self):
+        help_message = (
+            "How to Use:\n"
+            "- Click on the Altitude plot to add points.\n"
+            "- Drag points in the Mach plot to adjust values vertically.\n"
+            "- Use the checkboxes on the right to set options for the flight profile:\n"
+            "   - Optimize Mach: If checked, the flight profile will optimize for Mach number.\n"
+            "   - Optimize Altitude: If checked, the flight profile will optimize for altitude efficiency.\n"
+            "   - Constrain Range: If checked, the flight profile will include constraints on the flight range.\n"
+            "   - Solve for Range: If checked, the application will calculate the total flight range.\n"
+            "- Press 'Done' or the Enter key to process data and close the application.\n\n"
+            "Note: Dragging points in the plots will only change their vertical position"
+            "while keeping the time (horizontal position) constant."
+        )
+        messagebox.showinfo("Help", help_message)

+
+
[docs]    def setup_plot(self, ax):
+        if ax == self.ax_altitude:
+            title = 'Altitude Profile'
+            xlabel = 'Time (minutes)'
+            ylabel = 'Altitude (feet)'
+            xlim_min = 0
+            xlim_max = 360
+            ylim_min = 0
+            ylim_max = 50000
+        elif ax == self.ax_mach:
+            title = 'Mach Profile'
+            xlabel = 'Time (minutes)'
+            ylabel = 'Mach'
+            ylim_min = 0
+            ylim_max = 1.0
+
+        xlim_min = 0
+        xlim_max = 360
+        ax.set_title(title)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        ax.set_xlim(xlim_min, xlim_max)
+        ax.set_ylim(ylim_min, ylim_max)

+
+
[docs]    def on_click(self, event):
+        self.update_point_entries()
+        if event.inaxes != self.ax_altitude:
+            return  # Only interact with the altitude plot
+
+        self.current_point = None
+        # Check if the click is near an existing point
+        for i, point in enumerate(self.altitude_data):
+            if abs(point[0] - event.xdata) < 5.0 and abs(point[1] - event.ydata) < 1000.0:
+                self.current_point = i
+                return
+
+        # Add a new point only if the click is to the right of the last point
+        if event.xdata > max(self.altitude_data, key=lambda x: x[0])[0]:
+            x = round(event.xdata)
+            y = round(event.ydata / 500) * \
+                500 if event.inaxes == self.ax_altitude else round(
+                    event.ydata / 0.02) * 0.02
+
+            self.altitude_data.append((x, y))
+
+            # Optionally, add a corresponding point on the Mach plot at the same x
+            default_mach_y = 0.72
+            self.mach_data.append((x, default_mach_y))
+
+            # Update both plots
+            self.update_plot(self.ax_altitude, self.altitude_data, 'Altitude', 'g')
+            self.update_plot(self.ax_mach, self.mach_data, 'Mach Number', 'b')

+
+
[docs]    def on_motion(self, event):
+        if self.current_point is not None and event.xdata is not None and event.ydata is not None:
+            self.altitude_data[self.current_point] = (
+                self.altitude_data[self.current_point][0], event.ydata)
+            self.update_plot(self.ax_altitude, self.altitude_data, 'Altitude', 'g')

+
+
[docs]    def on_release(self, event):
+        self.update_point_entries()
+        self.current_point = None

+
+
[docs]    def update_plot(self, ax, data, label, color):
+        ax.clear()
+        ax.plot([p[0] for p in data], [p[1] for p in data], linestyle='-',
+                marker='o', color=color, markersize=8, label=label)
+
+        self.setup_plot(ax)
+        ax.figure.canvas.draw()

+
+
+if __name__ == "__main__":
+    app = IntegratedPlottingApp()
+    app.mainloop()
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/interface/methods_for_level1.html b/_modules/aviary/interface/methods_for_level1.html new file mode 100644 index 000000000..a03372765 --- /dev/null +++ b/_modules/aviary/interface/methods_for_level1.html @@ -0,0 +1,683 @@ + + + + + + + + + + + aviary.interface.methods_for_level1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.interface.methods_for_level1

+"""
+This file contains functions needed to run Aviary using the Level 1 interface.
+"""
+import os
+
+import openmdao.api as om
+from aviary.variable_info.enums import AnalysisScheme
+from aviary.interface.methods_for_level2 import AviaryProblem
+
+
+
[docs]def run_aviary(aircraft_filename, phase_info, optimizer=None,
+               analysis_scheme=AnalysisScheme.COLLOCATION, objective_type=None,
+               record_filename='dymos_solution.db', restart_filename=None, max_iter=50,
+               run_driver=True, make_plots=True, phase_info_parameterization=None,
+               optimization_history_filename=None):
+    """
+    Run the Aviary optimization problem for a specified aircraft configuration and mission.
+
+    This function creates an instance of the AviaryProblem class using provided phase information,
+    mission, and mass methods. It processes aircraft and options data from the given aircraft filename,
+    checks for clashing inputs, and sets up pre- and post-mission systems. The optimization problem is formulated,
+    initialized with guesses, and run to find a solution.
+
+    Parameters
+    ----------
+    aircraft_filename : str
+        Filename from which to load the aircraft and options data.
+    phase_info : dict
+        Information about the phases of the mission.
+    optimizer : str
+        The optimizer to use.
+    analysis_scheme : AnalysisScheme, optional
+        The analysis scheme to use, defaults to AnalysisScheme.COLLOCATION.
+    objective_type : str, optional
+        Type of the optimization objective.
+    record_filename : str, optional
+        Filename for recording the solution, defaults to 'dymos_solution.db'.
+    restart_filename : str, optional
+        Filename to use for restarting the optimization, if applicable.
+    max_iter : int, optional
+        Maximum number of iterations for the optimizer, defaults to 50.
+    run_driver : bool, optional
+        If True, the driver will be run, defaults to True.
+    make_plots : bool, optional
+        If True, generate plots during the optimization, defaults to True.
+    phase_info_parameterization : function, optional
+        Additional information to parameterize the phase_info object based on
+        desired cruise altitude and Mach.
+
+    Returns
+    -------
+    AviaryProblem
+        The AviaryProblem instance after running the optimization problem.
+
+    Notes
+    -----
+    The function allows for user overrides on aircraft and options data.
+    It raises warnings or errors if there are clashing user inputs.
+    Users can modify or add methods to alter the Aviary problem's behavior.
+    """
+
+    # Build problem
+    prob = AviaryProblem(analysis_scheme)
+
+    # Load aircraft and options data from user
+    # Allow for user overrides here
+    prob.load_inputs(aircraft_filename, phase_info)
+
+
+# Preprocess inputs
+    prob.check_and_preprocess_inputs()
+
+    prob.add_pre_mission_systems()
+
+    prob.add_phases(phase_info_parameterization=phase_info_parameterization)
+
+    prob.add_post_mission_systems()
+
+    # Link phases and variables
+    prob.link_phases()
+
+    prob.add_driver(optimizer, max_iter=max_iter)
+
+    prob.add_design_variables()
+
+    # Load optimization problem formulation
+    # Detail which variables the optimizer can control
+    prob.add_objective(objective_type=objective_type)
+
+    prob.setup()
+
+    prob.set_initial_guesses()
+
+    prob.failed = prob.run_aviary_problem(
+        record_filename, restart_filename=restart_filename, run_driver=run_driver, make_plots=make_plots, optimization_history_filename=optimization_history_filename)
+
+    return prob

+
+
+
[docs]def run_level_1(
+    input_deck,
+    outdir='output',
+    optimizer='SNOPT',
+    phase_info=None,
+    n2=False,
+    max_iter=50,
+    analysis_scheme=AnalysisScheme.COLLOCATION,
+):
+    '''
+    This file enables running aviary from the command line with a user specified input deck.
+    usage: aviary run_mission [input_deck] [opt_args]
+    '''
+
+    kwargs = {
+        'max_iter': max_iter,
+    }
+
+    if analysis_scheme is AnalysisScheme.SHOOTING:
+        kwargs['analysis_scheme'] = AnalysisScheme.SHOOTING
+        kwargs['run_driver'] = False
+    #     kwargs['optimizer'] = 'IPOPT'
+    # else:
+    kwargs['optimizer'] = optimizer
+
+    prob = run_aviary(input_deck, phase_info, **kwargs)
+
+    if n2:
+        outfile = os.path.join(outdir, "n2.html")
+        if outdir != '':
+            os.makedirs(outdir, exist_ok=True)
+        om.n2(
+            prob,
+            outfile=outfile,
+            show_browser=False,
+        )
+
+    return prob

+
+
+def _setup_level1_parser(parser):
+    def_outdir = os.path.join(os.getcwd(), "output")
+    parser.add_argument(
+        'input_deck', metavar='indeck', type=str, nargs=1, help='Name of vehicle input deck file'
+    )
+    parser.add_argument(
+        "-o", "--outdir", default=def_outdir, help="Directory to write outputs"
+    )
+    parser.add_argument(
+        "--optimizer",
+        type=str,
+        default='SNOPT',
+        help="Name of optimizer",
+        choices=("SNOPT", "IPOPT", "SLSQP", "None")
+    )
+    parser.add_argument(
+        "--phase_info",
+        type=str,
+        default=None,
+        help="Path to phase info file"
+    )
+    parser.add_argument("--n2", action="store_true",
+                        help="Generate an n2 diagram after the analysis")
+    parser.add_argument(
+        "--max_iter",
+        type=int,
+        default=50,
+        help="maximum number of iterations")
+    parser.add_argument(
+        "--shooting",
+        action="store_true",
+        help="Use shooting instead of collocation",
+    )
+
+
+def _exec_level1(args, user_args):
+    if args.shooting:  # For future use
+        analysis_scheme = AnalysisScheme.SHOOTING
+    else:
+        analysis_scheme = AnalysisScheme.COLLOCATION
+
+    if args.optimizer == 'None':
+        args.optimizer = None
+
+    # check if args.input_deck is a list, if so, use the first element
+    if isinstance(args.input_deck, list):
+        args.input_deck = args.input_deck[0]
+
+    prob = run_level_1(
+        input_deck=args.input_deck,
+        outdir=args.outdir,
+        optimizer=args.optimizer,
+        phase_info=args.phase_info,
+        n2=args.n2,
+        max_iter=args.max_iter,
+        analysis_scheme=analysis_scheme,
+    )
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/interface/methods_for_level2.html b/_modules/aviary/interface/methods_for_level2.html new file mode 100644 index 000000000..a47efd83d --- /dev/null +++ b/_modules/aviary/interface/methods_for_level2.html @@ -0,0 +1,3035 @@ + + + + + + + + + + + aviary.interface.methods_for_level2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.interface.methods_for_level2

+import csv
+import warnings
+from packaging import version
+import inspect
+from pathlib import Path
+from datetime import datetime
+import importlib.util
+import sys
+
+import numpy as np
+
+import dymos as dm
+from dymos.utils.misc import _unspecified
+
+import openmdao.api as om
+from openmdao.utils.units import convert_units
+from openmdao.utils.units import valid_units
+
+from aviary.constants import GRAV_ENGLISH_LBM, RHO_SEA_LEVEL_ENGLISH
+from aviary.mission.flops_based.phases.build_landing import Landing
+from aviary.mission.flops_based.phases.build_takeoff import Takeoff
+from aviary.mission.flops_based.phases.climb_phase import Climb
+from aviary.mission.flops_based.phases.cruise_phase import Cruise
+from aviary.mission.flops_based.phases.descent_phase import Descent
+from aviary.mission.flops_based.phases.simple_energy_phase import EnergyPhase
+from aviary.mission.gasp_based.ode.groundroll_ode import GroundrollODE
+from aviary.mission.gasp_based.ode.params import ParamPort
+from aviary.mission.gasp_based.ode.unsteady_solved.unsteady_solved_ode import \
+    UnsteadySolvedODE
+from aviary.mission.gasp_based.phases.time_integration_traj import FlexibleTraj
+from aviary.mission.gasp_based.phases.time_integration_phases import SGMCruise
+from aviary.mission.gasp_based.phases.accel_phase import get_accel
+from aviary.mission.gasp_based.phases.ascent_phase import get_ascent
+from aviary.mission.gasp_based.phases.climb_phase import get_climb
+from aviary.mission.gasp_based.phases.desc_phase import get_descent
+from aviary.mission.gasp_based.phases.groundroll_phase import get_groundroll
+from aviary.mission.gasp_based.phases.landing_group import LandingSegment
+from aviary.mission.gasp_based.phases.rotation_phase import get_rotation
+from aviary.mission.gasp_based.phases.taxi_group import TaxiSegment
+from aviary.mission.gasp_based.phases.v_rotate_comp import VRotateComp
+from aviary.mission.gasp_based.polynomial_fit import PolynomialFit
+from aviary.subsystems.premission import CorePreMission
+from aviary.mission.gasp_based.ode.breguet_cruise_ode import BreguetCruiseODESolution
+from aviary.utils.functions import set_aviary_initial_values, Null, create_opts2vals, add_opts2vals, promote_aircraft_and_mission_vars
+from aviary.utils.process_input_decks import create_vehicle
+from aviary.utils.preprocessors import preprocess_crewpayload
+from aviary.interface.utils.check_phase_info import check_phase_info
+from aviary.utils.aviary_values import AviaryValues
+
+from aviary.variable_info.functions import setup_trajectory_params, override_aviary_vars
+from aviary.variable_info.variables import Aircraft, Mission, Dynamic, Settings
+from aviary.variable_info.enums import AnalysisScheme, ProblemType, SpeedType, AlphaModes, EquationsOfMotion, LegacyCode
+from aviary.variable_info.variable_meta_data import _MetaData as BaseMetaData
+from aviary.variable_info.variables_in import VariablesIn
+
+from aviary.subsystems.propulsion.engine_deck import EngineDeck
+from aviary.subsystems.propulsion.propulsion_builder import CorePropulsionBuilder
+from aviary.subsystems.geometry.geometry_builder import CoreGeometryBuilder
+from aviary.subsystems.mass.mass_builder import CoreMassBuilder
+from aviary.subsystems.aerodynamics.aerodynamics_builder import CoreAerodynamicsBuilder
+from aviary.utils.preprocessors import preprocess_propulsion
+from aviary.utils.merge_variable_metadata import merge_meta_data
+
+from aviary.interface.default_phase_info.two_dof_fiti import create_2dof_based_ascent_phases, create_2dof_based_descent_phases
+from aviary.mission.gasp_based.idle_descent_estimation import descent_range_and_fuel
+from aviary.mission.flops_based.phases.phase_utils import get_initial
+
+
+FLOPS = LegacyCode.FLOPS
+GASP = LegacyCode.GASP
+
+HEIGHT_ENERGY = EquationsOfMotion.HEIGHT_ENERGY
+TWO_DEGREES_OF_FREEDOM = EquationsOfMotion.TWO_DEGREES_OF_FREEDOM
+SIMPLE = EquationsOfMotion.SIMPLE
+SOLVED = EquationsOfMotion.SOLVED
+
+
+
[docs]def wrapped_convert_units(val_unit_tuple, new_units):
+    """
+    Wrapper for OpenMDAO's convert_units function.
+
+    Parameters
+    ----------
+    val_unit_tuple : tuple
+        Tuple of the form (value, units) where value is a float and units is a
+        string.
+    new_units : string
+        New units to convert to.
+
+    Returns
+    -------
+    float
+        Value converted to new units.
+    """
+    value, units = val_unit_tuple
+
+    # can't convert units on None; return None
+    if value is None:
+        return None
+
+    if isinstance(value, (list, tuple)):
+        return [convert_units(v, units, new_units) for v in value]
+    else:
+        return convert_units(value, units, new_units)

+
+
+
[docs]class PreMissionGroup(om.Group):
+
[docs]    def configure(self):
+        external_outputs = promote_aircraft_and_mission_vars(self)
+
+        statics = self.core_subsystems
+        override_aviary_vars(statics, statics.options["aviary_options"],
+                             external_overrides=external_outputs,
+                             manual_overrides=statics.manual_overrides)

+
+
+
[docs]class PostMissionGroup(om.Group):
+
[docs]    def configure(self):
+        promote_aircraft_and_mission_vars(self)

+
+
+
[docs]class AviaryProblem(om.Problem):
+    """
+    Main class for instantiating, formulating, and solving Aviary problems.
+
+    On a basic level, this problem object is all the conventional user needs
+    to interact with. Looking at the three "levels" of use cases, from simplest
+    to most complicated, we have:
+
+    Level 1: users interact with Aviary through input files (.csv or .yaml, TBD)
+    Level 2: users interact with Aviary through a Python interface
+    Level 3: users can modify Aviary's workings through Python and OpenMDAO
+
+    This Problem object is simply a specialized OpenMDAO Problem that has
+    additional methods to help users create and solve Aviary problems.
+    """
+
+
[docs]    def __init__(self, analysis_scheme=AnalysisScheme.COLLOCATION, **kwargs):
+        super().__init__(**kwargs)
+
+        self.timestamp = datetime.now()
+
+        self.model = om.Group()
+        self.pre_mission = PreMissionGroup()
+        self.post_mission = PostMissionGroup()
+
+        self.aviary_inputs = None
+
+        self.traj = None
+
+        self.analysis_scheme = analysis_scheme

+
+
[docs]    def load_inputs(self, input_filename, phase_info=None, engine_builder=None):
+        """
+        This method loads the aviary_values inputs and options that the
+        user specifies. They could specify files to load and values to
+        replace here as well.
+        Phase info is also loaded if provided by the user. If phase_info is None,
+        the appropriate default phase_info based on mission analysis method is used.
+
+        This method is not strictly necessary; a user could also supply
+        an AviaryValues object and/or phase_info dict of their own.
+        """
+        ## LOAD INPUT FILE ###
+        self.engine_builder = engine_builder
+        self.aviary_inputs, self.initial_guesses = create_vehicle(input_filename)
+
+        aviary_inputs = self.aviary_inputs
+
+        self.mission_method = mission_method = aviary_inputs.get_val(
+            Settings.EQUATIONS_OF_MOTION)
+        self.mass_method = mass_method = aviary_inputs.get_val(Settings.MASS_METHOD)
+
+        if mission_method is TWO_DEGREES_OF_FREEDOM:
+            aviary_inputs.set_val(Mission.Summary.CRUISE_MASS_FINAL,
+                                  val=self.initial_guesses['cruise_mass_final'], units='lbm')
+            aviary_inputs.set_val(Mission.Summary.GROSS_MASS,
+                                  val=self.initial_guesses['actual_takeoff_mass'], units='lbm')
+
+            # Commonly referenced values
+            self.cruise_alt = aviary_inputs.get_val(
+                Mission.Design.CRUISE_ALTITUDE, units='ft')
+            self.problem_type = aviary_inputs.get_val('problem_type')
+            self.mass_defect = aviary_inputs.get_val('mass_defect', units='lbm')
+
+            self.cruise_mass_final = aviary_inputs.get_val(
+                Mission.Summary.CRUISE_MASS_FINAL, units='lbm')
+            self.target_range = aviary_inputs.get_val(
+                Mission.Design.RANGE, units='NM')
+            self.cruise_mach = aviary_inputs.get_val(Mission.Design.MACH)
+
+        ## LOAD PHASE_INFO ###
+        if phase_info is None:
+            # check if the user generated a phase_info from gui
+            # Load the phase info dynamically from the current working directory
+            phase_info_module_path = Path.cwd() / 'outputted_phase_info.py'
+
+            if phase_info_module_path.exists():
+                spec = importlib.util.spec_from_file_location(
+                    'outputted_phase_info', phase_info_module_path)
+                outputted_phase_info = importlib.util.module_from_spec(spec)
+                sys.modules['outputted_phase_info'] = outputted_phase_info
+                spec.loader.exec_module(outputted_phase_info)
+
+                # Access the phase_info variable from the loaded module
+                phase_info = outputted_phase_info.phase_info
+
+                print('Loaded outputted_phase_info.py generated with GUI')
+
+            else:
+                if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+                    from aviary.interface.default_phase_info.two_dof import phase_info
+                elif self.mission_method is HEIGHT_ENERGY:
+                    from aviary.interface.default_phase_info.height_energy import phase_info
+                elif self.mission_method is SIMPLE:
+                    from aviary.interface.default_phase_info.simple import phase_info
+                elif self.mission_method is SOLVED:
+                    from aviary.interface.default_phase_info.solved import phase_info
+
+                print('Loaded default phase_info for'
+                      f'{self.mission_method.value.lower()} equations of motion')
+
+        # create a new dictionary that only contains the phases from phase_info
+        self.phase_info = {}
+
+        for phase_name in phase_info:
+            if 'external_subsystems' not in phase_info[phase_name]:
+                phase_info[phase_name]['external_subsystems'] = []
+
+            if phase_name not in ['pre_mission', 'post_mission']:
+                self.phase_info[phase_name] = phase_info[phase_name]
+
+        # pre_mission and post_mission are stored in their own dictionaries.
+        if 'pre_mission' in phase_info:
+            self.pre_mission_info = phase_info['pre_mission']
+        else:
+            self.pre_mission_info = {'include_takeoff': True,
+                                     'external_subsystems': []}
+
+        if 'post_mission' in phase_info:
+            self.post_mission_info = phase_info['post_mission']
+        else:
+            self.post_mission_info = {'include_landing': True,
+                                      'external_subsystems': [],
+                                      'constrain_range': False}
+
+        ## PROCESSING ##
+        # set up core subsystems
+        if mission_method in (HEIGHT_ENERGY, SIMPLE):
+            everything_else_origin = FLOPS
+        elif mission_method in (TWO_DEGREES_OF_FREEDOM, SOLVED):
+            everything_else_origin = GASP
+        else:
+            raise ValueError(f'Unknown mission method {self.mission_method}')
+
+        prop = CorePropulsionBuilder('core_propulsion')
+        mass = CoreMassBuilder('core_mass', code_origin=self.mass_method)
+        aero = CoreAerodynamicsBuilder(
+            'core_aerodynamics', code_origin=everything_else_origin)
+
+        # TODO These values are currently hardcoded, in future should come from user
+        both_geom = False
+        code_origin_to_prioritize = None
+
+        # which geometry methods should be used, or both?
+        geom_code_origin = None
+        if (everything_else_origin is FLOPS) and (mass_method is FLOPS):
+            geom_code_origin = FLOPS
+        elif (everything_else_origin is GASP) and (mass_method is GASP):
+            geom_code_origin = GASP
+        else:
+            both_geom = True
+
+        # which geometry method gets prioritized in case of conflicting outputs
+        if not code_origin_to_prioritize:
+            if everything_else_origin is GASP:
+                code_origin_to_prioritize = GASP
+            elif everything_else_origin is FLOPS:
+                code_origin_to_prioritize = FLOPS
+
+        geom = CoreGeometryBuilder('core_geometry',
+                                   code_origin=geom_code_origin,
+                                   use_both_geometries=both_geom,
+                                   code_origin_to_prioritize=code_origin_to_prioritize)
+
+        self.core_subsystems = {'propulsion': prop,
+                                'geometry': geom,
+                                'mass': mass,
+                                'aerodynamics': aero}
+
+        # TODO optionally accept which subsystems to load from phase_info
+        subsystems = self.core_subsystems
+        default_mission_subsystems = [
+            subsystems['aerodynamics'], subsystems['propulsion']]
+        self.ode_args = dict(aviary_options=aviary_inputs,
+                             core_subsystems=default_mission_subsystems)
+
+        if engine_builder is None:
+            engine = EngineDeck(options=aviary_inputs)
+        else:
+            engine = engine_builder
+
+        preprocess_propulsion(aviary_inputs, [engine])
+
+        self._update_metadata_from_subsystems()
+
+        self.aviary_inputs = aviary_inputs
+        return aviary_inputs

+
+    def _update_metadata_from_subsystems(self):
+        self.meta_data = BaseMetaData.copy()
+
+        variables_to_pop = []
+
+        # loop through phase_info and external subsystems
+        for phase_name in self.phase_info:
+            external_subsystems = self._get_all_subsystems(
+                self.phase_info[phase_name]['external_subsystems'])
+            for subsystem in external_subsystems:
+                meta_data = subsystem.meta_data.copy()
+
+                state_info = subsystem.get_states()
+                for state in state_info:
+                    variables_to_pop.append(state)
+                    variables_to_pop.append(state_info[state]['rate_source'])
+
+                arg_spec = inspect.getfullargspec(subsystem.get_controls)
+                if 'phase_name' in arg_spec.args:
+                    control_dicts = subsystem.get_controls(
+                        phase_name=phase_name)
+                else:
+                    control_dicts = subsystem.get_controls()
+
+                for control_name, control_dict in control_dicts.items():
+                    variables_to_pop.append(control_name)
+
+                for output in subsystem.get_outputs():
+                    variables_to_pop.append(output)
+
+                for parameter in subsystem.get_parameters():
+                    variables_to_pop.append(parameter)
+
+                self.meta_data = merge_meta_data([self.meta_data, meta_data])
+
+        variables_to_pop = list(set(variables_to_pop))
+
+        for variable in variables_to_pop:
+            if variable in self.meta_data:
+                self.meta_data.pop(variable)
+
+
[docs]    def check_and_preprocess_inputs(self):
+        """
+        This method checks the user-supplied input values for any potential problems
+        and preprocesses the inputs to prepare them for use in the Aviary problem.
+        """
+        check_phase_info(self.phase_info, self.mission_method)
+
+        for phase_name in self.phase_info:
+            for external_subsystem in self.phase_info[phase_name]['external_subsystems']:
+                self.aviary_inputs = external_subsystem.preprocess_inputs(
+                    self.aviary_inputs)
+
+        # TODO find preprocessors a permanent home
+        # PREPROCESSORS #
+        # Fill in anything missing in the options with computed defaults.
+        preprocess_crewpayload(self.aviary_inputs)

+
+
[docs]    def add_pre_mission_systems(self):
+        """
+        Add pre-mission systems to the Aviary problem. These systems are executed before the mission
+        and are also known as the "pre_mission" group.
+
+        Depending on the mission model specified (`FLOPS` or `GASP`), this method adds various subsystems
+        to the aircraft model. For the `FLOPS` mission model, a takeoff phase is added using the Takeoff class
+        with the number of engines and airport altitude specified. For the `GASP` mission model, three subsystems
+        are added: a TaxiSegment subsystem, an ExecComp to calculate the time to initiate gear and flaps,
+        and an ExecComp to calculate the speed at which to initiate rotation. All subsystems are promoted with
+        aircraft and mission inputs and outputs as appropriate.
+
+        A user can override this method with their own pre-mission systems as desired.
+        """
+        pre_mission = self.pre_mission
+        self.model.add_subsystem('pre_mission', pre_mission,
+                                 promotes_inputs=['aircraft:*', 'mission:*'],
+                                 promotes_outputs=['aircraft:*', 'mission:*'],)
+
+        if 'linear_solver' in self.pre_mission_info:
+            pre_mission.linear_solver = self.pre_mission_info['linear_solver']
+
+        if 'nonlinear_solver' in self.pre_mission_info:
+            pre_mission.nonlinear_solver = self.pre_mission_info['nonlinear_solver']
+
+        self._add_premission_external_subsystems()
+
+        subsystems = self.core_subsystems
+        default_subsystems = [subsystems['propulsion'],
+                              subsystems['geometry'],
+                              subsystems['aerodynamics'],
+                              subsystems['mass'],]
+
+        pre_mission.add_subsystem(
+            'core_subsystems',
+            CorePreMission(
+                aviary_options=self.aviary_inputs,
+                subsystems=default_subsystems,
+                process_overrides=False,
+            ),
+            promotes_inputs=['*'],
+            promotes_outputs=['*'])
+
+        if not self.pre_mission_info['include_takeoff']:
+            return
+
+        # Check for 2DOF mission method
+        # NOTE should solved trigger this as well?
+        if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            self._add_gasp_takeoff_systems()
+
+        # Check for HE mission method
+        elif self.mission_method is HEIGHT_ENERGY or self.mission_method is SIMPLE:
+            self._add_flops_takeoff_systems()

+
+    def _add_flops_takeoff_systems(self):
+        # Initialize takeoff options
+        takeoff_options = Takeoff(
+            airport_altitude=0.,  # ft
+            num_engines=self.aviary_inputs.get_val(Aircraft.Engine.NUM_ENGINES)
+        )
+
+        # Build and add takeoff subsystem
+        takeoff = takeoff_options.build_phase(False)
+        self.model.add_subsystem(
+            'takeoff', takeoff, promotes_inputs=['aircraft:*', 'mission:*'],
+            promotes_outputs=['mission:*'])
+
+    def _add_gasp_takeoff_systems(self):
+        # Create options to values
+        OptionsToValues = create_opts2vals(
+            [Aircraft.CrewPayload.NUM_PASSENGERS,
+                Mission.Design.CRUISE_ALTITUDE, ])
+        add_opts2vals(self.model, OptionsToValues, self.aviary_inputs)
+
+        # Add thrust-to-weight ratio subsystem
+        self.model.add_subsystem(
+            'tw_ratio',
+            om.ExecComp(
+                f'TW_ratio = Fn_SLS / (takeoff_mass * {GRAV_ENGLISH_LBM})',
+                TW_ratio={'units': "unitless"},
+                Fn_SLS={'units': 'lbf'},
+                takeoff_mass={'units': 'lbm'},
+            ),
+            promotes_inputs=[('Fn_SLS', Aircraft.Propulsion.TOTAL_SCALED_SLS_THRUST),
+                             ('takeoff_mass', Mission.Summary.GROSS_MASS)],
+            promotes_outputs=[('TW_ratio', Aircraft.Design.THRUST_TO_WEIGHT_RATIO)],
+        )
+
+        self.cruise_alt = self.aviary_inputs.get_val(
+            Mission.Design.CRUISE_ALTITUDE, units='ft')
+
+        # Add taxi subsystem
+        self.model.add_subsystem(
+            "taxi", TaxiSegment(**(self.ode_args)),
+            promotes_inputs=['aircraft:*', 'mission:*'],
+        )
+
+        if self.analysis_scheme is AnalysisScheme.COLLOCATION:
+            # Add event transformation subsystem
+            self.model.add_subsystem(
+                "event_xform",
+                om.ExecComp(
+                    ["t_init_gear=m*tau_gear+b", "t_init_flaps=m*tau_flaps+b"], units="s"
+                ),
+                promotes_inputs=[
+                    "tau_gear",
+                    "tau_flaps",
+                    ("m", Mission.Takeoff.ASCENT_DURATION),
+                    ("b", Mission.Takeoff.ASCENT_T_INTIIAL),
+                ],
+                promotes_outputs=["t_init_gear", "t_init_flaps"],
+            )
+
+        # Calculate speed at which to initiate rotation
+        self.model.add_subsystem(
+            "vrot",
+            om.ExecComp(
+                "Vrot = ((2 * mass * g) / (rho * wing_area * CLmax))**0.5 + dV1 + dVR",
+                Vrot={"units": "ft/s"},
+                mass={"units": "lbm"},
+                CLmax={"units": "unitless"},
+                g={"units": "lbf/lbm", "val": GRAV_ENGLISH_LBM},
+                rho={"units": "slug/ft**3", "val": RHO_SEA_LEVEL_ENGLISH},
+                wing_area={"units": "ft**2"},
+                dV1={
+                    "units": "ft/s",
+                    "desc": "Increment of engine failure decision speed above stall",
+                },
+                dVR={
+                    "units": "ft/s",
+                    "desc": "Increment of takeoff rotation speed above engine failure "
+                    "decision speed",
+                },
+            ),
+            promotes_inputs=[
+                ("wing_area", Aircraft.Wing.AREA),
+                ("dV1", Mission.Takeoff.DECISION_SPEED_INCREMENT),
+                ("dVR", Mission.Takeoff.ROTATION_SPEED_INCREMENT),
+                ("CLmax", Mission.Takeoff.LIFT_COEFFICIENT_MAX),
+            ],
+            promotes_outputs=[('Vrot', Mission.Takeoff.ROTATION_VELOCITY)]
+        )
+
+    def _add_premission_external_subsystems(self):
+        """
+        This private method adds each external subsystem to the pre-mission subsystem and
+        a mass component that captures external subsystem masses for use in mass buildups.
+
+        Firstly, the method iterates through all external subsystems in the pre-mission
+        information. For each subsystem, it builds the pre-mission instance of the
+        subsystem.
+
+        Secondly, the method collects the mass names of the added subsystems. This
+        expression is then used to define an ExecComp (a component that evaluates a
+        simple equation given input values).
+
+        The method promotes the input and output of this ExecComp to the top level of the
+        pre-mission object, allowing this calculated subsystem mass to be accessed
+        directly from the pre-mission object.
+        """
+
+        mass_names = []
+        # Loop through all the phases in this subsystem.
+        for external_subsystem in self.pre_mission_info['external_subsystems']:
+            # Get all the subsystem builders for this phase.
+            subsystem_premission = external_subsystem.build_pre_mission(
+                self.aviary_inputs)
+
+            if subsystem_premission is not None:
+                self.pre_mission.add_subsystem(external_subsystem.name,
+                                               subsystem_premission)
+
+                mass_names.extend(external_subsystem.get_mass_names())
+
+        if mass_names:
+            formatted_names = []
+            for name in mass_names:
+                formatted_name = name.replace(':', '_')
+                formatted_names.append(formatted_name)
+
+            # Define the expression for computing the sum of masses
+            expr = 'subsystem_mass = ' + ' + '.join(formatted_names)
+
+            promotes_inputs_list = [(formatted_name, original_name)
+                                    for formatted_name, original_name in zip(formatted_names, mass_names)]
+
+            # Create the ExecComp
+            self.pre_mission.add_subsystem('external_comp_sum', om.ExecComp(expr, units='kg'),
+                                           promotes_inputs=promotes_inputs_list,
+                                           promotes_outputs=[
+                ('subsystem_mass', Aircraft.Design.EXTERNAL_SUBSYSTEMS_MASS)])
+
+    def _get_2dof_phase(self, phase_name):
+        # Get the phase options for the specified phase name
+        phase_options = self.phase_info[phase_name]
+
+        if 'cruise' in phase_name:
+            phase = dm.AnalyticPhase(
+                ode_class=BreguetCruiseODESolution,
+                ode_init_kwargs=self.ode_args,
+                num_nodes=5,
+            )
+
+            # Time here is really the independent variable through which we are integrating.
+            # In the case of the Breguet Range ODE, it's mass.
+            # We rely on mass being monotonically non-increasing across the phase.
+            phase.set_time_options(
+                name='mass',
+                fix_initial=False,
+                fix_duration=False,
+                units="lbm",
+                targets="mass",
+                initial_bounds=(10.e3, 500_000),
+                initial_ref=100_000,
+                duration_bounds=(-50000, -10),
+                duration_ref=50000,
+            )
+
+            phase.add_parameter(Dynamic.Mission.ALTITUDE, opt=False,
+                                val=self.phase_info['climb2']['final_alt'][0], units=self.phase_info['climb2']['final_alt'][1])
+            phase.add_parameter(Dynamic.Mission.MACH, opt=False,
+                                val=self.phase_info['climb2']['mach_cruise'])
+            phase.add_parameter("initial_distance", opt=False, val=0.0,
+                                units="NM", static_target=True)
+            phase.add_parameter("initial_time", opt=False, val=0.0,
+                                units="s", static_target=True)
+
+            phase.add_timeseries_output("time", units="s")
+
+        else:
+            # Create a Radau transcription scheme object with the specified num_segments and order
+            transcription = dm.Radau(
+                num_segments=phase_options['num_segments'],
+                order=phase_options['order'],
+                compressed=True,
+                solve_segments=False)
+
+            # Create a dictionary of phase functions
+            phase_functions = {
+                'groundroll': get_groundroll,
+                'rotation': get_rotation,
+                'ascent': get_ascent,
+                'accel': get_accel
+            }
+
+            # Set the phase function based on the phase name
+            if 'climb' in phase_name:
+                phase_functions[phase_name] = get_climb
+            elif 'desc' in phase_name:
+                phase_functions[phase_name] = get_descent
+
+            # Get the phase function corresponding to the phase name
+            phase_func = phase_functions.get(phase_name)
+
+            # Calculate the phase by calling the phase function
+            # with the transcription object and remaining phase options
+            trimmed_phase_options = {k: v for k, v in phase_options.items(
+            ) if k not in ['num_segments', 'order', 'initial_guesses', 'throttle_setting', 'external_subsystems']}
+
+            # define expected units for each phase option
+            expected_units = {
+                'alt': 'ft',
+                'mass': 'lbm',
+                'distance': 'ft',
+                'time': 's',
+                'duration': 's',
+                'initial': 's',
+                'EAS': 'kn',
+                'TAS': 'kn',
+                'angle': 'deg',
+                'pitch': 'deg',
+                'normal': 'lbf',
+                'final_alt': 'ft',
+                'required_available_climb_rate': 'ft/min',
+            }
+
+            if phase_name in ['accel', 'climb1', 'climb2', 'desc1', 'desc2']:
+                expected_units['distance'] = 'NM'
+
+            # loop through all trimmed_phase_options and call wrapped_convert_units with the correct expected units
+            for key, value in trimmed_phase_options.items():
+                for expected_key, expected_unit in expected_units.items():
+                    if key.startswith(expected_key):
+                        trimmed_phase_options[key] = wrapped_convert_units(
+                            value, expected_unit)
+
+            phase = phase_func(
+                ode_args=self.ode_args,
+                transcription=transcription,
+                **trimmed_phase_options)
+
+            phase.add_control(
+                Dynamic.Mission.THROTTLE, targets=Dynamic.Mission.THROTTLE, units='unitless',
+                opt=False, lower=0.0, upper=1.0
+            )
+
+        phase.timeseries_options['use_prefix'] = True
+
+        return phase
+
+    def _add_groundroll_eq_constraint(self, phase):
+        """
+        Add an equality constraint to the problem to ensure that the TAS at the end of the
+        groundroll phase is equal to the rotation velocity at the start of the rotation phase.
+        """
+        self.model.add_subsystem(
+            "groundroll_boundary",
+            om.EQConstraintComp(
+                "TAS",
+                eq_units="ft/s",
+                normalize=True,
+                add_constraint=True,
+            ),
+        )
+        self.model.connect(Mission.Takeoff.ROTATION_VELOCITY,
+                           "groundroll_boundary.rhs:TAS")
+        self.model.connect(
+            "traj.groundroll.states:TAS",
+            "groundroll_boundary.lhs:TAS",
+            src_indices=[-1],
+            flat_src_indices=True,
+        )
+
+        ascent_tx = phase.options["transcription"]
+        ascent_num_nodes = ascent_tx.grid_data.num_nodes
+        self.model.add_subsystem(
+            "h_fit",
+            PolynomialFit(N_cp=ascent_num_nodes),
+            promotes_inputs=["t_init_gear", "t_init_flaps"],
+        )
+
+    def _get_height_energy_phase(self, phase_name, phase_idx):
+        base_phase_options = self.phase_info[phase_name]
+        fix_duration = base_phase_options['user_options']['fix_duration']
+
+        # We need to exclude some things from the phase_options that we pass down
+        # to the phases. Intead of "popping" keys, we just create new outer dictionaries.
+
+        phase_options = {}
+        for key, val in base_phase_options.items():
+            if key != 'user_options':
+                phase_options[key] = val
+
+        phase_options['user_options'] = {}
+        for key, val in base_phase_options['user_options'].items():
+            if key != 'fix_duration':
+                phase_options['user_options'][key] = val
+
+        # TODO optionally accept which subsystems to load from phase_info
+        subsystems = self.core_subsystems
+        default_mission_subsystems = [
+            subsystems['aerodynamics'], subsystems['propulsion']]
+
+        if self.mission_method is HEIGHT_ENERGY or self.mission_method is SIMPLE:
+            if self.mission_method is SIMPLE:
+                climb_builder = EnergyPhase
+                cruise_builder = EnergyPhase
+                descent_builder = EnergyPhase
+            else:
+                climb_builder = Climb
+                cruise_builder = Cruise
+                descent_builder = Descent
+
+            if phase_name == 'climb':
+                phase_object = climb_builder.from_phase_info(
+                    phase_name, phase_options, default_mission_subsystems, meta_data=self.meta_data)
+
+            elif phase_name == 'cruise':
+                phase_object = cruise_builder.from_phase_info(
+                    phase_name, phase_options, default_mission_subsystems, meta_data=self.meta_data)
+
+            elif phase_name == 'descent':
+                phase_object = descent_builder.from_phase_info(
+                    phase_name, phase_options, default_mission_subsystems, meta_data=self.meta_data)
+            else:
+                phase_object = EnergyPhase.from_phase_info(
+                    phase_name, phase_options, default_mission_subsystems, meta_data=self.meta_data)
+
+            phase = phase_object.build_phase(aviary_options=self.aviary_inputs)
+
+            # TODO: add logic to filter which phases get which controls.
+            # right now all phases get all controls added from every subsystem.
+            # for example, we might only want ELECTRIC_SHAFT_POWER applied during the climb phase.
+            all_subsystems = self._get_all_subsystems(
+                phase_options['external_subsystems'])
+
+            # loop through all_subsystems and call `get_controls` on each subsystem
+            for subsystem in all_subsystems:
+                # add the controls from the subsystems to each phase
+                arg_spec = inspect.getfullargspec(subsystem.get_controls)
+                if 'phase_name' in arg_spec.args:
+                    control_dicts = subsystem.get_controls(
+                        phase_name=phase_name)
+                else:
+                    control_dicts = subsystem.get_controls()
+                for control_name, control_dict in control_dicts.items():
+                    phase.add_control(control_name, **control_dict)
+
+            user_options = AviaryValues(phase_options.get('user_options', ()))
+
+            fix_initial = user_options.get_val("fix_initial")
+            if "fix_initial_time" in user_options:
+                fix_initial_time = user_options.get_val("fix_initial_time")
+            else:
+                fix_initial_time = get_initial(fix_initial, "time", True)
+
+            input_initial = False
+            if self.mission_method is SIMPLE:
+                user_options.set_val('initial_ref', 10., 'min')
+                duration_bounds = user_options.get_val("duration_bounds", 'min')
+                user_options.set_val(
+                    'duration_ref', (duration_bounds[0] + duration_bounds[1]) / 2., 'min')
+                if phase_idx > 0:
+                    input_initial = True
+
+            if fix_initial_time or input_initial:
+                phase.set_time_options(
+                    fix_initial=fix_initial_time, fix_duration=fix_duration, units='s',
+                    duration_bounds=user_options.get_val("duration_bounds", 's'),
+                    duration_ref=user_options.get_val("duration_ref", 's'),
+                )
+            elif phase_name == 'descent':  # TODO: generalize this logic for all phases
+                phase.set_time_options(
+                    fix_initial=False, fix_duration=False, units='s',
+                    duration_bounds=user_options.get_val("duration_bounds", 's'),
+                    duration_ref=user_options.get_val("duration_ref", 's'),
+                    initial_bounds=user_options.get_val("initial_bounds", 's'),
+                    initial_ref=user_options.get_val("initial_ref", 's'),
+                )
+            else:  # TODO: figure out how to handle this now that fix_initial is dict
+                phase.set_time_options(
+                    fix_initial=fix_initial, fix_duration=fix_duration, units='s',
+                    duration_bounds=user_options.get_val("duration_bounds", 's'),
+                    duration_ref=user_options.get_val("duration_ref", 's'),
+                    initial_bounds=user_options.get_val("initial_bounds", 's'),
+                    initial_ref=user_options.get_val("initial_ref", 's'),
+                )
+
+            phase.timeseries_options['use_prefix'] = True
+
+            return phase
+
+    def _get_solved_phase(self, phase_name):
+        phase_options = self.phase_info[phase_name]
+
+        takeoff_mass = self.aviary_inputs.get_val(
+            Mission.Design.GROSS_MASS, units='lbm')
+        climb_mach = 0.8
+        solve_segments = False
+
+        if phase_name == "groundroll":
+            groundroll_trans = dm.Radau(
+                num_segments=phase_options['num_segments'], order=3, compressed=True, solve_segments="forward",
+            )
+
+            phase = dm.Phase(
+                ode_class=GroundrollODE,
+                ode_init_kwargs=self.ode_args,
+                transcription=groundroll_trans,
+            )
+
+            phase.set_time_options(fix_initial=True, fix_duration=False,
+                                   units="kn", name="TAS",
+                                   duration_bounds=wrapped_convert_units(
+                                       phase_options['duration_bounds'], 'kn'),
+                                   duration_ref=wrapped_convert_units(
+                                       phase_options['duration_ref'], 'kn'),
+                                   initial_ref=wrapped_convert_units(
+                                       phase_options['initial_ref'], 'kn'),
+                                   )
+
+            phase.set_state_options("time", rate_source="dt_dv", units="s",
+                                    fix_initial=True, fix_final=False, ref=1., defect_ref=1.)
+
+            phase.set_state_options("mass", rate_source="dmass_dv",
+                                    fix_initial=True, fix_final=False, lower=1, upper=195_000, ref=takeoff_mass, defect_ref=takeoff_mass)
+
+            phase.set_state_options(Dynamic.Mission.RANGE, rate_source="over_a",
+                                    fix_initial=True, fix_final=False, lower=0, upper=2000., ref=1.e2, defect_ref=1.e2)
+
+            phase.add_parameter("t_init_gear", units="s",
+                                static_target=True, opt=False, val=32.3)
+            phase.add_parameter("t_init_flaps", units="s",
+                                static_target=True, opt=False, val=44.0)
+            phase.add_parameter("wing_area", units="ft**2",
+                                static_target=True, opt=False, val=1370)
+
+        else:
+
+            trans = dm.Radau(num_segments=phase_options['num_segments'], order=3,
+                             compressed=True, solve_segments=solve_segments)
+
+            ode_args = dict(
+                input_speed_type=phase_options['input_speed_type'],
+                clean=phase_options['clean'],
+                ground_roll=phase_options['ground_roll'],
+                aviary_options=self.aviary_inputs,
+                core_subsystems=self.ode_args['core_subsystems'],
+                include_param_comp=True,
+                balance_throttle=False
+            )
+
+            phase = dm.Phase(
+                ode_class=UnsteadySolvedODE,
+                ode_init_kwargs=ode_args,
+                transcription=trans,
+            )
+
+            phase.add_parameter(
+                Dynamic.Mission.THROTTLE,
+                opt=False,
+                units="unitless",
+                val=phase_options['throttle_setting'],
+                static_target=False)
+
+            phase.set_time_options(fix_initial=False, fix_duration=False,
+                                   units="range_units", name=Dynamic.Mission.RANGE,
+                                   duration_bounds=wrapped_convert_units(
+                                       phase_options['duration_bounds'], "range_units"),
+                                   duration_ref=wrapped_convert_units(
+                                       phase_options['duration_ref'], "range_units"),
+                                   initial_bounds=wrapped_convert_units(
+                                       phase_options['initial_bounds'], "range_units"),
+                                   initial_ref=wrapped_convert_units(
+                                       phase_options['initial_ref'], "range_units"),
+                                   )
+
+            if phase_name == "cruise" or phase_name == "descent":
+                time_ref = 1.e4
+            else:
+                time_ref = 100.
+
+            phase.set_state_options("time", rate_source="dt_dr", targets=['t_curr'] if 'retract' in phase_name else [],
+                                    fix_initial=False, fix_final=False, ref=time_ref, defect_ref=time_ref * 1.e2)
+
+            phase.set_state_options("mass", rate_source="dmass_dr",
+                                    fix_initial=False, fix_final=False, ref=170.e3, defect_ref=170.e5,
+                                    val=170.e3, units='lbm', lower=10.e3)
+
+            phase.add_parameter("wing_area", units="ft**2",
+                                static_target=True, opt=False, val=1370)
+
+            if 'climb_at_constant_TAS' in phase_name or 'ascent' in phase_name:
+                phase.add_parameter(
+                    "t_init_gear", units="s", static_target=True, opt=False, val=100)
+                phase.add_parameter(
+                    "t_init_flaps", units="s", static_target=True, opt=False, val=100)
+
+            if 'rotation' in phase_name:
+                phase.add_polynomial_control("TAS",
+                                             order=phase_options['control_order'],
+                                             units="kn", val=200.0,
+                                             opt=phase_options['opt'], lower=1, upper=500, ref=250)
+
+                phase.add_polynomial_control(Dynamic.Mission.ALTITUDE,
+                                             order=phase_options['control_order'],
+                                             fix_initial=False,
+                                             rate_targets=['dh_dr'], rate2_targets=['d2h_dr2'],
+                                             opt=False, upper=40.e3, ref=30.e3, lower=-1.)
+
+                phase.add_polynomial_control("alpha",
+                                             order=phase_options['control_order'],
+                                             lower=-4, upper=15,
+                                             units='deg', ref=10.,
+                                             val=[0., 5.],
+                                             opt=phase_options['opt'])
+            else:
+                if 'constant_EAS' in phase_name:
+                    fixed_EAS = self.phase_info[phase_name]['fixed_EAS']
+                    phase.add_parameter("EAS", units="kn", val=fixed_EAS)
+                elif 'constant_mach' in phase_name:
+                    phase.add_parameter(
+                        Dynamic.Mission.MACH,
+                        units="unitless",
+                        val=climb_mach)
+                elif 'cruise' in phase_name:
+                    self.cruise_mach = self.aviary_inputs.get_val(Mission.Design.MACH)
+                    phase.add_parameter(
+                        Dynamic.Mission.MACH, units="unitless", val=self.cruise_mach)
+                else:
+                    phase.add_polynomial_control("TAS",
+                                                 order=phase_options['control_order'],
+                                                 fix_initial=False,
+                                                 units="kn", val=200.0,
+                                                 opt=True, lower=1, upper=500, ref=250)
+
+                phase.add_polynomial_control(Dynamic.Mission.ALTITUDE,
+                                             order=phase_options['control_order'],
+                                             units="ft", val=0.,
+                                             fix_initial=False,
+                                             rate_targets=['dh_dr'], rate2_targets=['d2h_dr2'],
+                                             opt=phase_options['opt'], upper=40.e3, ref=30.e3, lower=-1.)
+
+        phase.timeseries_options['use_prefix'] = True
+
+        return phase
+
+
[docs]    def add_phases(self, phase_info_parameterization=None):
+        """
+        Add the mission phases to the problem trajectory based on the user-specified
+        phase_info dictionary.
+
+        Parameters
+        ----------
+        phase_info_parameterization (function, optional): A function that takes in the phase_info dictionary
+            and aviary_inputs and returns modified aviary_inputs. Defaults to None.
+
+        Returns
+        -------
+        traj: The Dymos Trajectory object containing the added mission phases.
+        """
+        if phase_info_parameterization is not None:
+            self.phase_info = phase_info_parameterization(self.phase_info,
+                                                          self.aviary_inputs)
+
+        phase_info = self.phase_info
+
+        phases = list(phase_info.keys())
+
+        if self.analysis_scheme is AnalysisScheme.COLLOCATION:
+            traj = self.model.add_subsystem('traj', dm.Trajectory())
+
+        elif self.analysis_scheme is AnalysisScheme.SHOOTING:
+            initial_mass = self.aviary_inputs.get_val(Mission.Summary.GROSS_MASS, 'lbm')
+
+            ascent_phases = create_2dof_based_ascent_phases(
+                self.ode_args,
+                cruise_alt=self.cruise_alt,
+                cruise_mach=self.cruise_mach)
+
+            descent_phases = create_2dof_based_descent_phases(
+                self.ode_args,
+                cruise_alt=self.cruise_alt,
+                cruise_mach=self.cruise_mach)
+
+            descent_estimation = descent_range_and_fuel(
+                phases=descent_phases,
+                initial_mass=initial_mass,
+                cruise_alt=self.cruise_alt,
+                cruise_mach=self.cruise_mach)
+
+            estimated_descent_range = descent_estimation['refined_guess']['distance_flown']
+            end_of_cruise_range = self.target_range - estimated_descent_range
+
+            estimated_descent_fuel = descent_estimation['refined_guess']['fuel_burned']
+
+            cruise_kwargs = dict(
+                input_speed_type=SpeedType.MACH,
+                input_speed_units="unitless",
+                ode_args=self.ode_args,
+                alpha_mode=AlphaModes.REQUIRED_LIFT,
+                simupy_args=dict(
+                    DEBUG=True,
+                    blocked_state_names=['engine.nox', 'nox',
+                                         'TAS', Dynamic.Mission.FLIGHT_PATH_ANGLE],
+                ),
+            )
+            cruise_vals = {
+                'mach': {'val': self.cruise_mach, 'units': cruise_kwargs['input_speed_units']},
+                'descent_fuel': {'val': estimated_descent_fuel, 'units': 'lbm'},
+            }
+
+            phases = {
+                **ascent_phases,
+                'cruise': {
+                    'ode': SGMCruise(**cruise_kwargs),
+                    'vals_to_set': cruise_vals,
+                },
+                **descent_phases,
+            }
+            full_traj = FlexibleTraj(
+                Phases=phases,
+                traj_final_state_output=[
+                    Dynamic.Mission.MASS,
+                    Dynamic.Mission.DISTANCE,
+                ],
+                traj_initial_state_input=[
+                    Dynamic.Mission.MASS,
+                    Dynamic.Mission.DISTANCE,
+                    Dynamic.Mission.ALTITUDE,
+                ],
+                traj_event_trigger_input=[
+                    # specify ODE, output_name, with units that SimuPyProblem expects
+                    # assume event function is of form ODE.output_name - value
+                    # third key is event_idx associated with input
+                    (phases['groundroll']['ode'], "TAS", 0,),
+                    (phases['climb3']['ode'], Dynamic.Mission.ALTITUDE, 0,),
+                    (phases['cruise']['ode'], Dynamic.Mission.MASS, 0,),
+                ],
+            )
+            traj = self.model.add_subsystem('traj', full_traj)
+            return traj
+
+        def add_subsystem_timeseries_outputs(phase, phase_name):
+            phase_options = self.phase_info[phase_name]
+            all_subsystems = self._get_all_subsystems(
+                phase_options['external_subsystems'])
+            for subsystem in all_subsystems:
+                timeseries_to_add = subsystem.get_outputs()
+                for timeseries in timeseries_to_add:
+                    phase.add_timeseries_output(timeseries)
+
+        if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            if self.analysis_scheme is AnalysisScheme.COLLOCATION:
+                for idx, phase_name in enumerate(phases):
+                    phase = traj.add_phase(phase_name, self._get_2dof_phase(phase_name))
+                    add_subsystem_timeseries_outputs(phase, phase_name)
+
+                    if phase_name == 'ascent':
+                        self._add_groundroll_eq_constraint(phase)
+
+        elif self.mission_method is HEIGHT_ENERGY or self.mission_method is SIMPLE:
+            for phase_idx, phase_name in enumerate(phases):
+                phase = traj.add_phase(
+                    phase_name, self._get_height_energy_phase(phase_name, phase_idx))
+                add_subsystem_timeseries_outputs(phase, phase_name)
+
+            # loop through phase_info and external subsystems
+            external_parameters = {}
+            for phase_name in self.phase_info:
+                external_parameters[phase_name] = {}
+                all_subsystems = self._get_all_subsystems(
+                    self.phase_info[phase_name]['external_subsystems'])
+                for subsystem in all_subsystems:
+                    parameter_dict = subsystem.get_parameters()
+                    for parameter in parameter_dict:
+                        external_parameters[phase_name][parameter] = parameter_dict[parameter]
+
+            traj = setup_trajectory_params(
+                self.model, traj, self.aviary_inputs, phases, meta_data=self.meta_data, external_parameters=external_parameters)
+
+        elif self.mission_method is SOLVED:
+            target_range = self.aviary_inputs.get_val(
+                Mission.Design.RANGE, units='nmi')
+            takeoff_mass = self.aviary_inputs.get_val(
+                Mission.Design.GROSS_MASS, units='lbm')
+            climb_mach = 0.8
+
+            for idx, phase_name in enumerate(phases):
+                phase = traj.add_phase(phase_name, self._get_solved_phase(phase_name))
+                add_subsystem_timeseries_outputs(phase, phase_name)
+
+                if phase_name in phases[1:3]:
+                    phase.add_path_constraint(
+                        "fuselage_pitch", upper=15., units='deg', ref=15)
+                if phase_name == "rotation":
+                    phase.add_boundary_constraint(
+                        "TAS", loc="final", upper=200., units="kn", ref=200.)
+                    phase.add_boundary_constraint(
+                        "normal_force", loc="final", equals=0., units="lbf", ref=10000.0)
+                elif phase_name == "ascent_to_gear_retract":
+                    phase.add_path_constraint("load_factor", lower=0.0, upper=1.10)
+                elif phase_name == "ascent_to_flap_retract":
+                    phase.add_path_constraint("load_factor", lower=0.0, upper=1.10)
+                elif phase_name == "ascent":
+                    phase.add_path_constraint(
+                        "EAS", upper=250., units="kn", ref=250.)
+                elif phase_name == 'climb_at_constant_TAS':
+                    phase.add_boundary_constraint(
+                        "EAS", loc="final", equals=250., units="kn", ref=250.)
+                elif phase_name == "climb_at_constant_EAS":
+                    pass
+                elif phase_name == "climb_at_constant_EAS_to_mach":
+                    phase.add_boundary_constraint(
+                        Dynamic.Mission.MACH, loc="final", equals=climb_mach, units="unitless")
+                elif phase_name == "climb_at_constant_mach":
+                    pass
+                elif phase_name == "descent":
+                    phase.add_boundary_constraint(
+                        Dynamic.Mission.RANGE,
+                        loc="final",
+                        equals=target_range,
+                        units="NM",
+                        ref=1.e3)
+                    phase.add_boundary_constraint(
+                        Dynamic.Mission.ALTITUDE,
+                        loc="final",
+                        equals=10.e3,
+                        units="ft",
+                        ref=10e3)
+                    phase.add_boundary_constraint(
+                        "TAS", loc="final", equals=250., units="kn", ref=250.)
+
+                phase.add_timeseries_output(
+                    Dynamic.Mission.THRUST_TOTAL, units="lbf")
+                phase.add_timeseries_output("thrust_req", units="lbf")
+                phase.add_timeseries_output("normal_force")
+                phase.add_timeseries_output(Dynamic.Mission.MACH)
+                phase.add_timeseries_output("EAS", units="kn")
+                phase.add_timeseries_output("TAS", units="kn")
+                phase.add_timeseries_output(Dynamic.Mission.LIFT)
+                phase.add_timeseries_output("CL")
+                phase.add_timeseries_output("CD")
+                phase.add_timeseries_output("time")
+                phase.add_timeseries_output("mass")
+                phase.add_timeseries_output(Dynamic.Mission.ALTITUDE)
+                phase.add_timeseries_output("gear_factor")
+                phase.add_timeseries_output("flap_factor")
+                phase.add_timeseries_output("alpha")
+                phase.add_timeseries_output(
+                    "fuselage_pitch", output_name="theta", units="deg")
+
+                if 'rotation' in phase_name:
+                    phase.add_parameter("t_init_gear", units="s",
+                                        static_target=True, opt=False, val=100)
+                    phase.add_parameter("t_init_flaps", units="s",
+                                        static_target=True, opt=False, val=100)
+
+        self.traj = traj
+
+        return traj

+
+
[docs]    def add_post_mission_systems(self, include_landing=True):
+        """
+        Add post-mission systems to the aircraft model. This is akin to the statics group
+        or the "premission_systems", but occurs after the mission in the execution order.
+
+        Depending on the mission model specified (`FLOPS` or `GASP`), this method adds various subsystems
+        to the aircraft model. For the `FLOPS` mission model, a landing phase is added using the Landing class
+        with the wing area and lift coefficient specified, and a takeoff constraints ExecComp is added to enforce
+        mass, range, velocity, and altitude continuity between the takeoff and climb phases. The landing subsystem
+        is promoted with aircraft and mission inputs and outputs as appropriate, while the takeoff constraints ExecComp
+        is only promoted with mission inputs and outputs.
+
+        For the `GASP` mission model, four subsystems are added: a LandingSegment subsystem, an ExecComp to calculate
+        the reserve fuel required, an ExecComp to calculate the overall fuel burn, and three ExecComps to calculate
+        various mission objectives and constraints. All subsystems are promoted with aircraft and mission inputs and
+        outputs as appropriate.
+
+        A user can override this with their own postmission systems.
+        """
+
+        if include_landing and self.post_mission_info['include_landing']:
+            if self.mission_method is HEIGHT_ENERGY or self.mission_method is SIMPLE:
+                self._add_flops_landing_systems()
+            elif self.mission_method is TWO_DEGREES_OF_FREEDOM:
+                self._add_gasp_landing_systems()
+
+        self.model.add_subsystem('post_mission', self.post_mission,
+                                 promotes_inputs=['*'],
+                                 promotes_outputs=['*'])
+
+        # Loop through all the phases in this subsystem.
+        for external_subsystem in self.post_mission_info['external_subsystems']:
+            # Get all the subsystem builders for this phase.
+            subsystem_postmission = external_subsystem.build_post_mission(
+                self.aviary_inputs)
+
+            if subsystem_postmission is not None:
+                self.post_mission.add_subsystem(external_subsystem.name,
+                                                subsystem_postmission)
+
+        if self.mission_method is HEIGHT_ENERGY or self.mission_method is SIMPLE:
+            phases = list(self.phase_info.keys())
+            ecomp = om.ExecComp('fuel_burned = initial_mass - mass_final',
+                                initial_mass={'units': 'lbm'},
+                                mass_final={'units': 'lbm'},
+                                fuel_burned={'units': 'lbm'})
+
+            self.post_mission.add_subsystem('fuel_burn', ecomp,
+                                            promotes_outputs=['fuel_burned'])
+
+            self.model.connect(f"traj.{phases[0]}.timeseries.states:mass",
+                               "fuel_burn.initial_mass", src_indices=[0])
+            self.model.connect(f"traj.{phases[-1]}.states:mass",
+                               "fuel_burn.mass_final", src_indices=[-1])
+
+            self._add_fuel_reserve_component()
+
+            # TODO: need to add some sort of check that this value is less than the fuel capacity
+            # TODO: the overall_fuel variable is the burned fuel plus the reserve, but should
+            # also include the unused fuel, and the hierarchy variable name should be more clear
+            ecomp = om.ExecComp('overall_fuel = fuel_burned + fuel_reserve',
+                                fuel_burned={'units': 'lbm', 'shape': 1},
+                                fuel_reserve={'units': 'lbm', 'shape': 1},
+                                overall_fuel={'units': 'lbm'})
+            self.post_mission.add_subsystem(
+                'fuel_calc', ecomp,
+                promotes_inputs=[
+                    'fuel_burned',
+                    ("fuel_reserve", Mission.Design.RESERVE_FUEL),
+                ],
+                promotes_outputs=[('overall_fuel', Mission.Summary.TOTAL_FUEL_MASS)])
+
+            if 'constrain_range' in self.post_mission_info:
+                if self.post_mission_info['constrain_range']:
+                    target_range = self.post_mission_info['target_range']
+                    self.post_mission.add_subsystem(
+                        "range_constraint",
+                        om.ExecComp(
+                            "range_resid = target_range - actual_range",
+                            range_resid={'units': 'nmi'},
+                            actual_range={'units': 'nmi'},
+                            target_range={
+                                'val': target_range[0], 'units': target_range[1]},
+                        ),
+                        promotes_outputs=[
+                            ("range_resid", Mission.Constraints.RANGE_RESIDUAL)],
+                    )
+
+                    self.model.connect(f"traj.{phases[-1]}.timeseries.states:range",
+                                       "range_constraint.actual_range", src_indices=[-1])
+                    self.model.add_constraint(
+                        Mission.Constraints.RANGE_RESIDUAL, equals=0.0, ref=1.e2)
+
+        ecomp = om.ExecComp(
+            'mass_resid = operating_empty_mass + overall_fuel + payload_mass -'
+            ' initial_mass',
+            operating_empty_mass={'units': 'lbm'},
+            overall_fuel={'units': 'lbm'},
+            payload_mass={'units': 'lbm'},
+            initial_mass={'units': 'lbm'},
+            mass_resid={'units': 'lbm'})
+
+        if self.mass_method is GASP:
+            payload_mass_src = Aircraft.CrewPayload.PASSENGER_PAYLOAD_MASS
+        else:
+            payload_mass_src = Aircraft.CrewPayload.TOTAL_PAYLOAD_MASS
+
+        self.post_mission.add_subsystem(
+            'mass_constraint', ecomp,
+            promotes_inputs=[
+                ('operating_empty_mass', Aircraft.Design.OPERATING_MASS),
+                ('overall_fuel', Mission.Summary.TOTAL_FUEL_MASS),
+                ('payload_mass', payload_mass_src),
+                ('initial_mass', Mission.Design.GROSS_MASS)],
+            promotes_outputs=[("mass_resid", Mission.Constraints.MASS_RESIDUAL)])
+
+        if self.mission_method is not SOLVED:
+            self.post_mission.add_constraint(
+                Mission.Constraints.MASS_RESIDUAL, equals=0.0, ref=1.e5)

+
+    def _link_phases_helper_with_options(self, phases, option_name, var, **kwargs):
+        phases_to_link = []
+        for idx, phase_name in enumerate(self.phase_info):
+            if self.phase_info[phase_name]['user_options'][option_name]:
+                # get the name of the previous phase
+                if idx > 0:
+                    prev_phase_name = phases[idx - 1]
+                    phases_to_link.append(prev_phase_name)
+                phases_to_link.append(phase_name)
+                if idx < len(phases) - 1:
+                    next_phase_name = phases[idx + 1]
+                    phases_to_link.append(next_phase_name)
+        if len(phases_to_link) > 1:
+            phases_to_link = list(dict.fromkeys(phases))
+            self.traj.link_phases(phases=phases_to_link, vars=[var], **kwargs)
+
+
+
+
[docs]    def add_driver(self, optimizer=None, use_coloring=None, max_iter=50, debug_print=False):
+        """
+        Add an optimization driver to the Aviary problem.
+
+        Depending on the provided optimizer, the method instantiates the relevant driver (ScipyOptimizeDriver or
+        pyOptSparseDriver) and sets the optimizer options. Options for 'SNOPT', 'IPOPT', and 'SLSQP' are
+        specified. The method also allows for the declaration of coloring and setting debug print options.
+
+        Parameters
+        ----------
+        optimizer : str
+            The name of the optimizer to use. It can be "SLSQP", "SNOPT", "IPOPT" or others supported by OpenMDAO.
+            If "SLSQP", it will instantiate a ScipyOptimizeDriver, else it will instantiate a pyOptSparseDriver.
+
+        use_coloring : bool, optional
+            If True (default), the driver will declare coloring, which can speed up derivative computations.
+
+        max_iter : int, optional
+            The maximum number of iterations allowed for the optimization process. Default is 50. This option is
+            applicable to "SNOPT", "IPOPT", and "SLSQP" optimizers.
+
+        debug_print : bool or list, optional
+            If True, default debug print options ['desvars','ln_cons','nl_cons','objs'] will be set. If a list is
+            provided, it will be used as the debug print options.
+
+        Returns
+        -------
+        None
+        """
+        # Set defaults for optimizer and use_coloring based on analysis scheme
+        if optimizer is None:
+            optimizer = 'IPOPT' if self.analysis_scheme is AnalysisScheme.SHOOTING else 'SNOPT'
+        if use_coloring is None:
+            use_coloring = False if self.analysis_scheme is AnalysisScheme.SHOOTING else True
+
+        # check if optimizer is SLSQP
+        if optimizer == "SLSQP":
+            driver = self.driver = om.ScipyOptimizeDriver()
+        else:
+            driver = self.driver = om.pyOptSparseDriver()
+
+        driver.options["optimizer"] = optimizer
+        if use_coloring:
+            driver.declare_coloring()
+
+        if driver.options["optimizer"] == "SNOPT":
+            driver.opt_settings["Major iterations limit"] = max_iter
+            driver.opt_settings["Major optimality tolerance"] = 1e-4
+            driver.opt_settings["Major feasibility tolerance"] = 1e-7
+            driver.opt_settings["iSumm"] = 6
+        elif driver.options["optimizer"] == "IPOPT":
+            driver.opt_settings['tol'] = 1.0E-6
+            driver.opt_settings['mu_init'] = 1e-5
+            driver.opt_settings['max_iter'] = max_iter
+            driver.opt_settings['print_level'] = 5
+            # for faster convergence
+            driver.opt_settings['nlp_scaling_method'] = 'gradient-based'
+            driver.opt_settings['alpha_for_y'] = 'safer-min-dual-infeas'
+            driver.opt_settings['mu_strategy'] = 'monotone'
+        elif driver.options["optimizer"] == "SLSQP":
+            driver.options["tol"] = 1e-9
+            driver.options["maxiter"] = max_iter
+            driver.options["disp"] = True
+
+        if debug_print:
+            if isinstance(debug_print, list):
+                driver.options['debug_print'] = debug_print
+            else:
+                driver.options['debug_print'] = ['desvars', 'ln_cons', 'nl_cons', 'objs']

+
+
[docs]    def add_design_variables(self):
+        """
+        Adds design variables to the Aviary problem.
+
+        Depending on the mission model and problem type, different design variables and constraints are added.
+
+        If using the FLOPS model, a design variable is added for the gross mass of the aircraft, with a lower bound of 100,000 lbm and an upper bound of 200,000 lbm.
+
+        If using the GASP model, the following design variables are added depending on the mission type:
+            - the initial thrust-to-weight ratio of the aircraft during ascent
+            - the duration of the ascent phase
+            - the time constant for the landing gear actuation
+            - the time constant for the flaps actuation
+
+        In addition, two constraints are added for the GASP model:
+            - the initial altitude of the aircraft with gear extended is constrained to be 50 ft
+            - the initial altitude of the aircraft with flaps extended is constrained to be 400 ft
+
+        If solving a sizing problem, a design variable is added for the gross mass of the aircraft, and another for the gross mass of the aircraft computed during the mission. A constraint is also added to ensure that the residual range is zero.
+
+        If solving an alternate problem, only a design variable for the gross mass of the aircraft computed during the mission is added. A constraint is also added to ensure that the residual range is zero.
+
+        In all cases, a design variable is added for the final cruise mass of the aircraft, with no upper bound, and a residual mass constraint is added to ensure that the mass balances.
+
+        """
+        # add the engine builder `get_design_vars` dict to a collected dict from the external subsystems
+
+        # TODO : maybe in the most general case we need to handle DVs in the mission and post-mission as well.
+        # for right now we just handle pre_mission
+        all_subsystems = self._get_all_subsystems()
+
+        # loop through all_subsystems and call `get_design_vars` on each subsystem
+        for subsystem in all_subsystems:
+            dv_dict = subsystem.get_design_vars()
+            for dv_name, dv_dict in dv_dict.items():
+                self.model.add_design_var(dv_name, **dv_dict)
+
+        if self.mission_method is HEIGHT_ENERGY or self.mission_method is SIMPLE:
+            optimize_mass = self.pre_mission_info.get('optimize_mass')
+            if optimize_mass:
+                self.model.add_design_var(Mission.Design.GROSS_MASS, units='lbm',
+                                          lower=100.e3, upper=200.e3, ref=135.e3)
+
+        elif self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            if self.analysis_scheme is AnalysisScheme.COLLOCATION:
+                # problem formulation to make the trajectory work
+                self.model.add_design_var(Mission.Takeoff.ASCENT_T_INTIIAL,
+                                          lower=0, upper=100, ref=30.0)
+                self.model.add_design_var(Mission.Takeoff.ASCENT_DURATION,
+                                          lower=1, upper=1000, ref=10.)
+                self.model.add_design_var("tau_gear", lower=0.01,
+                                          upper=1.0, units="s", ref=1)
+                self.model.add_design_var("tau_flaps", lower=0.01,
+                                          upper=1.0, units="s", ref=1)
+                self.model.add_constraint(
+                    "h_fit.h_init_gear", equals=50.0, units="ft", ref=50.0)
+                self.model.add_constraint("h_fit.h_init_flaps",
+                                          equals=400.0, units="ft", ref=400.0)
+
+            self.problem_type = self.aviary_inputs.get_val('problem_type')
+
+            # vehicle sizing problem
+            # size the vehicle (via design GTOW) to meet a target range using all fuel capacity
+            if self.problem_type is ProblemType.SIZING:
+                self.model.add_design_var(
+                    Mission.Design.GROSS_MASS,
+                    lower=10.,
+                    upper=400.e3,
+                    units="lbm",
+                    ref=175_000,
+                )
+                self.model.add_design_var(
+                    Mission.Summary.GROSS_MASS,
+                    lower=10.,
+                    upper=400.e3,
+                    units="lbm",
+                    ref=175_000,
+                )
+
+                self.model.add_constraint(
+                    Mission.Constraints.RANGE_RESIDUAL, equals=0, ref=10
+                )
+                self.model.add_subsystem(
+                    "gtow_constraint",
+                    om.EQConstraintComp(
+                        "GTOW",
+                        eq_units="lbm",
+                        normalize=True,
+                        add_constraint=True,
+                    ),
+                    promotes_inputs=[
+                        ("lhs:GTOW", Mission.Design.GROSS_MASS),
+                        ("rhs:GTOW", Mission.Summary.GROSS_MASS),
+                    ],
+                )
+
+            # target range problem
+            # fixed vehicle (design GTOW) but variable actual GTOW for off-design mission range
+            elif self.problem_type is ProblemType.ALTERNATE:
+                self.model.add_design_var(
+                    Mission.Summary.GROSS_MASS,
+                    lower=0,
+                    upper=None,
+                    units="lbm",
+                    ref=175_000,
+                )
+
+                self.model.add_constraint(
+                    Mission.Constraints.RANGE_RESIDUAL, equals=0, ref=10,
+                )
+            elif self.problem_type is ProblemType.FALLOUT:
+                print('No design variables for Fallout missions')

+
+
[docs]    def add_objective(self, objective_type=None, ref=None):
+        """
+        Add the objective function based on the given objective_type and ref.
+
+        NOTE: the ref value should be positive for values you're trying
+        to minimize and negative for values you're trying to maximize.
+        Please check and double-check that your ref value makes sense
+        for the objective you're using.
+
+        Parameters
+        ----------
+        objective_type : str
+            The type of objective to add. Options are 'mass', 'hybrid_objective', 'fuel_burned', and 'fuel'.
+        ref : float
+            The reference value for the objective. If None, a default value will be used based on the objective type. Please see the
+            `default_ref_values` dict for these default values.
+
+        Raises
+        ------
+            ValueError: If an invalid problem type is provided.
+
+        """
+        # Dictionary for default reference values
+        default_ref_values = {
+            'mass': -5e4,
+            'hybrid_objective': -5e4,
+            'fuel_burned': 1e4,
+            'fuel': 1e4
+        }
+
+        # Check if an objective type is specified
+        if objective_type is not None:
+            ref = ref if ref is not None else default_ref_values.get(objective_type, 1)
+
+            if objective_type == 'mass':
+                last_phase = list(self.traj._phases.items())[-1][1]
+                last_phase.add_objective(
+                    Dynamic.Mission.MASS, loc='final', ref=ref)
+            elif objective_type == "hybrid_objective":
+                self._add_hybrid_objective(self.phase_info)
+                self.model.add_objective("obj_comp.obj")
+            elif objective_type == "fuel_burned":
+                self.model.add_objective("fuel_burned", ref=ref)
+            elif objective_type == "fuel":
+                self.model.add_objective(Mission.Objectives.FUEL, ref=ref)
+
+        # If 'mission_method' is 'FLOPS', add a 'fuel_burned' objective
+        elif self.mission_method is HEIGHT_ENERGY or self.mission_method is SIMPLE:
+            ref = ref if ref is not None else default_ref_values.get("fuel_burned", 1)
+            self.model.add_objective("fuel_burned", ref=ref)
+
+        else:  # If no 'objective_type' is specified, we handle based on 'problem_type'
+            # If 'ref' is not specified, assign a default value
+            ref = ref if ref is not None else 1
+
+            if self.problem_type is ProblemType.SIZING:
+                self.model.add_objective(Mission.Objectives.FUEL, ref=ref)
+            elif self.problem_type is ProblemType.ALTERNATE:
+                self.model.add_objective(Mission.Objectives.FUEL, ref=ref)
+            elif self.problem_type is ProblemType.FALLOUT:
+                self.model.add_objective(Mission.Objectives.RANGE, ref=ref)
+            else:
+                raise ValueError(f'{self.problem_type} is not a valid problem type.')

+
+    def _add_bus_variables_and_connect(self):
+        all_subsystems = self._get_all_subsystems()
+
+        base_phases = list(self.phase_info.keys())
+
+        for external_subsystem in all_subsystems:
+            bus_variables = external_subsystem.get_bus_variables()
+            if bus_variables is not None:
+                for bus_variable in bus_variables:
+                    mission_variable_name = bus_variables[bus_variable]['mission_name']
+
+                    # check if mission_variable_name is a list
+                    if not isinstance(mission_variable_name, list):
+                        mission_variable_name = [mission_variable_name]
+
+                    # loop over the mission_variable_name list and add each variable to the trajectory
+                    for mission_var_name in mission_variable_name:
+                        if 'mission_name' in bus_variables[bus_variable]:
+                            if mission_var_name not in self.meta_data:
+                                # base_units = self.model.get_io_metadata(includes=f'pre_mission.{external_subsystem.name}.{bus_variable}')[f'pre_mission.{external_subsystem.name}.{bus_variable}']['units']
+                                base_units = bus_variables[bus_variable]['units']
+
+                                shape = bus_variables[bus_variable].get(
+                                    'shape', _unspecified)
+
+                                targets = mission_var_name
+                                if '.' in mission_var_name:
+                                    # Support for non-hiearchy variables as parameters.
+                                    mission_var_name = mission_var_name.split('.')[-1]
+
+                                if 'phases' in bus_variables[bus_variable]:
+                                    # Support for connecting bus variables into a subset of
+                                    # phases.
+                                    phases = bus_variables[bus_variable]['phases']
+
+                                    for phase_name in phases:
+                                        phase = getattr(self.traj.phases, phase_name)
+
+                                        phase.add_parameter(mission_var_name, opt=False, static_target=True,
+                                                            units=base_units, shape=shape, targets=targets)
+
+                                        self.model.connect(f'pre_mission.{bus_variable}',
+                                                           f'traj.{phase_name}.parameters:{mission_var_name}')
+
+                                else:
+                                    phases = base_phases
+
+                                    self.traj.add_parameter(mission_var_name, opt=False, static_target=True,
+                                                            units=base_units, shape=shape, targets={
+                                                                phase_name: [mission_var_name] for phase_name in phases})
+
+                                    self.model.connect(
+                                        f'pre_mission.{bus_variable}', f'traj.parameters:'+mission_var_name)
+
+                        if 'post_mission_name' in bus_variables[bus_variable]:
+                            self.model.connect(f'pre_mission.{external_subsystem.name}.{bus_variable}',
+                                               f'post_mission.{external_subsystem.name}.{bus_variables[bus_variable]["post_mission_name"]}')
+
+
[docs]    def setup(self, **kwargs):
+        """
+        Lightly wrappd setup() method for the problem.
+
+        Allows us to do pre- and post-setup changes, like adding
+        calls to `set_input_defaults` and do some simple `set_vals`
+        if needed.
+        """
+        # Adding a trailing component that contains all inputs so that set_input_defaults
+        # doesn't raise any errors.
+        self.model.add_subsystem(
+            'input_sink',
+            VariablesIn(aviary_options=self.aviary_inputs,
+                        meta_data=self.meta_data),
+            promotes_inputs=['*'],
+            promotes_outputs=['*'])
+
+        # suppress warnings:
+        # "input variable '...' promoted using '*' was already promoted using 'aircraft:*'
+        with warnings.catch_warnings():
+
+            # Set initial default values for all LEAPS aircraft variables.
+            set_aviary_initial_values(
+                self.model, self.aviary_inputs, meta_data=self.meta_data)
+
+            warnings.simplefilter("ignore", om.PromotionWarning)
+            super().setup(**kwargs)

+
+
[docs]    def set_initial_guesses(self):
+        """
+        Call `set_val` on the trajectory for states and controls to seed
+        the problem with reasonable initial guesses. This is especially
+        important for collocation methods.
+
+        This method first identifies all phases in the trajectory then
+        loops over each phase. If the mission method is "solved", solved guesses
+        are added to the problem for each phase as those are handled differently
+        than other mission types. If not solved, specific initial guesses
+        are added depending on the phase and mission method. Cruise is treated
+        as a special phase for GASP-based missions because it is an AnalyticPhase
+        in Dymos. For this phase, we handle the initial guesses first separately
+        and continue to the next phase after that. For other phases, we set the initial
+        guesses for states and controls according to the information available
+        in the 'initial_guesses' attribute of the phase.
+        """
+        # Grab the trajectory object from the model
+        if self.analysis_scheme is AnalysisScheme.SHOOTING:
+            if self.problem_type is ProblemType.SIZING:
+                self.set_val(Mission.Summary.GROSS_MASS,
+                             self.get_val(Mission.Design.GROSS_MASS))
+
+            self.set_val("traj.SGMClimb_"+Dynamic.Mission.ALTITUDE +
+                         "_trigger", val=self.cruise_alt, units="ft")
+
+            return
+
+        traj = self.model.traj
+
+        # Determine which phases to loop over, fetching them from the trajectory
+        phase_items = traj._phases.items()
+
+        # Loop over each phase and set initial guesses for the state and control variables
+        for idx, (phase_name, phase) in enumerate(phase_items):
+            if self.mission_method is SOLVED:
+                # If so, add solved guesses to the problem
+                self._add_solved_guesses(idx, phase_name, phase)
+            else:
+                # If not, fetch the initial guesses specific to the phase
+                guesses = self.phase_info[phase_name]['initial_guesses']
+
+                if 'cruise' in phase_name and self.mission_method is TWO_DEGREES_OF_FREEDOM:
+                    for guess_key, guess_data in guesses.items():
+                        val, units = guess_data
+
+                        if 'mass' == guess_key:
+                            # Set initial and duration mass for the analytic cruise phase.
+                            # Note we are integrating over mass, not time for this phase.
+                            self.set_val(f'traj.{phase_name}.t_initial',
+                                         val[0], units=units)
+                            self.set_val(f'traj.{phase_name}.t_duration',
+                                         val[1], units=units)
+                        else:
+                            # Otherwise, set the value of the parameter in the trajectory phase
+                            self.set_val(f'traj.{phase_name}.parameters:{guess_key}',
+                                         val, units=units)
+
+                    continue
+
+                # If not cruise and GASP, add subsystem guesses
+                self._add_subsystem_guesses(phase_name, phase)
+
+                # Set initial guesses for states and controls for each phase
+                self._add_guesses(phase_name, phase, guesses)

+
+    def _process_guess_var(self, val, key, phase):
+        """
+        Process the guess variable, which can either be a float or an array of floats.
+
+        This method is responsible for interpolating initial guesses when the user
+        provides a list or array of values rather than a single float. It interpolates
+        the guess values across the phase's domain for a given variable, be it a control
+        or a state variable. The interpolation is performed between -1 and 1 (representing
+        the normalized phase time domain), using the numpy linspace function.
+
+        The result of this method is a single value or an array of interpolated values
+        that can be used to seed the optimization problem with initial guesses.
+
+        Parameters
+        ----------
+        val : float or list/array of floats
+            The initial guess value(s) for a particular variable.
+        key : str
+            The key identifying the variable for which the initial guess is provided.
+        phase : Phase
+            The phase for which the variable is being set.
+
+        Returns
+        -------
+        val : float or array of floats
+            The processed guess value(s) to be used in the optimization problem.
+        """
+
+        # Check if val is not a single float
+        if not isinstance(val, float):
+            # If val is an array of values
+            if len(val) > 1:
+                # Get the shape of the val array
+                shape = np.shape(val)
+
+                # Generate an array of evenly spaced values between -1 and 1,
+                # reshaping to match the shape of the val array
+                xs = np.linspace(-1, 1, num=np.prod(shape)).reshape(shape)
+
+                # Check if the key indicates a control or state variable
+                if "controls:" in key or "states:" in key:
+                    # If so, strip the first part of the key to match the variable name in phase
+                    stripped_key = ":".join(key.split(":")[1:])
+
+                    # Interpolate the initial guess values across the phase's domain
+                    val = phase.interp(stripped_key, xs=xs, ys=val)
+                else:
+                    # If not a control or state variable, interpolate the initial guess values directly
+                    val = phase.interp(key, xs=xs, ys=val)
+
+        # Return the processed guess value(s)
+        return val
+
+    def _add_subsystem_guesses(self, phase_name, phase):
+        """
+        Adds the initial guesses for each subsystem of a given phase to the problem.
+
+        This method first fetches all subsystems associated with the given phase.
+        It then loops over each subsystem and fetches its initial guesses. For each
+        guess, it identifies whether the guess corresponds to a state or a control
+        variable and then processes the guess variable. After this, the initial
+        guess is set in the problem using the `set_val` method.
+
+        Parameters
+        ----------
+        phase_name : str
+            The name of the phase for which the subsystem guesses are being added.
+        phase : Phase
+            The phase object for which the subsystem guesses are being added.
+        """
+
+        # Get all subsystems associated with the phase
+        all_subsystems = self._get_all_subsystems(
+            self.phase_info[phase_name]['external_subsystems'])
+
+        # Loop over each subsystem
+        for subsystem in all_subsystems:
+            # Fetch the initial guesses for the subsystem
+            initial_guesses = subsystem.get_initial_guesses()
+
+            # Loop over each guess
+            for key, val in initial_guesses.items():
+                # Identify the type of the guess (state or control)
+                type = val.pop('type')
+                if 'state' in type:
+                    path_string = 'states'
+                elif 'control' in type:
+                    path_string = 'controls'
+
+                # Process the guess variable (handles array interpolation)
+                val['val'] = self._process_guess_var(val['val'], key, phase)
+
+                # Set the initial guess in the problem
+                self.set_val(f'traj.{phase_name}.{path_string}:{key}', **val)
+
+    def _add_guesses(self, phase_name, phase, guesses):
+        """
+        Adds the initial guesses for each variable of a given phase to the problem.
+
+        This method sets the initial guesses for time, control, state, and problem-specific
+        variables for a given phase. If using the GASP model, it also handles some special
+        cases that are not covered in the `phase_info` object. These include initial guesses
+        for mass, time, and distance, which are determined based on the phase name and other
+        mission-related variables.
+
+        Parameters
+        ----------
+        phase_name : str
+            The name of the phase for which the guesses are being added.
+        phase : Phase
+            The phase object for which the guesses are being added.
+        guesses : dict
+            A dictionary containing the initial guesses for the phase.
+        """
+
+        # If using the GASP model, set initial guesses for the rotation mass and flight duration
+        if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            rotation_mass = self.initial_guesses['rotation_mass']
+            flight_duration = self.initial_guesses['flight_duration']
+
+        if self.mission_method is SIMPLE:
+            control_keys = ["mach", "altitude"]
+            state_keys = ["mass", "range"]
+        else:
+            control_keys = ["velocity_rate", "throttle"]
+            state_keys = ["altitude", "velocity", "mass",
+                          "range", "TAS", "distance", "flight_path_angle", "alpha"]
+            if self.mission_method is TWO_DEGREES_OF_FREEDOM and phase_name == 'ascent':
+                # Alpha is a control for ascent.
+                control_keys.append('alpha')
+
+        prob_keys = ["tau_gear", "tau_flaps"]
+
+        # for the simple mission method, use the provided initial and final mach and altitude values from phase_info
+        if self.mission_method is SIMPLE:
+            initial_altitude = self.phase_info[phase_name]['user_options']['initial_altitude']
+            final_altitude = self.phase_info[phase_name]['user_options']['final_altitude']
+            initial_mach = self.phase_info[phase_name]['user_options']['initial_mach']
+            final_mach = self.phase_info[phase_name]['user_options']['final_mach']
+
+            # add a check for the altitude units, raise an error if they are not consistent
+            if initial_altitude[1] != final_altitude[1]:
+                raise ValueError(
+                    f"Initial and final altitude units for {phase_name} are not consistent.")
+            guesses["mach"] = ([initial_mach[0], final_mach[0]], "unitless")
+            guesses["altitude"] = (
+                [initial_altitude[0], final_altitude[0]], initial_altitude[1])
+
+        for guess_key, guess_data in guesses.items():
+            val, units = guess_data
+
+            # Set initial guess for time variables
+            if 'times' == guess_key:
+                self.set_val(f'traj.{phase_name}.t_initial',
+                             val[0], units=units)
+                self.set_val(f'traj.{phase_name}.t_duration',
+                             val[1], units=units)
+
+            else:
+                # Set initial guess for control variables
+                if guess_key in control_keys:
+                    try:
+                        self.set_val(f'traj.{phase_name}.controls:{guess_key}', self._process_guess_var(
+                            val, guess_key, phase), units=units)
+                    except KeyError:
+                        try:
+                            self.set_val(f'traj.{phase_name}.polynomial_controls:{guess_key}', self._process_guess_var(
+                                val, guess_key, phase), units=units)
+                        except KeyError:
+                            self.set_val(f'traj.{phase_name}.bspline_controls:{guess_key}', self._process_guess_var(
+                                val, guess_key, phase), units=units)
+
+                # Set initial guess for state variables
+                elif guess_key in state_keys:
+                    self.set_val(f'traj.{phase_name}.states:{guess_key}', self._process_guess_var(
+                        val, guess_key, phase), units=units)
+                elif guess_key in prob_keys:
+                    self.set_val(guess_key, val, units=units)
+                elif ":" in guess_key:
+                    self.set_val(f'traj.{phase_name}.{guess_key}', self._process_guess_var(
+                        val, guess_key, phase), units=units)
+                else:
+                    # raise error if the guess key is not recognized
+                    raise ValueError(
+                        f"Initial guess key {guess_key} in {phase_name} is not recognized.")
+
+        # We need some special logic for these following variables because GASP computes
+        # initial guesses using some knowledge of the mission duration and other variables
+        # that are only available after calling `create_vehicle`. Thus these initial guess
+        # values are not included in the `phase_info` object.
+        if 'mass' not in guesses:
+            if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+                # Determine a mass guess depending on the phase name
+                if phase_name in ["groundroll", "rotation", "ascent", "accel", "climb1"]:
+                    mass_guess = rotation_mass
+                elif phase_name == "climb2":
+                    mass_guess = 0.99 * rotation_mass
+                elif "desc" in phase_name:
+                    mass_guess = 0.9 * self.cruise_mass_final
+            else:
+                mass_guess = self.aviary_inputs.get_val(
+                    Mission.Design.GROSS_MASS, units='lbm')
+            # Set the mass guess as the initial value for the mass state variable
+            self.set_val(f'traj.{phase_name}.states:mass',
+                         mass_guess, units='lbm')
+
+        if 'times' not in guesses:
+            # Determine initial time and duration guesses depending on the phase name
+            if 'desc1' == phase_name:
+                t_initial = flight_duration*.9
+                t_duration = flight_duration*.04
+            elif 'desc2' in phase_name:
+                t_initial = flight_duration*.94
+                t_duration = 5000
+            # Set the time guesses as the initial values for the time-related trajectory variables
+            self.set_val(f"traj.{phase_name}.t_initial",
+                         t_initial, units='s')
+            self.set_val(f"traj.{phase_name}.t_duration",
+                         t_duration, units='s')
+
+        if self.mission_method is TWO_DEGREES_OF_FREEDOM:
+            if 'distance' not in guesses:
+                # Determine initial distance guesses depending on the phase name
+                if 'desc1' == phase_name:
+                    ys = [self.target_range*.97, self.target_range*.99]
+                elif 'desc2' in phase_name:
+                    ys = [self.target_range*.99, self.target_range]
+                # Set the distance guesses as the initial values for the distance state variable
+                self.set_val(
+                    f"traj.{phase_name}.states:distance", phase.interp(
+                        "distance", ys=ys)
+                )
+
+    def _add_solved_guesses(self, idx, phase_name, phase):
+        target_range = self.aviary_inputs.get_val(
+            Mission.Design.RANGE, units='nmi')
+        takeoff_mass = self.aviary_inputs.get_val(
+            Mission.Design.GROSS_MASS, units='lbm')
+        cruise_alt = self.aviary_inputs.get_val(
+            Mission.Design.CRUISE_ALTITUDE, units='ft')
+
+        range_guesses = np.array([  # in meters
+            0.,  # 'groundroll',
+            1000.,  # 'rotation',
+            1500.,  # 'ascent_to_gear_retract',
+            2000.,  # 'ascent_to_flap_retract',
+            2500.,  # 'ascent',
+            3500.,  # 'climb_at_constant_TAS',
+            4500.,  # 'climb_at_constant_EAS',
+            32000.,  # 'climb_at_constant_EAS_to_mach',
+            300.e3,  # 'climb_at_constant_mach',
+            600.e3,  # 'cruise',
+            1700. * target_range,  # 'descent'
+            1700. * target_range + 200000.,
+        ])
+        mass_guesses = np.array([
+            1.0,
+            0.999,
+            0.999,
+            0.999,
+            0.998,
+            0.998,
+            0.998,
+            0.990,
+            0.969,
+            0.951,
+            0.873,
+            0.866,
+        ]) * takeoff_mass
+        alt_guesses = [
+            0.0,
+            0.0,
+            0.0,
+            50.0,
+            400.0,
+            500.0,
+            500.0,
+            10000.,
+            32857.,
+            cruise_alt,
+            cruise_alt,
+            10000.,
+        ]
+        TAS_guesses = np.array([
+            0.0,
+            150.,
+            200.,
+            200.,
+            200.,
+            225.,
+            251.,
+            290.,
+            465. * self.cruise_mach / 0.8,
+            458. * self.cruise_mach / 0.8,
+            483. * self.cruise_mach / 0.8,
+            250.,
+        ])
+
+        mean_TAS = (TAS_guesses[1:] + TAS_guesses[:-1]) / 2. / 1.94
+        range_durations = range_guesses[1:] - range_guesses[:-1]
+        time_guesses = np.hstack((0., np.cumsum(range_durations / mean_TAS)))
+
+        if phase_name != "groundroll":
+            range_initial = range_guesses[idx]
+            self.set_val(f"traj.{phase_name}.t_initial",
+                         range_initial, units='range_units')
+            self.set_val(f"traj.{phase_name}.t_duration",
+                         range_guesses[idx+1] - range_initial, units='range_units')
+
+            self.set_val(
+                f"traj.{phase_name}.polynomial_controls:altitude",
+                phase.interp(Dynamic.Mission.ALTITUDE, [
+                    alt_guesses[idx], alt_guesses[idx + 1]]),
+                units="ft",
+            )
+
+            if "constant_EAS" in phase_name or "constant_mach" in phase_name or "cruise" in phase_name:
+                pass
+            else:
+                self.set_val(
+                    f"traj.{phase_name}.polynomial_controls:TAS",
+                    phase.interp(
+                        "TAS", [TAS_guesses[idx], TAS_guesses[idx+1]]),
+                    units="kn",
+                )
+        else:
+            self.set_val(f"traj.{phase_name}.t_initial", 0., units='kn')
+            self.set_val(f"traj.{phase_name}.t_duration", 100., units='kn')
+
+        self.set_val(
+            f"traj.{phase_name}.states:mass",
+            phase.interp("mass", [mass_guesses[idx], mass_guesses[idx+1]]),
+            units="lbm",
+        )
+
+        self.set_val(
+            f"traj.{phase_name}.states:time",
+            phase.interp("time", [time_guesses[idx], time_guesses[idx+1]]),
+            units="s",
+        )
+
+        self.final_setup()
+
+
[docs]    def run_aviary_problem(self,
+                           record_filename="aviary_history.db",
+                           optimization_history_filename=None,
+                           restart_filename=None, suppress_solver_print=True, run_driver=True, simulate=False, make_plots=True):
+        """
+        This function actually runs the Aviary problem, which could be a simulation, optimization, or a driver execution, depending on the arguments provided.
+
+        Parameters
+        ----------
+        record_filename : str, optional
+            The name of the database file where the solutions are to be recorded. The default is "aviary_history.db".
+        optimization_history_filename : str, None
+            The name of the database file where the driver iterations are to be recorded. The default is None.
+        restart_filename : str, optional
+            The name of the file that contains previously computed solutions which are to be used as starting points for this run. If it is None (default), no restart file will be used.
+        suppress_solver_print : bool, optional
+            If True (default), all solvers' print statements will be suppressed. Useful for deeply nested models with multiple solvers so the print statements don't overwhelm the output.
+        run_driver : bool, optional
+            If True (default), the driver (aka optimizer) will be executed. If False, the problem will be run through one pass -- equivalent to OpenMDAO's `run_model` behavior.
+        simulate : bool, optional
+            If True, an explicit Dymos simulation will be performed. The default is False.
+        make_plots : bool, optional
+            If True (default), Dymos html plots will be generated as part of the output.
+        """
+
+        if self.aviary_inputs.get_val('debug_mode'):
+            self.final_setup()
+            with open('input_list.txt', 'w') as outfile:
+                self.model.list_inputs(out_stream=outfile)
+
+        if suppress_solver_print:
+            self.set_solver_print(level=0)
+
+        if optimization_history_filename:
+            recorder = om.SqliteRecorder(optimization_history_filename)
+            self.driver.add_recorder(recorder)
+
+        # and run mission, and dynamics
+        if run_driver:
+            failed = dm.run_problem(self, run_driver=run_driver, simulate=simulate, make_plots=make_plots,
+                                    solution_record_file=record_filename, restart=restart_filename)
+        else:
+            # prevent UserWarning that is displayed when an event is triggered
+            warnings.filterwarnings('ignore', category=UserWarning)
+            failed = self.run_model()
+            warnings.filterwarnings('default', category=UserWarning)
+
+        if self.aviary_inputs.get_val('debug_mode'):
+            with open('output_list.txt', 'w') as outfile:
+                self.model.list_outputs(out_stream=outfile)
+
+        return failed

+
+    def _add_hybrid_objective(self, phase_info):
+        phases = list(phase_info.keys())
+        takeoff_mass = self.aviary_inputs.get_val(
+            Mission.Design.GROSS_MASS, units='lbm')
+
+        obj_comp = om.ExecComp(f"obj = -final_mass / {takeoff_mass} + final_time / 5.",
+                               final_mass={"units": "lbm"},
+                               final_time={"units": "h"})
+        self.model.add_subsystem("obj_comp", obj_comp)
+
+        final_phase_name = phases[-1]
+        self.model.connect(f"traj.{final_phase_name}.timeseries.mass",
+                           "obj_comp.final_mass", src_indices=[-1])
+        self.model.connect(f"traj.{final_phase_name}.timeseries.time",
+                           "obj_comp.final_time", src_indices=[-1])
+
+    def _add_vrotate_comp(self):
+        self.model.add_subsystem("vrot_comp", VRotateComp())
+        self.model.connect('traj.groundroll.states:mass',
+                           'vrot_comp.mass', src_indices=om.slicer[0, ...])
+
+        vrot_eq_comp = self.model.add_subsystem("vrot_eq_comp", om.EQConstraintComp())
+        vrot_eq_comp.add_eq_output("v_rotate_error", eq_units="kn",
+                                   lhs_name="v_rot_computed", rhs_name="groundroll_v_final", add_constraint=True)
+
+        self.model.connect('vrot_comp.Vrot', 'vrot_eq_comp.v_rot_computed')
+        self.model.connect('traj.groundroll.timeseries.TAS',
+                           'vrot_eq_comp.groundroll_v_final', src_indices=om.slicer[-1, ...])
+
+    def _save_to_csv_file(self, filename):
+        with open(filename, 'w', newline='') as csvfile:
+            fieldnames = ['name', 'value', 'units']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+
+            for name, value_units in sorted(self.aviary_inputs):
+                if 'engine_models' in name:
+                    continue
+                value, units = value_units
+                writer.writerow({'name': name, 'value': value, 'units': units})
+
+    def _get_all_subsystems(self, external_subsystems=None):
+        all_subsystems = []
+        if external_subsystems is None:
+            all_subsystems.extend(self.pre_mission_info['external_subsystems'])
+        else:
+            all_subsystems.extend(external_subsystems)
+
+        if self.engine_builder is not None:
+            all_subsystems.append(self.engine_builder)
+
+        return all_subsystems
+
+    def _add_flops_landing_systems(self):
+        landing_options = Landing(
+            ref_wing_area=self.aviary_inputs.get_val(
+                Aircraft.Wing.AREA, units='ft**2'),
+            Cl_max_ldg=self.aviary_inputs.get_val(
+                Mission.Landing.LIFT_COEFFICIENT_MAX)  # no units
+        )
+
+        landing = landing_options.build_phase(
+            False,
+        )
+        self.model.add_subsystem(
+            'landing', landing, promotes_inputs=['aircraft:*', 'mission:*'],
+            promotes_outputs=['mission:*'])
+
+        connect_takeoff_to_climb = not self.phase_info['climb']['user_options'].get(
+            'add_initial_mass_constraint', True)
+
+        if connect_takeoff_to_climb:
+            self.model.connect(Mission.Takeoff.FINAL_MASS,
+                               'traj.climb.initial_states:mass')
+            self.model.connect(Mission.Takeoff.GROUND_DISTANCE,
+                               'traj.climb.initial_states:range')
+            if self.mission_method is HEIGHT_ENERGY:
+                self.model.connect(Mission.Takeoff.FINAL_VELOCITY,
+                                   'traj.climb.initial_states:velocity')
+                self.model.connect(Mission.Takeoff.FINAL_ALTITUDE,
+                                   'traj.climb.initial_states:altitude')
+            else:
+                pass
+                # TODO: connect this correctly
+                # mass is the most important to connect but these others should
+                # be connected as well
+                # self.model.connect(Mission.Takeoff.FINAL_VELOCITY,
+                #                 'traj.climb.initial_states:mach')
+                # self.model.connect(Mission.Takeoff.FINAL_ALTITUDE,
+                #                 'traj.climb.controls:altitude')
+
+        self.model.connect('traj.descent.states:mass',
+                           Mission.Landing.TOUCHDOWN_MASS, src_indices=[-1])
+        # TODO: approach velocity should likely be connected
+        if self.mission_method is HEIGHT_ENERGY:
+            self.model.connect('traj.descent.states:altitude', Mission.Landing.INITIAL_ALTITUDE,
+                               src_indices=[-1])
+        else:
+            self.model.connect('traj.descent.control_values:altitude', Mission.Landing.INITIAL_ALTITUDE,
+                               src_indices=[0])
+
+    def _add_gasp_landing_systems(self):
+        self.model.add_subsystem(
+            "landing",
+            LandingSegment(
+                **(self.ode_args)),
+            promotes_inputs=['aircraft:*', 'mission:*'],
+            promotes_outputs=['mission:*'],
+        )
+
+        self._add_fuel_reserve_component()
+
+        self.model.add_subsystem(
+            "fuel_burn",
+            om.ExecComp(
+                "overall_fuel = (1 + fuel_margin/100)*(takeoff_mass - final_mass) + reserve_fuel",
+                takeoff_mass={"units": "lbm"},
+                final_mass={"units": "lbm"},
+                fuel_margin={"units": "unitless"},
+                reserve_fuel={"units": "lbm"},
+                overall_fuel={"units": "lbm"},
+            ),
+            promotes_inputs=[
+                ("takeoff_mass", Mission.Summary.GROSS_MASS),
+                ("fuel_margin", Aircraft.Fuel.FUEL_MARGIN),
+                ("final_mass", Mission.Landing.TOUCHDOWN_MASS),
+                ("reserve_fuel", Mission.Design.RESERVE_FUEL),
+            ],
+            promotes_outputs=[("overall_fuel", Mission.Summary.TOTAL_FUEL_MASS)],
+        )
+
+        self.model.add_subsystem(
+            "fuel_obj",
+            om.ExecComp(
+                "reg_objective = overall_fuel/10000 + ascent_duration/30.",
+                reg_objective={"val": 0.0, "units": "unitless"},
+                ascent_duration={"units": "s", "shape": 1},
+                overall_fuel={"units": "lbm"},
+            ),
+            promotes_inputs=[
+                ("ascent_duration", Mission.Takeoff.ASCENT_DURATION),
+                ("overall_fuel", Mission.Summary.TOTAL_FUEL_MASS),
+            ],
+            promotes_outputs=[("reg_objective", Mission.Objectives.FUEL)],
+        )
+
+        self.model.add_subsystem(
+            "range_obj",
+            om.ExecComp(
+                "reg_objective = -actual_range/1000 + ascent_duration/30.",
+                reg_objective={"val": 0.0, "units": "unitless"},
+                ascent_duration={"units": "s", "shape": 1},
+                actual_range={
+                    "val": self.target_range, "units": "NM"},
+            ),
+            promotes_inputs=[
+                ("actual_range", Mission.Summary.RANGE),
+                ("ascent_duration", Mission.Takeoff.ASCENT_DURATION),
+            ],
+            promotes_outputs=[("reg_objective", Mission.Objectives.RANGE)],
+        )
+
+        self.model.add_subsystem(
+            "range_constraint",
+            om.ExecComp(
+                "range_resid = target_range - actual_range",
+                target_range={"val": self.target_range, "units": "NM"},
+                actual_range={"val": self.target_range - 25, "units": "NM"},
+                range_resid={"val": 30, "units": "NM"},
+            ),
+            promotes_inputs=[
+                ("actual_range", Mission.Summary.RANGE),
+                ("target_range", Mission.Design.RANGE),
+            ],
+            promotes_outputs=[
+                ("range_resid", Mission.Constraints.RANGE_RESIDUAL)],
+        )
+
+    def _add_fuel_reserve_component(self, reserves_name=Mission.Design.RESERVE_FUEL):
+        reserves_val = self.aviary_inputs.get_val(Aircraft.Design.RESERVES)
+        if reserves_val <= 0:
+            reserves_val = -reserves_val
+            self.model.add_subsystem(
+                "reserves_calc",
+                om.ExecComp(
+                    f"reserve_fuel = {reserves_val}*(takeoff_mass - final_mass)",
+                    takeoff_mass={"units": "lbm"},
+                    final_mass={"units": "lbm"},
+                    reserve_fuel={"units": "lbm"}
+                ),
+                promotes_inputs=[
+                    ("takeoff_mass", Mission.Summary.GROSS_MASS),
+                    ("final_mass", Mission.Landing.TOUCHDOWN_MASS),
+                ],
+                promotes_outputs=[("reserve_fuel", reserves_name)],
+            )
+        elif reserves_val > 10:
+            self.model.add_subsystem(
+                "reserves_calc",
+                om.ExecComp(
+                    f"reserve_fuel = {reserves_val}",
+                    reserve_fuel={"val": reserves_val, "units": "lbm"}
+                ),
+                promotes_outputs=[("reserve_fuel", reserves_name)],
+            )
+        else:
+            raise ValueError('"aircraft:design:reserves" is not valid between 0 and 10.')

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/interface/reports.html b/_modules/aviary/interface/reports.html new file mode 100644 index 000000000..5921cc103 --- /dev/null +++ b/_modules/aviary/interface/reports.html @@ -0,0 +1,531 @@ + + + + + + + + + + + aviary.interface.reports + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.interface.reports

+from pathlib import Path
+
+from openmdao.utils.reports_system import register_report
+
+
+
[docs]def register_custom_reports():
+    """
+    Registers Aviary reports with openMDAO, so they are automatically generated and
+    added to the same reports folder as other default reports
+    """
+    # TODO top-level aircraft report?
+    # TODO mission report?
+    # TODO add flag to skip registering reports?
+
+    # register per-subsystem report generation
+    register_report(name='subsystems',
+                    func=subsystem_report,
+                    desc='Generates reports for each subsystem builder in the '
+                         'Aviary Problem',
+                    class_name='Problem',
+                    method='run_model',
+                    pre_or_post='post',
+                    # **kwargs
+                    )

+
+
+
[docs]def subsystem_report(prob, **kwargs):
+    """
+    Loops through all subsystem builders in the AviaryProblem calls their write_report
+    method. All generated report files are placed in the ./reports/subsystem_reports folder
+
+    Parameters
+    ----------
+    prob : AviaryProblem
+        The AviaryProblem that will be used to generate this report
+    """
+    reports_folder = Path(prob.get_reports_dir() / 'subsystems')
+    reports_folder.mkdir(exist_ok=True)
+
+    # TODO external subsystems??
+    core_subsystems = prob.core_subsystems
+
+    for subsystem in core_subsystems.values():
+        subsystem.report(prob, reports_folder, **kwargs)

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/Fortran_to_Aviary.html b/_modules/aviary/utils/Fortran_to_Aviary.html new file mode 100644 index 000000000..b51540214 --- /dev/null +++ b/_modules/aviary/utils/Fortran_to_Aviary.html @@ -0,0 +1,1093 @@ + + + + + + + + + + + aviary.utils.Fortran_to_Aviary + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.Fortran_to_Aviary

+"""
+Fortran_to_Aviary.py is used to read in Fortran based vehicle decks and convert them to Aviary decks.
+
+FLOPS, GASP, or Aviary names can be used for variables (Ex WG or Mission:Design:GROSS_MASS)
+When specifying variables from FORTRAN, they should be in the appropriate NAMELIST.
+Aviary variable names should be specified outside any NAMELISTS.
+Names are not case-sensitive.
+Units can be specified using any of the openMDAO valid units.
+Comments can be added using !
+Lists can be entered by separating values with commas.
+Individual list elements can be specified by adding an index after the variable name.
+(NOTE: 1 indexing is used inside NAMELISTS, while 0 indexing is used outside NAMELISTS)
+
+Example inputs:
+aircraft:fuselage:pressure_differential = .5, atm !DELP in GASP, but using atmospheres instead of psi
+ARNGE(1) = 3600 !target range in nautical miles
+pyc_phases = taxi, groundroll, rotation, landing
+debug_mode = True
+"""
+
+import csv
+import re
+from enum import Enum
+from pathlib import Path
+
+from openmdao.utils.units import valid_units
+
+from aviary.utils.functions import convert_strings_to_data
+from aviary.utils.named_values import NamedValues, get_items
+from aviary.variable_info.variable_meta_data import _MetaData
+from aviary.variable_info.variables import Aircraft, Mission
+from aviary.variable_info.enums import LegacyCode
+from aviary.utils.functions import get_path
+from aviary.utils.legacy_code_data.deprecated_vars import flops_deprecated_vars, gasp_deprecated_vars
+
+
+FLOPS = LegacyCode.FLOPS
+GASP = LegacyCode.GASP
+
+
+
[docs]def create_aviary_deck(fortran_deck: str, legacy_code=None, defaults_deck=None,
+                       out_file=None, force=False):
+    '''
+    Create an Aviary CSV file from a Fortran input deck
+    Required input is the filepath to the input deck and legacy code. Optionally, a
+    deck of default values can be specified, this is useful if an input deck
+    assumes certain values for any unspecified variables
+    If an invalid filepath is given, pre-packaged resources will be checked for
+    input decks with a matching name.
+    '''
+    # TODO generate both an Aviary input file and a phase_info file
+
+    vehicle_data = {'input_values': NamedValues(), 'unused_values': NamedValues(),
+                    'initial_guesses': initial_guesses, 'debug_mode': False}
+
+    fortran_deck: Path = get_path(fortran_deck, verbose=False)
+
+    if not out_file:
+        name = fortran_deck.stem
+        out_file: Path = fortran_deck.parents / name + '_converted.csv'
+
+    if legacy_code is GASP:
+        default_extension = '.dat'
+        deprecated_vars = gasp_deprecated_vars
+    elif legacy_code is FLOPS:
+        default_extension = '.txt'
+        deprecated_vars = flops_deprecated_vars
+
+    if not defaults_deck:
+        defaults_filename = legacy_code.value.lower() + '_default_values' + default_extension
+        defaults_deck = Path(__file__).parent.resolve().joinpath(
+            'legacy_code_data', defaults_filename)
+
+    # create dictionary to convert legacy code variables to Aviary variables
+    aviary_variable_dict = generate_aviary_names([legacy_code.value])
+
+    if defaults_deck:  # If defaults are specified, initialize the vehicle with them
+        vehicle_data = input_parser(defaults_deck, vehicle_data,
+                                    aviary_variable_dict, deprecated_vars, legacy_code)
+
+    vehicle_data = input_parser(fortran_deck, vehicle_data,
+                                aviary_variable_dict, deprecated_vars, legacy_code)
+    if legacy_code is GASP:
+        vehicle_data = update_gasp_options(vehicle_data)
+
+    if not out_file.is_file():  # default outputted file to be in same directory as input
+        out_file = fortran_deck.parent / out_file
+
+    if out_file.is_file():
+        if force:
+            print(f'Overwriting existing file: {out_file.name}')
+        else:
+            raise RuntimeError(f'{out_file} already exists. Choose a new name or enable '
+                               '--force')
+    else:
+        # create any directories defined by the new filename if they don't already exist
+        out_file.parent.mkdir(parents=True, exist_ok=True)
+        print('Writing to:', out_file)
+
+    # open the file in write mode
+    with open(out_file, 'w', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow(['debug_mode', vehicle_data['debug_mode']])
+        writer.writerow([])
+
+        # Values that have been successfully translated to Aviary variables
+        writer.writerow(['# Input Values'])
+        for var, (val, units) in sorted(vehicle_data['input_values']):
+            writer.writerow([var] + val + [units])
+        if legacy_code is FLOPS:
+            EOM = 'height_energy'
+            mass = 'FLOPS'
+        if legacy_code is GASP:
+            EOM = '2DOF'
+            mass = 'GASP'
+        writer.writerow(['settings:equations_of_motion'] + [EOM])
+        writer.writerow(['settings:mass_method'] + [mass])
+
+        if legacy_code is GASP:
+            # Values used in initial guessing of the trajectory
+            writer.writerow([])
+            writer.writerow(['# Initial Guesses'])
+            for var_name in sorted(vehicle_data['initial_guesses']):
+                row = [var_name, vehicle_data['initial_guesses'][var_name]]
+                writer.writerow(row)
+
+        # Values that were not successfully converted
+        writer.writerow([])
+        writer.writerow(['# Unconverted Values'])
+        for var, (val, _) in sorted(vehicle_data['unused_values']):
+            writer.writerow([var] + val)

+
+
+
[docs]def input_parser(fortran_deck, vehicle_data, alternate_names, unused_vars, legacy_code):
+    '''
+    input_parser will modify the values in the vehicle_data dictionary using the data in the
+    fortran_deck.
+    Lines are read one by one, comments are removed, and namelists are tracked.
+    Lines with multiple variable-data pairs are supported, but the last value per variable must
+    be followed by a trailing comma.
+    '''
+    with open(fortran_deck, 'r') as f_in:
+        current_namelist = current_tag = ''
+        for line in f_in:
+            terminate_namelist = False
+
+            tmp = [*line.split('!', 1), '']
+            line, comment = tmp[0], tmp[1]  # anything after the first ! is a comment
+
+            # remove all white space and trailing commas
+            line = ''.join(line.split()).rstrip(',')
+            if len(line.split()) == 0:
+                continue  # skip line if it contains only white space
+
+            # Track when namelists are opened and closed
+            if (line.lstrip()[0] in ['$', '&']) and current_tag == '':
+                current_tag = line.lstrip()[0]
+                current_namelist = line.split(current_tag)[1].split()[0] + '.'
+            elif (line.lstrip()[0] == current_tag) or (line.rstrip()[-1] == '/'):
+                line = line.replace('/', '')
+                terminate_namelist = True
+
+            number_of_variables = line.count('=')
+            if number_of_variables == 1:
+                # get the first element and remove white space
+                var_name = ''.join(line.split('=')[0].split())
+                # everything after the = is the data
+                data = line.split('=')[1]
+                try:
+                    vehicle_data = process_and_store_data(
+                        data, var_name, legacy_code, current_namelist, alternate_names, vehicle_data, unused_vars, comment)
+                except Exception as err:
+                    if current_namelist == '':
+                        raise RuntimeError(line + ' could not be parsed successfully.'
+                                           '\nIf this was intended as a comment, '
+                                           'add an "!" at the beginning of the line.') from err
+                    else:
+                        raise err
+            elif number_of_variables > 1:
+                sub_line = line.split('=')  # split the line at each =
+                var_name = sub_line[0]  # the first element is the first name
+                for ii in range(number_of_variables):
+                    # Each of the following elements contains all of the data for the current variable
+                    # and the last element is the name of the next variable
+                    sub_list = sub_line[ii+1].split(',')
+                    if ii+1 < number_of_variables:
+                        next_var_name = sub_list.pop()
+                        if not next_var_name[0].isalpha():
+                            index = next((i for i, c in enumerate(
+                                next_var_name) if c.isalpha()), len(next_var_name))
+                            sub_list.append(next_var_name[:index])
+                            next_var_name = next_var_name[index:]
+
+                    data = ','.join(sub_list)
+                    try:
+                        vehicle_data = process_and_store_data(
+                            data, var_name, legacy_code, current_namelist, alternate_names, vehicle_data, unused_vars, comment)
+                    except Exception as err:
+                        if current_namelist == '':
+                            raise RuntimeError(line + ' could not be parsed successfully.'
+                                               '\nIf this was intended as a comment, '
+                                               'add an "!" at the beginning of the line.') from err
+                        else:
+                            raise err
+                    var_name = next_var_name
+
+            if terminate_namelist:
+                current_namelist = current_tag = ''
+
+    return vehicle_data

+
+
+
[docs]def process_and_store_data(data, var_name, legacy_code, current_namelist, alternate_names, vehicle_data, unused_vars, comment=''):
+    '''
+    process_and_store_data takes in a string that contains the data, the current variable's name and
+    namelist, the dictionary of alternate names, and the current vehicle data.
+    It will convert the string of data into a list, get units, check whether the data specified is
+    part of a list or a single element, and update the current name to it's equivalent Aviary name.
+    The variables are also sorted based on whether they will set an Aviary variable or they are for initial guessing
+    '''
+
+    guess_names = list(initial_guesses.keys())
+    var_ind = data_units = None
+    skip_variable = False
+    # skip any variables that shouldn't get converted
+    if re.search(current_namelist+var_name+'\Z', str(unused_vars), re.IGNORECASE):
+        return vehicle_data
+    # remove any elements that are empty (caused by trailing commas or extra commas)
+    data_list = [dat for dat in data.split(',') if dat != '']
+    if len(data_list) > 0:
+        if valid_units(data_list[-1]):
+            # if the last element is a unit, remove it from the list and update the variable's units
+            data_units = data_list.pop()
+        var_values = convert_strings_to_data(data_list)
+    else:
+        skip_variable = True
+        var_values = []
+
+    if '(' in var_name:  # some GASP lists are given as individual elements
+        # get the target index (Fortran uses 1 indexing, Python uses 0 indexing)
+        fortran_offset = 1 if current_namelist else 0
+        var_ind = int(var_name.split('(')[1].split(')')[0])-fortran_offset
+        var_name = var_name.split('(')[0]  # remove the index formatting
+
+    list_of_equivalent_aviary_names = update_name(
+        alternate_names, current_namelist+var_name, vehicle_data['debug_mode'])
+    for name in list_of_equivalent_aviary_names:
+        if not skip_variable:
+            if name == 'debug_mode':
+                vehicle_data['debug_mode'] = var_values[0]
+                continue
+
+            elif name in guess_names and legacy_code is GASP:
+                # all initial guesses take only a single value
+                vehicle_data['initial_guesses'][name] = float(var_values[0])
+                continue
+
+            elif name in _MetaData:
+                vehicle_data['input_values'] = set_value(name, var_values, vehicle_data['input_values'],
+                                                         var_ind=var_ind, units=data_units)
+                continue
+
+        vehicle_data['unused_values'] = set_value(name, var_values, vehicle_data['unused_values'],
+                                                  var_ind=var_ind, units=data_units)
+        if vehicle_data['debug_mode']:
+            print('Unused:', name, var_values, comment)
+
+    return vehicle_data

+
+
+
[docs]def set_value(var_name, var_value, value_dict: NamedValues, var_ind=None, units=None):
+    ''' 
+    set_value will update the current value of a variable in a value dictionary that contains a value
+    and it's associated units.
+    If units are specified for the new value, they will be used, otherwise the current units in the
+    value dictionary or the default units from _MetaData are used.
+    If the new variable is part of a list, the current list will be extended if needed.
+    '''
+
+    if var_name in value_dict:
+        current_value, units = value_dict.get_item(var_name)
+    else:
+        current_value = None
+        if var_name in _MetaData:
+            units = _MetaData[var_name]['units']
+        else:
+            units = 'unitless'
+    if not units:
+        units = 'unitless'
+
+    if var_ind != None:
+        # if an index is specified, use it, otherwise store the input as the whole value
+        if isinstance(current_value, list):
+            max_ind = len(current_value) - 1
+            if var_ind > max_ind:
+                current_value.extend((var_ind-max_ind)*[0])
+        else:
+            current_value = [current_value]+[0]*var_ind
+        current_value[var_ind] = var_value[0]
+        value_dict.set_val(var_name, current_value, units)
+    else:
+        value_dict.set_val(var_name, var_value, units)
+    return value_dict

+
+
+
[docs]def generate_aviary_names(code_bases):
+    '''
+    Create a dictionary for each of the specified Fortran code bases to map to the Aviary
+    variable names. Each dictionary of Aviary names will have a list of Fortran names for
+    each variable
+    '''
+
+    alternate_names = {}
+    for code_base in code_bases:
+        alternate_names[code_base] = {}
+        for key in _MetaData.keys():
+            historical_dict = _MetaData[key]['historical_name']
+            if historical_dict and code_base in historical_dict:
+                alt_name = _MetaData[key]['historical_name'][code_base]
+                if isinstance(alt_name, str):
+                    alt_name = [alt_name]
+                alternate_names[code_base][key] = alt_name
+    return alternate_names

+
+
+
[docs]def update_name(alternate_names, var_name, debug_mode=False):
+    '''update_name will convert a Fortran name to a list of equivalent Aviary names.'''
+
+    all_equivalent_names = []
+    for code_base in alternate_names.keys():
+        for key, list_of_names in alternate_names[code_base].items():
+            if list_of_names is not None:
+                if any([re.search(var_name+r'\Z', altname, re.IGNORECASE) for altname in list_of_names]):
+                    all_equivalent_names.append(key)
+
+    # if there are no equivalent variable names, return the original name
+    if len(all_equivalent_names) == 0:
+        if debug_mode:
+            print('passing: ', var_name)
+        all_equivalent_names = [var_name]
+    return all_equivalent_names

+
+
+
[docs]def update_gasp_options(vehicle_data):
+    """
+    Handles variables that are affected by the values of others
+    """
+    input_values: NamedValues = vehicle_data['input_values']
+
+    flap_types = ["plain", "split", "single_slotted", "double_slotted",
+                  "triple_slotted", "fowler", "double_slotted_fowler"]
+
+    ## PROBLEM TYPE ##
+    # if multiple values of target_range are specified, use the one that corresponds to the problem_type
+    design_range, range_units = input_values.get_item(Mission.Design.RANGE)
+    try:
+        problem_type = input_values.get_val('problem_type')[0]
+    except KeyError:
+        problem_type = 'sizing'
+
+    if isinstance(design_range, list):
+        # if the design range target_range value is 0, set the problem_type to fallout
+        if design_range[0] == 0:
+            input_values.set_val('problem_type', ['fallout'])
+            design_range = 0
+        if problem_type == 'sizing':
+            design_range = design_range[0]
+        elif problem_type == 'alternate':
+            design_range = design_range[2]
+        elif problem_type == 'fallout':
+            design_range = 0
+    else:
+        if design_range == 0:
+            input_values.set_val('problem_type', ['fallout'])
+    input_values.set_val(Mission.Design.RANGE, [design_range], range_units)
+
+    ## STRUT AND FOLD ##
+    strut_loc = input_values.get_val(Aircraft.Strut.ATTACHMENT_LOCATION, 'ft')[0]
+    folded_span = input_values.get_val(Aircraft.Wing.FOLDED_SPAN, 'ft')[0]
+
+    if strut_loc == 0:
+        input_values.set_val(Aircraft.Wing.HAS_STRUT, [False], 'unitless')
+    else:
+        input_values.set_val(Aircraft.Wing.HAS_STRUT, [True], 'unitless')
+    if folded_span == 0:
+        input_values.set_val(Aircraft.Wing.HAS_FOLD, [False], 'unitless')
+    else:
+        input_values.set_val(Aircraft.Wing.HAS_FOLD, [True], 'unitless')
+
+    if strut_loc < 0:
+        input_values.set_val(Aircraft.Wing.HAS_FOLD, [True], 'unitless')
+        input_values.set_val(Aircraft.Wing.CHOOSE_FOLD_LOCATION, [False], 'unitless')
+        strut_loc = abs(strut_loc)
+
+    if strut_loc < 1:
+        input_values.set_val(Aircraft.Strut.ATTACHMENT_LOCATION_DIMENSIONLESS,
+                             [strut_loc], 'unitless')
+        input_values.set_val(Aircraft.Strut.DIMENSIONAL_LOCATION_SPECIFIED, [
+                             False], 'unitless')
+    else:
+        input_values.set_val(Aircraft.Strut.ATTACHMENT_LOCATION, [strut_loc], 'ft')
+        input_values.set_val(
+            Aircraft.Strut.DIMENSIONAL_LOCATION_SPECIFIED, [True], 'unitless')
+
+    if input_values.get_val(Aircraft.Wing.HAS_FOLD)[0]:
+        if not input_values.get_val(Aircraft.Wing.CHOOSE_FOLD_LOCATION)[0]:
+            input_values.set_val(Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED,
+                                 [True], 'unitless')
+        else:
+            if input_values.get_val(Aircraft.Wing.FOLDED_SPAN, 'ft')[0] > 1:
+                input_values.set_val(Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED,
+                                     [True], 'unitless')
+            else:
+                input_values.set_val(Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED,
+                                     [False], 'unitless')
+    else:
+        input_values.set_val(Aircraft.Wing.CHOOSE_FOLD_LOCATION, [True], 'unitless')
+        input_values.set_val(Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED, [
+                             False], 'unitless')
+
+    ## FLAPS ##
+    flap_type = input_values.get_val(Aircraft.Wing.FLAP_TYPE)[0]
+    if not isinstance(flap_type, str):
+        flap_type = flap_types[flap_type-1]
+        input_values.set_val(Aircraft.Wing.FLAP_TYPE, [flap_type])
+    flap_ind = flap_types.index(flap_type)
+    if input_values.get_val(Aircraft.Wing.HIGH_LIFT_MASS_COEFFICIENT)[0] <= 0:
+        input_values.set_val(Aircraft.Wing.HIGH_LIFT_MASS_COEFFICIENT,
+                             [[0.62, 1.0, 0.733, 1.2, 1.32, 0.633, 0.678][flap_ind]])
+    if input_values.get_val(Aircraft.Wing.OPTIMUM_FLAP_DEFLECTION, 'deg')[0] == 0:
+        input_values.set_val(Aircraft.Wing.OPTIMUM_FLAP_DEFLECTION,
+                             [[60, 60, 40, 55, 55, 30, 30][flap_ind]], 'deg')
+    if input_values.get_val(Aircraft.Wing.FLAP_LIFT_INCREMENT_OPTIMUM)[0] == 0:
+        input_values.set_val(Aircraft.Wing.FLAP_LIFT_INCREMENT_OPTIMUM,
+                             [[.9, .8, 1.18, 1.4, 1.6, 1.67, 2.25][flap_ind]])
+    if input_values.get_val(Aircraft.Wing.FLAP_DRAG_INCREMENT_OPTIMUM)[0] == 0:
+        input_values.set_val(Aircraft.Wing.FLAP_DRAG_INCREMENT_OPTIMUM,
+                             [[.12, .23, .13, .23, .23, .1, .15][flap_ind]])
+
+    vehicle_data['input_values'] = input_values
+    return vehicle_data

+
+
+
[docs]def update_flops_options(vehicle_data):
+    """
+    Handles variables that are affected by the values of others
+    """
+    input_values: NamedValues = vehicle_data['input_values']
+
+    for var_name in flops_scalar_variables.items():
+        update_flops_scalar_variables(var_name, input_values)
+
+    # TWR <= 0 is not valid in Aviary (parametric variation)
+    if Aircraft.Design.THRUST_TO_WEIGHT_RATIO in input_values:
+        if input_values.get_val(Aircraft.Design.THRUST_TO_WEIGHT_RATIO) <= 0:
+            input_values.delete(Aircraft.Design.THRUST_TO_WEIGHT_RATIO)
+
+    # WSR
+
+    # Additional mass fraction scalar set to zero to not add mass twice
+    if Aircraft.Engine.ADDITIONAL_MASS_FRACTION in input_values:
+        if input_values.get_val(Aircraft.Engine.ADDITIONAL_MASS_FRACTION) >= 1:
+            input_values.set_val(Aircraft.Engine.ADDITIONAL_MASS,
+                                 input_values.get_val(
+                                     Aircraft.Engine.ADDITIONAL_MASS_FRACTION),
+                                 'lbm')
+            input_values.set_val(Aircraft.Engine.ADDITIONAL_MASS_FRACTION, 0.0)
+
+    # Miscellaneous propulsion mass trigger point 1 instead of 5
+    if Aircraft.Propulsion.MISC_MASS_SCALER in input_values:
+        if input_values.get_val(Aircraft.Propulsion.MISC_MASS_SCALER) >= 1:
+            input_values.set_val(Aircraft.Propulsion.TOTAL_MISC_MASS,
+                                 input_values.get_val(
+                                     Aircraft.Propulsion.MISC_MASS_SCALER),
+                                 'lbm')
+            input_values.set_val(Aircraft.Propulsion.MISC_MASS_SCALER, 0.0)
+
+    vehicle_data['input_values'] = input_values
+    return vehicle_data

+
+
+
[docs]def update_flops_scalar_variables(var_name, input_values: NamedValues):
+    # The following parameters are used to modify or override
+    # internally computed weights for various components as follows:
+    # < 0., negative of starting weight which will be modified
+    #   as appropriate during optimization or parametric
+    #   variation, lb
+    # = 0., no weight for that component
+    # > 0. but < 5., scale factor applied to internally
+    #   computed weight
+    # > 5., actual fixed weight for component, lb
+    # Same rules also applied to various other FLOPS scalar parameters
+    scalar_name = var_name + '_scaler'
+    if scalar_name not in input_values:
+        return
+    scalar_value = input_values[scalar_name]
+    if scalar_value <= 0:
+        input_values.delete(scalar_name)
+    elif scalar_value < 5:
+        return
+    elif scalar_value > 5:
+        input_values.set_val(var_name, scalar_value, 'lbm')
+        input_values.set_val(scalar_name, 1.0)

+
+
+# list storing information on Aviary variables that are split from single
+# FLOPS variables that use the same value-based branching behavior
+flops_scalar_variables = [
+    Aircraft.AirConditioning.MASS,
+    Aircraft.AntiIcing.MASS,
+    Aircraft.APU.MASS,
+    Aircraft.Avionics.MASS,
+    Aircraft.Canard.MASS,
+    Aircraft.Canard.WETTED_AREA,
+    Aircraft.CrewPayload.CARGO_CONTAINER_MASS,
+    Aircraft.CrewPayload.FLIGHT_CREW_MASS,
+    Aircraft.CrewPayload.NON_FLIGHT_CREW_MASS,
+    Aircraft.CrewPayload.PASSENGER_SERVICE_MASS,
+    Aircraft.Design.EMPTY_MASS_MARGIN,
+    Aircraft.Electrical.MASS,
+    Aircraft.Engine.THRUST_REVERSERS_MASS,
+    Aircraft.Fins.MASS,
+    Aircraft.Fuel.FUEL_SYSTEM_MASS,
+    Aircraft.Fuel.UNUSABLE_FUEL_MASS,
+    Aircraft.Furnishings.MASS,
+    Aircraft.Fuselage.MASS,
+    Aircraft.Fuselage.WETTED_AREA,
+    Aircraft.HorizontalTail.MASS,
+    Aircraft.HorizontalTail.WETTED_AREA,
+    Aircraft.Hydraulics.MASS,
+    Aircraft.Instruments.MASS,
+    Aircraft.LandingGear.MAIN_GEAR_MASS,
+    Aircraft.LandingGear.NOSE_GEAR_MASS,
+    Aircraft.Nacelle.MASS,
+    Aircraft.Propulsion.TOTAL_ENGINE_OIL_MASS,
+    Aircraft.VerticalTail.MASS_SCALER,
+    Aircraft.VerticalTail.WETTED_AREA_SCALER,
+    Aircraft.Wing.MASS,
+    Aircraft.Wing.SHEAR_CONTROL_MASS,
+    Aircraft.Wing.SURFACE_CONTROL_MASS,
+    Aircraft.Wing.WETTED_AREA,
+]
+
+initial_guesses = {
+    # initial_guesses is a dictionary that contains values used to initialize the trajectory
+    'actual_takeoff_mass': 0,
+    'rotation_mass': .99,
+    'fuel_burn_per_passenger_mile': 0.1,
+    'cruise_mass_final': 0,
+    'flight_duration': 0,
+    'time_to_climb': 0,
+    'climb_range': 0,
+    'reserves': 0
+}
+
+
+def _setup_F2A_parser(parser):
+    '''
+    Set up the subparser for the Fortran_to_aviary tool.
+
+    Parameters
+    ----------
+    parser : argparse subparser
+        The parser we're adding options to.
+    '''
+    parser.add_argument(
+        "input_deck",
+        type=str,
+        nargs=1,
+        help="Filename of vehicle input deck, including partial or complete path.",
+    )
+    parser.add_argument(
+        "-o",
+        "--out_file",
+        default=None,
+        help="Filename for converted input deck, including partial or complete path."
+    )
+    parser.add_argument(
+        "-l",
+        "--legacy_code",
+        type=LegacyCode,
+        help="Name of the legacy code the deck originated from",
+        choices=list(LegacyCode),
+        required=True
+    )
+    parser.add_argument(
+        "-d",
+        "--defaults_deck",
+        default=None,
+        help="Deck of default values for unspecified variables"
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Allow overwriting existing output files",
+    )
+
+
+def _exec_F2A(args, user_args):
+    # check if args.input_deck is a list, if so, use the first element
+    if isinstance(args.input_deck, list):
+        args.input_deck = args.input_deck[0]
+    filepath = args.input_deck
+
+    create_aviary_deck(filepath, args.legacy_code, args.defaults_deck,
+                       Path(args.out_file), args.force)
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/aero_table_conversion.html b/_modules/aviary/utils/aero_table_conversion.html new file mode 100644 index 000000000..04e92129e --- /dev/null +++ b/_modules/aviary/utils/aero_table_conversion.html @@ -0,0 +1,738 @@ + + + + + + + + + + + aviary.utils.aero_table_conversion + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.aero_table_conversion

+#!/usr/bin/python
+
+import argparse
+import re
+
+import numpy as np
+
+from enum import Enum
+from pathlib import Path
+
+from aviary.api import NamedValues
+from aviary.utils.csv_data_file import write_data_file
+from aviary.utils.functions import get_path
+
+
+
[docs]class CodeOrigin(Enum):
+    FLOPS = 'FLOPS'
+    GASP = 'GASP'

+
+
+allowed_headers = {
+    'altitude': 'Altitude',
+    'alt': 'Altitude',
+    'alpha': 'Angle of Attack',
+    'mach': 'Mach',
+    'delflp': 'Flap Deflection',
+    'cltot': 'CL',
+    'cl': 'CL',
+    'cd': 'CD',
+    'hob': 'Hob',
+    'del_cl': 'Delta CL',
+    'del_cd': 'Delta CD'
+}
+
+
+
[docs]def AeroDataConverter(input_file=None, output_file=None, data_format=None):
+    data_format = CodeOrigin(data_format)
+    data_file = get_path(input_file)
+    if not output_file:
+        if data_format is CodeOrigin.GASP:
+            # Default output file name is same location and name as input file, with
+            # '_aviary' appended to filename
+            path = input_file.parents[0]
+            name = input_file.name
+            suffix = input_file.suffix
+            output_file = path / (name + '_aviary' + suffix)
+        elif data_format is CodeOrigin.FLOPS:
+            # Default output file name is same location and name as input file, with
+            # '_aviary' appended to filename
+            path = input_file.parents[0]
+            name = input_file.stem
+            suffix = input_file.suffix
+            file1 = path / name + '_aviary_CDI' + suffix
+            file2 = path / name + '_aviary_CD0' + suffix
+            output_file = [file1, file2]
+
+    stamp = f'# {data_format.value}-derived aerodynamics data converted from {data_file.name}'
+
+    if data_format is CodeOrigin.GASP:
+        data, comments = _load_gasp_aero_table(data_file)
+        comments = [stamp] + comments
+
+        write_data_file(output_file, data, comments, include_timestamp=True)
+    elif data_format is CodeOrigin.FLOPS:
+        if type(output_file) is not list:
+            # if only one filename is given, split into two
+            path = output_file.parents[0]
+            name = output_file.stem
+            suffix = output_file.suffix
+            file1 = path / (name + '_CDi' + suffix)
+            file2 = path / (name + '_CD0' + suffix)
+            output_file = [file1, file2]
+
+        lift_drag_data, lift_drag_comments, \
+            zero_lift_drag_data, zero_lift_drag_comments = _load_flops_aero_table(
+                data_file)
+
+        # write lift-dependent drag file
+        lift_drag_comments = [stamp] + lift_drag_comments
+        write_data_file(output_file[0], lift_drag_data,
+                        lift_drag_comments, include_timestamp=True)
+
+        # write zero-lift drag file
+        zero_lift_drag_comments = [stamp] + zero_lift_drag_comments
+        write_data_file(output_file[1], zero_lift_drag_data,
+                        zero_lift_drag_comments, include_timestamp=True)

+
+
+def _load_flops_aero_table(filepath: Path):
+    """Load an aero table in FLOPS format"""
+
+    def _read_line(line_count, comments):
+        line = file_contents[line_count].strip()
+        items = re.split(r'[\s]*\s', line)
+        if items[0] == '#':
+            comments.append(line)
+            nonlocal offset
+            offset += 1
+            try:
+                items = _read_line(line_count+1, comments)
+            except IndexError:
+                return
+        else:
+            # try to convert line to float
+            try:
+                items = [float(var) for var in items]
+            # data contains things other than floats
+            except (ValueError):
+                raise ValueError(
+                    f'Non-numerical value found in data file <{filepath.name}> on '
+                    f'line {str(line_count)}')
+
+        return items
+
+    lift_drag = []
+    lift_drag_data = NamedValues()
+    lift_drag_comments = []
+    zero_lift_drag = []
+    zero_lift_drag_data = NamedValues()
+    zero_lift_drag_comments = []
+
+    file_contents = []
+    with open(filepath, 'r') as reader:
+        for line in reader:
+            file_contents.append(line)
+
+    offset = 0
+    # these are not needed, we can determine the length of data vectors directly
+    lift_drag_mach_count, cl_count = _read_line(0 + offset, lift_drag_comments)
+    lift_drag_machs = _read_line(1 + offset, lift_drag_comments)
+    cls = _read_line(2 + offset, lift_drag_comments)
+    lift_drag = []
+    for i in range(len(lift_drag_machs)):
+        drag = _read_line(3 + i + offset, lift_drag_comments)
+        if len(drag) == len(cls):
+            lift_drag.append(drag)
+        else:
+            raise ValueError('Number of data points provided for '
+                             f'lift-dependent drag at Mach {lift_drag_machs[i]} '
+                             'does not match number of CLs provided '
+                             f'(FLOPS aero data file {filepath.name})')
+    if len(lift_drag) != len(lift_drag_machs):
+        raise ValueError('Number of data rows provided for lift-dependent drag does '
+                         'not match number of Mach numbers provided (FLOPS aero data '
+                         f'file {filepath.name})')
+    offset = offset + i
+    # these are not needed, we can determine the length of data vectors directly
+    altitude_count, zero_lift_mach_count = _read_line(
+        4 + offset, zero_lift_drag_comments)
+    altitudes = _read_line(5 + offset, zero_lift_drag_comments)
+    zero_lift_machs = _read_line(6 + offset, zero_lift_drag_comments)
+    for i in range(len(altitudes)):
+        drag = _read_line(7 + i + offset, zero_lift_drag_comments)
+        if len(drag) == len(zero_lift_machs):
+            zero_lift_drag.append(drag)
+        else:
+            raise ValueError('Number of data points provided for '
+                             f'zero-lift drag at altitude {altitudes[i]} '
+                             'does not match number of Machs provided '
+                             f'(FLOPS aero data file {filepath.name})')
+    if len(zero_lift_drag) != len(altitudes):
+        raise ValueError('Number of data rows provided for zero-lift drag does '
+                         'not match number of altitudes provided (FLOPS aero data '
+                         f'file {filepath.name})')
+
+    cl, mach = np.meshgrid(cls, lift_drag_machs)
+    lift_drag_data.set_val('Mach', mach.flatten(), 'unitless')
+    lift_drag_data.set_val('Lift Coefficient', cl.flatten(), 'unitless')
+    lift_drag_data.set_val('Lift-Dependent Drag Coefficient',
+                           np.array(lift_drag).flatten(), 'unitless')
+
+    mach, altitude = np.meshgrid(zero_lift_machs, altitudes)
+    zero_lift_drag_data.set_val('Altitude', altitude.flatten(), 'ft')
+    zero_lift_drag_data.set_val('Mach', mach.flatten(), 'unitless')
+    zero_lift_drag_data.set_val('Zero-Lift Drag Coefficient',
+                                np.array(zero_lift_drag).flatten(), 'unitless')
+
+    return lift_drag_data, lift_drag_comments, zero_lift_drag_data, zero_lift_drag_comments
+
+
+def _load_gasp_aero_table(filepath: Path):
+    """Load an aero table in GASP format"""
+    data = NamedValues()
+    raw_data = []
+    comments = []
+    variables = []
+    units = []
+    read_header = True
+    read_units = False
+    with open(filepath, 'r') as reader:
+        for line_count, line in enumerate(reader):
+            # ignore empty lines
+            if not line or line.strip() == ['']:
+                continue
+            if line[0] == '#':
+                line = line.strip('# ').strip()
+                if read_header:
+                    items = re.split(r'[\s]*\s', line)
+                    if all(name.lower() in allowed_headers for name in items):
+                        variables = [name for name in items]
+                        read_header = False
+                        read_units = True
+                    else:
+                        if line:
+                            comments.append(line)
+                else:
+                    if read_units:
+                        items = re.split(r'[\s]*\s', line)
+                        for item in items:
+                            item = item.strip('()')
+                            if item == '-':
+                                item = 'unitless'
+                            units.append(item)
+                continue
+            else:
+                # this is data
+                items = re.split(r'[\s]*\s', line.strip())
+                # try to convert line to float
+                try:
+                    line_data = [float(var) for var in items]
+                # data contains things other than floats
+                except (ValueError):
+                    raise ValueError(
+                        f'Non-numerical value found in data file <{filepath.name}> on '
+                        f'line {str(line_count)}')
+                else:
+                    raw_data.append(line_data)
+
+    raw_data = np.array(raw_data)
+
+    # translate raw data into NamedValues object
+    for idx, var in enumerate(variables):
+        if var.lower() in allowed_headers:
+            data.set_val(allowed_headers[var.lower()], raw_data[:, idx], units[idx])
+
+    return data, comments
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Converts FLOPS- or GASP-formatted '
+                                     'aero data files into Aviary csv format.\n')
+    parser.add_argument('input_file', type=str,
+                        help='path to engine deck file to be converted')
+    parser.add_argument('output_file', type=str,
+                        help='path to file where new converted data will be written')
+    parser.add_argument('data_format', type=str, choices=[origin.value for origin in CodeOrigin],
+                        help='data format used by input_file')
+
+    args = parser.parse_args()
+
+    AeroDataConverter(**vars(args))
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/aviary_values.html b/_modules/aviary/utils/aviary_values.html new file mode 100644 index 000000000..fa10392ea --- /dev/null +++ b/_modules/aviary/utils/aviary_values.html @@ -0,0 +1,620 @@ + + + + + + + + + + + aviary.utils.aviary_values + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.aviary_values

+'''
+Define utilities for using aviary values with associated units and testing
+for compatibility with aviary metadata dictionary.
+
+Utilities
+---------
+Units : type alias
+    define a type hint for associated units
+
+ValueAndUnits : type alias
+    define a type hint for a single value paired with its associated units
+
+OptionalValueAndUnits : type alias
+    define a type hint for an optional single value paired with its associated units
+
+class AviaryValues
+    define a collection of named values with associated units
+'''
+from enum import EnumMeta
+
+import numpy as np
+from openmdao.utils.units import convert_units as _convert_units
+
+from aviary.utils.named_values import (NamedValues, get_items, get_keys,
+                                       get_values)
+from aviary.variable_info.variable_meta_data import _MetaData
+
+
+
[docs]class AviaryValues(NamedValues):
+    '''
+    Define a collection of aviary values with associated units and aviary tests.
+    '''
+
+
[docs]    def set_val(self, key, val, units='unitless', meta_data=_MetaData):
+        '''
+        Update the named value and its associated units.
+
+        Note, specifying units of `None` or units of any type other than `str` will raise
+        `Typerror`.
+
+        Parameters
+        ----------
+        key : str
+            the name of the item
+
+        val : Any
+            the new value of the item
+
+        units : str ('unitless')
+            the units associated with the new value, if any
+
+        Raises
+        ------
+        TypeError
+            if units of `None` were specified or units of any type other than `str`
+        '''
+
+        # Special handling to access an Enum member from either the member name or its value.
+        my_val = val
+        if key in _MetaData.keys():
+            expected_types = _MetaData[key]['types']
+            if type(expected_types) is EnumMeta:
+                if self._is_iterable(val):
+                    my_val = [self._convert_to_enum(
+                        item, expected_types) for item in val]
+                else:
+                    my_val = self._convert_to_enum(val, expected_types)
+
+        self._check_type(key, my_val, meta_data=meta_data)
+        self._check_units_compatability(key, my_val, units, meta_data=meta_data)
+
+        super().set_val(key=key, val=my_val, units=units)

+
+    def _check_type(self, key, val, meta_data=_MetaData):
+        if key in meta_data.keys():
+            expected_types = meta_data[key]['types']
+            if expected_types is not None:
+                if isinstance(expected_types, list):
+                    expected_types = tuple(expected_types)
+                # if val is not iterable, add it to a list (length 1)
+                if not self._is_iterable(val):
+                    val = [val]
+                # numpy arrays have special typings. Extract item of equivalent built-in python type
+                # numpy arrays do not allow mixed types, only have to check first entry
+                # empty arrays do not need this check
+                if isinstance(val, np.ndarray) and len(val) > 0:
+                    # NoneType numpy arrays do not need to be "converted" to built-in python types
+                    if val.dtype == type(None):
+                        val = [val[0]]
+                    else:
+                        val = [val[0].item()]
+                for item in val:
+                    has_bool = False  # needs some fancy shenanigans because bools will register as ints
+                    if (isinstance(expected_types, type)):
+                        if expected_types is bool:
+                            has_bool = True
+                    elif bool in expected_types:
+                        has_bool = True
+                    if (not isinstance(item, expected_types)) or (
+                            (has_bool == False) and (isinstance(item, bool))):
+                        raise TypeError(
+                            f'{key} is of type(s) {meta_data[key]["types"]} but you have provided a value of type {type(item)}.')
+
+    def _check_units_compatability(self, key, val, units, meta_data=_MetaData):
+        if key in meta_data.keys():
+            expected_units = meta_data[key]['units']
+
+            try:
+                # NOTE the value here is unimportant, we only care if OpenMDAO will
+                # convert the units
+                _convert_units(10, expected_units, units)
+            except ValueError:
+                raise ValueError(
+                    f'The units {units} which you have provided for {key} are invalid.')
+            except TypeError:
+                raise TypeError(
+                    f'The base units of {key} are {expected_units}, and you have tried to set {key} with units of {units}, which are not compatible.')
+            except BaseException:
+                raise KeyError('There is an unknown error with your units.')
+
+    def _is_iterable(self, val):
+        return isinstance(val, list) or isinstance(val, np.ndarray) or isinstance(val, tuple)
+
+    def _convert_to_enum(self, val, enum_type):
+        if isinstance(val, str):
+            try:
+                # see if str maps to ENUM value
+                return enum_type(val)
+            except ValueError:
+                # str instead maps to ENUM name
+                return enum_type[val.upper()]
+        else:
+            return enum_type(val)

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/compare_hierarchies.html b/_modules/aviary/utils/compare_hierarchies.html new file mode 100644 index 000000000..2c66d2bbe --- /dev/null +++ b/_modules/aviary/utils/compare_hierarchies.html @@ -0,0 +1,659 @@ + + + + + + + + + + + aviary.utils.compare_hierarchies + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.compare_hierarchies

+from aviary.variable_info.variables import Aircraft as _Aircraft
+from aviary.variable_info.variables import Mission as _Mission
+
+
+
[docs]def compare_inner_classes(class1, class2, show_all=False):
+    """
+    Compare two nested class hierarchies and return a set of shared inner-classes.
+
+    Summary:
+    This function takes in two classes that both are part of variable hierarchies and may contain
+    inner-classes or variables with string-named values. This function compares those two classes 
+    and returns a set of inner classes that have the same name in both inputted classes. It will throw 
+    an error if the two classes have the same variable with a different string-named value.
+
+    Parameters
+    ----------
+    class1 : class
+        A class that is all or part of a variable hierarchy. This can be the top-level 
+        class in the hierarchy, or any inner class nested at any depth within that top-level class.
+    class2 : class
+        A class that is all or part of a variable hierarchy. This can be the top-level
+        class in the hierarchy, or any inner class nested at any depth within that top-level class.
+    show_all : bool, optional
+        Flag to tell the function to return the sets of variables and inner classes for
+        each provided class.
+
+    Returns
+    -------
+    overlapping_inner_classes : set of strings
+        A set of string names of all the inner classes which are common between the two
+        input classes.
+    class1_vars_set : set of strings, optional
+        Set of string names of the variables belonging to class1, optional return based 
+        on show_all flag.
+    class2_vars_set : set of strings, optional
+        Set of string names of the variables belonging to class2, optional return based
+        on show_all flag.
+    class1_inner_classes_set : set of strings, optional
+        Set of the string names of inner classes belonging to class1, optional return based
+        on show_all flag.
+    class2_inner_classes_set : set of strings, optional
+        Set of the string names of inner classes belonging to class2, optional return based
+        on show_all flag.
+
+    Raises
+    ------
+    ValueError
+        If the two input classes both have a variable with the same variable name but 
+        different string-named value.
+    """
+    class1_vars_inner_classes = vars(class1)
+    class2_vars_inner_classes = vars(class2)
+
+    class1_vars = []
+    class1_inner_classes = []
+    class2_vars = []
+    class2_inner_classes = []
+
+    # separate out a list of string names of the variables belonging to class1, and the inner classes belonging to class1
+    for key in class1_vars_inner_classes.keys():
+        # just checks if it is a class
+        if type(class1_vars_inner_classes[key]) == type(class1):
+            class1_inner_classes.append(key)
+        elif (type(class1_vars_inner_classes[key]) == str) and not (key == '__module__') and not (key == '__doc__'):
+            class1_vars.append(key)
+
+    # separate out a list of string names of the variables belonging to class2, and the inner classes belonging to class2
+    for key in class2_vars_inner_classes.keys():
+        if type(class2_vars_inner_classes[key]) == type(class2):
+            class2_inner_classes.append(key)
+        elif (type(class2_vars_inner_classes[key]) == str) and not (key == '__module__') and not (key == '__doc__'):
+            class2_vars.append(key)
+
+    class1_vars_set = set(class1_vars)
+    class2_vars_set = set(class2_vars)
+    # get set of the variables in the provided classes that have the same name
+    overlapping_vars = class1_vars_set & class2_vars_set
+    for var in overlapping_vars:  # go through overlapping variables and check that they have the same value associated with them
+        value1 = getattr(class1, var)  # value of the variable in the first class
+        value2 = getattr(class2, var)  # value of the variable in the second class
+
+        if value1 != value2:
+            raise ValueError(
+                f"You have attempted to merge two variable hierarchies together that have the same variable with a different string name associated to it. The offending variable is '{var}'. In '{class1.__qualname__}' it has a value of '{value1}' and in '{class2.__qualname__}' it has a value of '{value2}'.")
+
+    class1_inner_classes_set = set(class1_inner_classes)
+    class2_inner_classes_set = set(class2_inner_classes)
+    overlapping_inner_classes = class1_inner_classes_set & class2_inner_classes_set
+
+    if show_all:
+        return (overlapping_inner_classes, class1_vars_set, class2_vars_set, class1_inner_classes_set, class2_inner_classes_set)
+
+    else:
+        return (overlapping_inner_classes)

+
+
+
[docs]def recursive_comparison(overlapping_inner_classes, outer_class_a, outer_class_b):
+    """
+    Recursively compares all inner classes to an infinite depth and identifies mismatched string-named values.
+
+    For all of the inner class names provided in overlapping_inner_classes this function calls compare_inner_classes
+    and compares those inner classes recursively until it reaches the full depth to which outer_class_a and
+    outer_class_b have any inner classes in common.
+
+    Parameters
+    ----------
+    overlapping_inner_classes : set of strings
+        This is a set of strings where each string is the name of an inner class that outer_class_a
+        and outer_class_b have in common.
+    outer_class_a : class
+        A class that is all or part of a variable hierarchy. This can be the top-level class in the 
+        hierarchy, or any inner class nested at any depth within that top-level class.
+    outer_class_b : class
+        A class that is all or part of a variable hierarchy. This can be the top-level class in the 
+        hierarchy, or any inner class nested at any depth within that top-level class.
+
+    Returns
+    -------
+    None
+
+    Exceptions
+    ----------
+    No exceptions explicitly raised by this function, although called functions may raise exceptions.
+    """
+    for overlapping_class_name in overlapping_inner_classes:
+        overlapping_inner_class_a = getattr(outer_class_a, overlapping_class_name)
+        overlapping_inner_class_b = getattr(outer_class_b, overlapping_class_name)
+        overlapping_second_inner_classes = compare_inner_classes(
+            overlapping_inner_class_a, overlapping_inner_class_b)
+        recursive_comparison(overlapping_second_inner_classes,
+                             overlapping_inner_class_a, overlapping_inner_class_b)

+
+
+
[docs]def compare_hierarchies_to_merge(hierarchies_to_merge):
+    """
+    Compares variable hierarchies to ensure there are no string-valued variable conflicts.
+
+    For all the variable hierarchies provided in hierarchies_to_merge this function compares each
+    hierarchy with every other hierarchy as well as the Aviary core aircraft and mission hierarchies
+    to ensure there are no string-valued variable conflicts within the same class or inner class to
+    and infinite depth.
+
+    Parameters
+    ----------
+    hierarchies_to_merge : list of classes
+        This is a list of variable hierarchy classes which will be compared for merge compatibility
+        with one another.
+
+    Returns
+    -------
+    None
+
+    Raises
+    ------
+    No explicit exceptions are raised by this function, although called functions may raise exceptions.
+    """
+
+    for hierarchy in hierarchies_to_merge:
+        # check if hierarchy has developed conflicts with original hierarchy
+        if issubclass(hierarchy, _Aircraft):
+            overlap = compare_inner_classes(hierarchy, _Aircraft)
+            recursive_comparison(overlap, hierarchy, _Aircraft)
+
+        # check if hierarchy has developed conflicts with original hierarchy
+        if issubclass(hierarchy, _Mission):
+            overlap = compare_inner_classes(hierarchy, _Mission)
+            recursive_comparison(overlap, hierarchy, _Mission)
+
+        for hierarchy2 in hierarchies_to_merge:
+            if hierarchy != hierarchy2:
+                overlap = compare_inner_classes(hierarchy, hierarchy2)
+                recursive_comparison(overlap, hierarchy, hierarchy2)

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/conflict_checks.html b/_modules/aviary/utils/conflict_checks.html new file mode 100644 index 000000000..223aa523b --- /dev/null +++ b/_modules/aviary/utils/conflict_checks.html @@ -0,0 +1,515 @@ + + + + + + + + + + + aviary.utils.conflict_checks + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.conflict_checks

+
+from aviary.utils.aviary_values import AviaryValues
+from aviary.variable_info.variables import Aircraft
+
+
+
[docs]def check_fold_location_definition(inputs, options: AviaryValues):
+    choose_fold_location = options.get_val(
+        Aircraft.Wing.CHOOSE_FOLD_LOCATION, units='unitless')
+    has_strut = options.get_val(Aircraft.Wing.HAS_STRUT, units='unitless')
+    if not choose_fold_location and not has_strut:
+        raise RuntimeError(
+            "The option CHOOSE_FOLD_LOCATION can only be False if the option HAS_STRUT is True.")

+
+# Possible TODO
+# Aircraft.Design.ULF_CALCULATED_FROM_MANEUVER - Aircraft.Design.PART25_STRUCTURAL_CATEGORY
+# Aircraft.Engine.FUSELAGE_MOUNTED - Aircraft.Engine.WING_LOCATIONS
+# Aircraft.Engine.NUM_ENGINES - Aircraft.Engine.NUM_FUSELAGE_ENGINES - Aircraft.Engine.NUM_WING_ENGINES
+# Aircraft.Propulsion.TOTAL_NUM_ENGINES - Aircraft.Propulsion.TOTAL_NUM_FUSELAGE_ENGINES - Aircraft.Propulsion.TOTAL_NUM_WING_ENGINES
+# Aircraft.Engine.TYPE - Aircraft.Engine.HAS_PROPELLERS
+# Aircraft.Design.COMPUTE_TAIL_VOLUME_COEFFS
+# Aircraft.Engine.REFERENCE_WEIGHT
+# Aircraft.Fuselage.PROVIDE_SURFACE_AREA - Aircraft.Fuselage.WETTED_AREA_FACTOR
+# Mission.Taxi.MACH - pycycle
+# Aircraft.HorizontalTail.AREA
+# Aircraft.VerticalTail.AREA
+# Aircraft.Strut.DIMENSIONAL_LOCATION_SPECIFIED
+# Aircraft.Wing.FOLD_LOCATION_IS_DIMENSIONAL
+# Aircraft.Wing.HAS_FOLD
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/csv_data_file.html b/_modules/aviary/utils/csv_data_file.html new file mode 100644 index 000000000..0ccb98605 --- /dev/null +++ b/_modules/aviary/utils/csv_data_file.html @@ -0,0 +1,756 @@ + + + + + + + + + + + aviary.utils.csv_data_file + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.csv_data_file

+import getpass
+import numpy as np
+import re
+import warnings
+
+from datetime import datetime
+from pathlib import Path
+
+from openmdao.utils.units import valid_units, is_compatible
+
+from aviary.utils.named_values import get_items, get_keys
+from aviary.utils.functions import get_path
+from aviary.utils.named_values import NamedValues
+
+
+
[docs]def read_data_file(filename: (str, Path), metadata=None, aliases=None,
+                   save_comments=False):
+    """
+    Read data file in Aviary format, which is data delimited by commas with any amount of
+    whitespace allowed between data entries. Spaces are not allowed in openMDAO
+    variables, so any spaces in header entries are replaced with underscores.
+
+    Parameters
+    ----------
+    filename : (str, Path)
+        filename or filepath of data file to be read
+    metadata : dict, optional
+        metadata to check validity of variable names provided in data file. Columns with
+        variable names that can't be found in metadata will be skipped. If not provided,
+        all validly formatted columns are always read.
+    aliases : dict, optional
+        optional dictionary to define a mapping of variables to allowable aliases in the
+        data file header. Keys are variable names, to be used in openMDAO, values
+        are a list of headers that correspond to that variable. Alias matching is not
+        case-sensitive, and underscores and spaces are treated as equivalent.
+    save_comments : bool, optional
+        flag if comments in data file should be returned along with data. Defaults to 
+        False.
+
+    Returns
+    -------
+    data : NamedValues
+        data read from file in NamedValues format, including variable name, units, and 
+        values (stored in a numpy array)
+    comments : list of str
+        any comments from file, with comment characters ('#') stripped out (only if 
+        save_comments=True)
+    """
+    filepath = get_path(filename)
+
+    data = NamedValues()
+    comments = []
+
+    # prep aliases for case-insensitive matching, with spaces == underscores
+    if aliases:
+        for key in aliases:
+            if isinstance(aliases[key], str):
+                aliases[key] = [aliases[key]]
+            aliases[key] = [re.sub('\s', '_', item).lower() for item in aliases[key]]
+
+    with open(filepath, newline=None, encoding='utf-8-sig') as file:
+        # csv.reader() and other avaliable packages that can read csv files are not used
+        # Manual control of file reading ensures that comments are kept intact and other
+        # checks can be performed
+        check_for_header = True
+        for line_count, line_data in enumerate(file):
+            # if comments are present in line, strip them out
+            if '#' in line_data:
+                index = line_data.index('#')
+                comments.append(line_data[index+1:].strip())
+                line_data = line_data[:index]
+
+            # split by delimiters, remove whitespace and newline characters
+            line_data = re.split(r'[;,]\s*', line_data.strip())
+
+            # ignore empty lines
+            if not line_data or line_data == ['']:
+                continue
+
+            # try to convert line_data to float, skip any blank strings
+            try:
+                line_data = [float(var) for var in line_data if var != '']
+            # data contains things other than floats
+            except (ValueError):
+                # skip checking for header data if not required
+                if check_for_header:
+                    # dictionary of header name: units
+                    header = {}
+                    # list of which column goes with each valid header entry
+                    valid_indices = []
+                    for index in range(len(line_data)):
+                        item = re.split('[(]', line_data[index])
+                        item = [item[i].strip(') ') for i in range(len(item))]
+                        # openMDAO vars can't have spaces, convert to underscores
+                        name = re.sub('\s', '_', item[0])
+                        if aliases:
+                            # "reverse" lookup name in alias dict
+                            for key in aliases:
+                                if name.lower() in aliases[key]:
+                                    name = key
+                                    break
+                        # 'default' default_units
+                        default_units = 'unitless'
+                        # if metadata is provided, ensure variable exists and update
+                        # default_units
+                        if metadata is not None:
+                            if name not in metadata.keys():
+                                warnings.warn(f'Header <{name}> was not recognized, and '
+                                              'will be skipped'
+                                              )
+                                continue
+                            else:
+                                default_units = metadata[name]['units']
+
+                        # if units are provided, check that they are valid
+                        if len(item) > 1:
+                            units = item[-1]
+                            if valid_units(item[1]):
+                                # check that units are compatible with expected units
+                                if metadata is not None:
+                                    if not is_compatible(units, default_units):
+                                        # Raising error here, as trying to use default
+                                        # units could mean accidental conversion which
+                                        # would significantly impact analysis
+                                        raise ValueError(f'Provided units of <{units}> '
+                                                         f'for column <{name}>, which '
+                                                         'are not compatible with default '
+                                                         f'units of {default_units}')
+                            else:
+                                # Units were not recognized. Raise error
+                                raise ValueError(f'Invalid units <{units}> provided for '
+                                                 f'column <{name}> while reading '
+                                                 f'<{filepath}>.')
+                        else:
+                            if metadata is not None and default_units != 'unitless':
+                                # units were not provided, but variable should have them
+                                # assume default units for that variable
+                                warning = f'Units were not provided for column <{name}> '\
+                                          f'while reading <{filepath}>. Using default '\
+                                          f'units of {default_units}.'
+                                warnings.warn(warning)
+                            units = default_units
+
+                        header[name] = units
+                        valid_indices.append(index)
+
+                    if len(header) > 0:
+                        check_for_header = False
+                        raw_data = {key: [] for key in header.keys()}
+                        continue
+
+                # only raise error if not checking for header, or invalid header found
+                raise ValueError(
+                    f'Non-numerical value found in data file <{filepath}> on line '
+                    f'{str(line_count)}')
+
+            # This point is reached when the first valid numerical entry in data file
+            # is found. Stop looking for header data from now on
+            check_for_header = False
+
+            # pull out data for each valid header, ignore other columns
+            for idx, variable in enumerate(header.keys()):
+                # valid_indices matches dictionary order, pull data from correct column
+                raw_data[variable].append(line_data[valid_indices[idx]])
+
+    # store data in NamedValues object
+    for variable in header.keys():
+        data.set_val(variable, val=np.array(raw_data[variable]), units=header[variable])
+
+    if save_comments:
+        return data, comments
+    else:
+        return data

+
+
+
[docs]def write_data_file(filename: (str, Path) = None, data: NamedValues = None,
+                    comments: (str, list) = [], include_timestamp: bool = False):
+    """
+    Write data to a comma-separated values (csv) format file using the Aviary data table
+    format.
+
+    Parameters
+    ----------
+    filename : (str, Path)
+        filename or filepath for data file to be written
+    data : NamedValues
+        NamedValues object containing data that will be written to file, which includes
+        variable name, units, and values
+    comments : (str, list of str), optional
+        optional comments that will be included in the top of the output file, before
+        data begins
+    include_timestamp : bool, optional
+        optional flag to set if timestamp and user should be include in file comments
+    """
+    if isinstance(filename, str):
+        filepath = Path(filename)
+    else:
+        filepath = filename
+
+    if data is None:
+        raise UserWarning(f'No data provided to write to {filepath.name}')
+
+    if type(comments) is str:
+        comments = [comments]
+
+    # strip '#' from comments - np.savetxt() will automatically add them
+    for idx, line in enumerate(comments):
+        if len(line) > 0:
+            if line[0] != '#':
+                comments[idx] = '# ' + line.strip()
+
+    # if there are comments, add some spacing afterwards - otherwise it should be empty
+    if comments:
+        comments.append('\n')
+
+    if include_timestamp:
+        timestamp = datetime.now().strftime('%m/%d/%y at %H:%M')
+        try:
+            user = ' by ' + getpass.getuser()
+        except Exception:
+            user = ''
+        stamp = [f'# created {timestamp}{user}\n']
+        comments = stamp + comments
+
+    # assemble separate variable name and units information into single list for header
+    header = []
+    data_dict = {}
+    for var, val_and_units in get_items(data):
+        units = val_and_units[1]
+        formatted_units = ''
+        # only explicitly include units if there are any
+        if units is not None and units != 'unitless':
+            formatted_units = ' (' + units + ')'
+        header.append(var + formatted_units)
+        data_dict[var] = np.array([str(i) for i in data.get_val(var, units)])
+
+    # set column widths, for more human-readable format
+    col_format = []
+    for i, key in enumerate(get_keys(data)):
+        header_len = len(header[i])
+        data_len = len(max(data_dict[key], key=len))
+        # min column width is 10 - spaced out columns are visually easier to follow
+        # don't pad first column
+        if i > 0:
+            min_width = 10
+        else:
+            min_width = 0
+        col_len = max(header_len, data_len, min_width)
+
+        # if headers are smaller than column, pad with leading whitespace
+        if header_len < col_len:
+            header[i] = ' '*(col_len-header_len) + header[i]
+
+        # special string to define column formatting with specific width
+        format = f'%{col_len}s'
+        # don't include commas for last column
+        if i < len(header)-1:
+            format = format + ', '
+        col_format.append(format)
+
+    # convert engine_data from dict to array so it can be written using savetxt
+    formatted_data = np.array([data_dict[key] for key in data_dict]).transpose()
+
+    # write to output file w/ header and comments
+    np.savetxt(filepath, formatted_data,
+               fmt=''.join(col_format),
+               delimiter=',',
+               header=', '.join(header),
+               comments='\n'.join(comments))

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/data_interpolator_builder.html b/_modules/aviary/utils/data_interpolator_builder.html new file mode 100644 index 000000000..1af783d6a --- /dev/null +++ b/_modules/aviary/utils/data_interpolator_builder.html @@ -0,0 +1,726 @@ + + + + + + + + + + + aviary.utils.data_interpolator_builder + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.data_interpolator_builder

+import warnings
+import numpy as np
+import openmdao.api as om
+
+from pathlib import Path
+
+from aviary.utils.named_values import get_keys, get_items
+from aviary.utils.csv_data_file import read_data_file
+from aviary.utils.functions import get_path
+from aviary.utils.named_values import NamedValues
+
+
+
[docs]def build_data_interpolator(num_nodes, interpolator_data=None, interpolator_outputs=None,
+                            method='slinear', extrapolate=True, structured=None,
+                            training_data=False):
+    """
+    Builder for openMDAO metamodel components using data provided via data file, directly
+    provided as an argument, or training data passed through openMDAO connections.
+    If using a structured grid, data can either be converted from a semistructured
+    grid format, or directly provided in structured grid format.
+
+    Parameters
+    ----------
+
+    num_nodes : int
+        Number of points that will be simultaneously interpolated during model executuion.
+
+    interpolator_data : (str, Path, NamedValues)
+        Path to the Aviary csv file containing all data required for interpolation, or
+        the data directly given as a NamedValues object.
+
+    interpolator_outputs : dict
+        Dictionary describing the names of dependent variables (keys) and their
+        units (values). If training_data is False, these variable names must reference
+        variables in data_file or interpolator_data. If training_data is True, then
+        this dictionary describes the names and units for training data that will be
+        provided via openMDAO connections during model execution.
+
+    method : str, optional
+        Interpolation method for metamodel. See openMDAO documentation for valid
+        options.
+
+    extrapolate : bool, optional
+        Flag that sets if metamodel should allow extrapolation
+
+    structured : bool, optional
+        Flag to set if interpolation data is a structure grid. If True, the 
+        structured metamodel component is used, if False, the semistructured metamodel is
+        used. If None, the builder chooses based on provided data structure.
+
+    training_data : bool, optional
+        Flag that sets if dependent data for interpolation will be passed via openMDAO
+        connections. If True, any provided values for dependent variables will
+        be ignored.
+
+    Returns
+    -------
+
+    interp_comp : om.MetaModelSemiStructuredComp, om.MetaModelStructuredComp
+        OpenMDAO metamodel component using the provided data and flags
+    """
+    # Argument checking #
+    if interpolator_outputs is None:
+        raise UserWarning('Independent variables for interpolation were not provided.')
+    # if interpolator data is a filepath, get data from file
+    if isinstance(interpolator_data, str):
+        interpolator_data = get_path(interpolator_data)
+    if isinstance(interpolator_data, Path):
+        interpolator_data = read_data_file(interpolator_data)
+
+    # Pre-format data: Independent variables placed before dependent variables - position
+    #                  of these variables relative to others of their type is preserved
+    #                  All data converted to numpy arrays
+    indep_vars = NamedValues()
+    dep_vars = NamedValues()
+    for (key, (val, units)) in get_items(interpolator_data):
+        if not isinstance(val, np.ndarray):
+            val = np.array(val)
+        if key in interpolator_outputs:
+            dep_vars.set_val(key, val, units)
+        else:
+            indep_vars.set_val(key, val, units)
+    # update interpolator_data with correctly ordered indep/dep vars in numpy arrays
+    interpolator_data.update(indep_vars)
+    for (key, (val, units)) in get_items(dep_vars):
+        interpolator_data.set_val(key, val, units)
+
+    # TODO investigate creating structured grid from semistructured grid via extrapolation
+
+    # is data already in structured format?
+    # assume data is structured until proven otherwise
+    data_pre_structured = True
+    shape = []
+    # check inputs, should be vector of unique values only
+    for (key, (val, units)) in get_items(interpolator_data):
+        if len(val.shape) == 1:
+            if key not in interpolator_outputs:
+                # try:
+                if np.array_equal(np.unique(val), val):
+                    # if vector is only unique values, could be structured!
+                    # Store shape and keep going
+                    shape.append(len(np.unique(val)))
+                else:
+                    # Data is not structured. Stop looping through inputs
+                    data_pre_structured = False
+                    break
+
+    # check outputs, should be array matching shape of input vector lengths
+    # if we already know data needs formatting, don't bother checking outputs
+    if data_pre_structured:
+        for key in interpolator_outputs:
+            (val, units) = interpolator_data.get_item(key)
+            if np.shape(val) != tuple(shape):
+                if len(np.shape(val)) > 1:
+                    # we know for sure user was *trying* to set up a structured grid
+                    # if output is multi-dimensional array. If output is 1d it could
+                    # be a strucured grid with one input, or a semistructured grid
+                    raise ValueError(f'shape of output <{key}>, {np.shape(val)}, does '
+                                     f'not match expected shape {tuple(shape)}')
+                else:
+                    # We don't know if data is structured or not if 1d. No harm
+                    # in sorting and "reformatting", so assume it needs to be converted
+                    data_pre_structured = False
+                    break
+
+    if structured is None and data_pre_structured:
+        # If the data is already structured, just use a structured grid - it's faster
+        # with no downsides
+        structured = True
+    elif structured is None:
+        # In case structured is still None, set it to False - we know data is unstructured
+        structured = False
+
+    if not training_data:
+        # Sort and format data. Only if not using training data - since we have control
+        # over both input and output data they are guarenteed to match after reformatting
+
+        # sort data in semistructured grid format
+        # always sort unless data is in structured format
+        if not data_pre_structured:
+            # first check that data are all vectors of the same length
+            for idx, item in enumerate(get_items(interpolator_data)):
+                key = item[0]
+                units = item[1][1]
+                if idx != 0:
+                    prev_model_length = model_length
+                else:
+                    prev_model_length = len(interpolator_data.get_val(key, units))
+                model_length = len(interpolator_data.get_val(key, units))
+                if model_length != prev_model_length:
+                    raise IndexError('Lengths of data provided for interpolation do not '
+                                     'match.')
+
+            # get data into column array format
+            sorted_values = np.array([val for (key, (val, units))
+                                      in get_items(interpolator_data)]).transpose()
+
+            # get all the independent values in format needed for sorting
+            independent_vals = np.array([val for (key, (val, units))
+                                         in get_items(indep_vars)])
+
+            # Sort by dependent variables in priority order of their appearance
+            sorted_values = sorted_values[np.lexsort(np.flip(independent_vals, 0))]
+
+            # reset interpolator_data with sorted values
+            for idx, (var, (val, units)) in enumerate(get_items(interpolator_data)):
+                interpolator_data.set_val(var, sorted_values[:, idx], units)
+
+        # If user wants structured data, but provided data is not formatted correctly,
+        # convert it!
+        if structured and not data_pre_structured:
+            # Use assumptions for structured grid to format data
+            # Only need to reformat data when not using training data, user is responsible
+            # for formatting in that case
+            # Assumes independent variables are first columns
+
+            (length, var_count) = np.shape(sorted_values)
+            indep_var_count = np.shape(independent_vals)[0]
+
+            structured_data = []
+            # only need unique independent variables
+            unique_data = []
+            for i in range(indep_var_count):
+                unique_data.append(np.unique(sorted_values[:, i]))
+                structured_data.append(unique_data[i])
+
+            shape = tuple([np.size(unique_data[i]) for i in range(indep_var_count)])
+
+            # output data needs to be in nd array format
+            for i in range(indep_var_count, var_count):
+                structured_data.append(np.reshape(sorted_values[:, i], shape))
+
+            # reset interpolator_data with structured grid formatted values
+            for idx, (var, (val, units)) in enumerate(get_items(interpolator_data)):
+                interpolator_data.set_val(var, structured_data[idx], units)
+
+    if training_data and structured and not data_pre_structured:
+        # User has asked for structured data but not provided it. Use of training data
+        # means we can't do any processing on the data including ensuring sorted order,
+        # since that might misalign inputs with future connections we can't control here
+        # Just convert inputs to structure grid format
+        for key in get_keys(indep_vars):
+            (val, units) = interpolator_data.get_item(key)
+            # take unique values only, put back into interpolator_data
+            val = np.unique(val)
+            interpolator_data.set_val(key, val, units)
+
+    # create interpolation component
+    if structured:
+        interp_comp = om.MetaModelStructuredComp(method=method,
+                                                 extrapolate=extrapolate,
+                                                 vec_size=num_nodes,
+                                                 training_data_gradients=training_data)
+    else:
+        interp_comp = om.MetaModelSemiStructuredComp(method=method,
+                                                     extrapolate=extrapolate,
+                                                     vec_size=num_nodes,
+                                                     training_data_gradients=training_data)
+
+    # add interpolator inputs
+    for key in get_keys(indep_vars):
+        values, units = interpolator_data.get_item(key)
+        interp_comp.add_input(key,
+                              training_data=values,
+                              units=units)
+    # add interpolator outputs
+    for key in interpolator_outputs:
+        if key in interpolator_data:
+            values, units = interpolator_data.get_item(key)
+        if training_data:
+            units = interpolator_outputs[key]
+            interp_comp.add_output(key,
+                                   units=units)
+        else:
+            interp_comp.add_output(key,
+                                   training_data=values,
+                                   units=units)
+
+    return interp_comp

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/develop_metadata.html b/_modules/aviary/utils/develop_metadata.html new file mode 100644 index 000000000..67c7b04fe --- /dev/null +++ b/_modules/aviary/utils/develop_metadata.html @@ -0,0 +1,663 @@ + + + + + + + + + + + aviary.utils.develop_metadata + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.develop_metadata

+
[docs]def add_meta_data(
+        key,
+        meta_data,
+        units='unitless',
+        desc=None,
+        default_value=0.0,
+        option=False,
+        types=None,
+        historical_name=None,
+        _check_unique=True):
+    '''
+    Add new meta data associated with variables in the Aviary data hierarchy.
+
+    Parameters
+    ----------
+    key : str
+        Aviary variable name
+
+    meta_data : dict
+        dictionary of meta data to add the variable to
+
+    units : str or None
+        units of measure
+
+    desc : str
+        brief description of the variable
+
+    default_value : any
+        in context, the Aviary value assumed if the variable is missing from
+        options and/or inputs
+
+        Note, a default value of `None` indicates that the variable is
+        optional, but that there is no default.
+
+    option : bool
+        indicates that this variable is an option, rather than a normal input
+
+    types : type
+        gives the allowable type(s) of the variable
+
+    historical_name : dict or None
+        dictionary of names that the variable held in prior codes
+
+        Example: {"FLOPS":"WTIN.WNGWT", "LEAPS1": "aircraft.inputs.wing_weight", "GASP": "INGASP.WWGHT"}
+
+        NAMELIST nameing convention
+            &<function_name>.<namelist_name>.<var_name>
+
+            Example: &DEFINE.CONFIN.GW
+                represents the GW variable of the CONFIN namelist as defined in
+                the DEFINE subroutine
+
+        COMMON block naming convention, including aliases:
+            <block_name>.<var_name>
+
+            Example: CONFIG.GW
+                represents the GW variable of the CONFIG common block
+
+        Local variable naming convention, including equivalence statements, parameters, and other local declarations:
+            ~<function_name>.<var_name>
+
+            Example: ~ANALYS.GWTOL
+                represents the GWTOL variable of the ANALYS subroutine
+
+    _check_unique : bool
+        private use only flag that tells whether to check the meta_data for the pre-existing presence
+        of the provided key. This should only be set to false when update_meta_data is the calling function.
+
+    Returns
+    ------- 
+    None
+        No variables returned by this method.
+
+    Raises
+    ----------
+    None
+        No exceptions raised by this method, although other methods called within may raise exceptions.
+    '''
+
+    if key in meta_data and _check_unique:
+        raise ValueError(
+            f'You added the variable {key} to a variable metadata dictionary via the add_meta_data function, but {key} already was present in the dictionary. If you are sure you want to overwrite this variable, call the update_meta_data function instead.')
+
+    if units is None:
+        units = 'unitless'
+
+    meta_data[key] = {
+        'historical_name': historical_name,
+        'units': units,
+        'desc': desc,
+        'option': option,
+        'default_value': default_value,
+        'types': types
+    }

+
+
+
[docs]def update_meta_data(
+        key,
+        meta_data,
+        units='unitless',
+        desc=None,
+        default_value=0.0,
+        option=False,
+        types=None,
+        historical_name=None):
+    '''
+    Update existing meta data associated with variables in the Aviary data hierarchy.
+
+    Parameters
+    ----------
+    key : str
+        Aviary variable name
+
+    meta_data : dict
+        dictionary of meta data to add the variable to
+
+    units : str or None
+        units of measure
+
+    desc : str
+        brief description of the variable
+
+    default_value : Any
+        in context, the Aviary value assumed if the variable is missing from
+        options and/or inputs
+
+        Note, a default value of `None` indicates that the variable is
+        optional, but that there is no default.
+
+    option : bool
+        indicates that this variable is an option, rather than a normal input
+
+    types : type
+        gives the allowable type(s) of the variable
+
+    historical_name : dict or None
+        dictionary of names that the variable held in prior codes
+
+        Example: {"FLOPS":"WTIN.WNGWT", "LEAPS1": "aircraft.inputs.wing_weight", "GASP": "INGASP.WWGHT"}
+
+        NAMELIST nameing convention
+            &<function_name>.<namelist_name>.<var_name>
+
+            Example: &DEFINE.CONFIN.GW
+                represents the GW variable of the CONFIN namelist as defined in
+                the DEFINE subroutine
+
+        COMMON block naming convention, including aliases:
+            <block_name>.<var_name>
+
+            Example: CONFIG.GW
+                represents the GW variable of the CONFIG common block
+
+        Local variable naming convention, including equivalence statements, parameters, and other local declarations:
+            ~<function_name>.<var_name>
+
+            Example: ~ANALYS.GWTOL
+                represents the GWTOL variable of the ANALYS subroutine
+
+    Returns
+    ------- 
+    None
+        No variables returned by this method.
+
+    Raises
+    ----------
+    None
+        No exceptions raised by this method, although other methods called within may raise exceptions.
+    '''
+
+    if key not in meta_data:
+        raise ValueError(
+            f'You provided the variable {key} to a variable metadata dictionary via the update_meta_data function, but {key} does not exist in the dictionary. If you are sure you want to add this variable to the dictionary, call the add_meta_data function instead.')
+
+    add_meta_data(key=key, meta_data=meta_data, units=units, desc=desc,
+                  default_value=default_value, option=option, types=types, historical_name=historical_name, _check_unique=False)

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/engine_deck_conversion.html b/_modules/aviary/utils/engine_deck_conversion.html new file mode 100644 index 000000000..777a5d92f --- /dev/null +++ b/_modules/aviary/utils/engine_deck_conversion.html @@ -0,0 +1,1191 @@ + + + + + + + + + + + aviary.utils.engine_deck_conversion + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.engine_deck_conversion

+#!/usr/bin/python
+
+import argparse
+import getpass
+import itertools
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+
+import numpy as np
+import openmdao.api as om
+from dymos.models.atmosphere import USatm1976Comp
+from openmdao.components.interp_util.interp import InterpND
+
+from aviary.subsystems.propulsion.engine_deck import normalize
+from aviary.subsystems.propulsion.utils import EngineModelVariables, default_units
+from aviary.variable_info.variables import Dynamic
+from aviary.utils.csv_data_file import write_data_file
+from aviary.utils.functions import get_path
+from aviary.utils.named_values import NamedValues
+
+
+
[docs]class EngineDeckType(Enum):
+    FLOPS = 'FLOPS'
+    GASP = 'GASP'

+
+
+MACH = EngineModelVariables.MACH
+ALTITUDE = EngineModelVariables.ALTITUDE
+THROTTLE = EngineModelVariables.THROTTLE
+HYBRID_THROTTLE = EngineModelVariables.HYBRID_THROTTLE
+THRUST = EngineModelVariables.THRUST
+GROSS_THRUST = EngineModelVariables.GROSS_THRUST
+RAM_DRAG = EngineModelVariables.RAM_DRAG
+FUEL_FLOW = EngineModelVariables.FUEL_FLOW
+ELECTRIC_POWER = EngineModelVariables.ELECTRIC_POWER
+NOX_RATE = EngineModelVariables.NOX_RATE
+TEMPERATURE = EngineModelVariables.TEMPERATURE_ENGINE_T4
+# EXIT_AREA = EngineModelVariables.EXIT_AREA
+
+flops_keys = [
+    MACH,
+    ALTITUDE,
+    THROTTLE,
+    GROSS_THRUST,
+    RAM_DRAG,
+    FUEL_FLOW,
+    NOX_RATE]  # , EXIT_AREA]
+
+# later code assumes T4 is last item in keys
+gasp_keys = [MACH, ALTITUDE, THROTTLE, THRUST, FUEL_FLOW, TEMPERATURE]
+
+header_names = {
+    MACH: 'Mach_Number',
+    ALTITUDE: 'Altitude',
+    THROTTLE: 'Throttle',
+    THRUST: 'Thrust',
+    GROSS_THRUST: 'Gross_Thrust',
+    RAM_DRAG: 'Ram_Drag',
+    FUEL_FLOW: 'Fuel_Flow',
+    NOX_RATE: 'NOx_Rate',
+    TEMPERATURE: 'T4',
+    # EXIT_AREA: 'Exit Area',
+}
+
+
+
[docs]def EngineDeckConverter(input_file=None, output_file=None, data_format=None):
+    '''
+    Converts FLOPS- or GASP-formatted engine decks into Aviary csv format.
+    FLOPS decks are changed from column-delimited to csv format with added headers.
+    GASP decks are reorganized into csv. T4 is recovered using assumptions used in GASPy.
+    Data points whose T4 exceeds T4max are removed.
+
+    Parameters
+    ----------
+    input_file : (str, Path)
+        path to engine deck file to be converted
+    output_file : (str, Path)
+        path to file where new converted data will be written
+    data_format : (EngineDeckType)
+        data format used by input_file (FLOPS or GASP)
+    readable : (bool)
+        output_file will be organized with consistent column widths for easier reading
+    '''
+    # TODO rounding for calculated values?
+
+    timestamp = datetime.now().strftime('%m/%d/%y at %H:%M')
+    user = getpass.getuser()
+    comments = []
+    header = {}
+    data = {}
+
+    data_file = get_path(input_file)
+
+    comments.append(f'# created {timestamp} by {user}')
+    comments.append(
+        f'# {data_format.value}-derived engine deck converted from {data_file.name}')
+    if data_format == EngineDeckType.FLOPS:
+        header = {key: default_units[key] for key in flops_keys}
+        data = {key: np.array([]) for key in flops_keys}
+
+        with open(data_file, newline='', encoding='utf-8-sig') as file:
+            reader = _read_flops_engine(file)
+            data_starts = False
+
+            for line in reader:
+                if not data_starts:
+                    # pull out comments before data starts
+                    if line[0][0] == '#':
+                        comments.append(line)
+                        continue
+                    data_starts = True
+
+                data[MACH] = np.append(data[MACH], line[0])
+                data[ALTITUDE] = np.append(data[ALTITUDE], line[1])
+                data[THROTTLE] = np.append(data[THROTTLE], line[2])
+                data[GROSS_THRUST] = np.append(data[GROSS_THRUST], line[3])
+                data[RAM_DRAG] = np.append(data[RAM_DRAG], line[4])
+                data[FUEL_FLOW] = np.append(data[FUEL_FLOW], line[5])
+                data[NOX_RATE] = np.append(data[NOX_RATE], line[6])
+                # data[EXIT_AREA].append(line[7])
+
+    elif data_format == EngineDeckType.GASP:
+        data = {key: [] for key in gasp_keys}
+
+        scalars, tables = _read_gasp_engine(data_file)
+        # save scalars as comments
+        comments.extend(['# ' + key + ': ' + str(scalars[key])
+                        for key in scalars.keys()])
+
+        # recommended to always generate structured grid
+        structure_data = True
+        if structure_data:
+            structured_data = _make_structured_grid(tables, method='lagrange3')
+
+            data[MACH] = structured_data['thrust']['machs']
+            data[ALTITUDE] = structured_data['thrust']['alts']
+            data[THRUST] = structured_data['thrust']['vals']
+            data[FUEL_FLOW] = structured_data['fuelflow']['vals']
+            T4T2 = structured_data['thrust']['t4t2s']
+
+        else:
+            data[MACH] = tables['thrust'][:, 2]
+            data[ALTITUDE] = tables['thrust'][:, 0]
+            data[THRUST] = tables['thrust'][:, 3]
+            data[FUEL_FLOW] = tables['fuelflow'][:, 3]
+            T4T2 = tables['thrust'][:, 1]
+
+        generate_flight_idle = True
+        if generate_flight_idle:
+            data, T4T2 = _generate_flight_idle(data, T4T2,
+                                               ref_sls_airflow=scalars['sls_airflow'],
+                                               ref_sfn_idle=scalars['sfn_idle'])
+
+        t4max = scalars['t4max']
+
+        # if t4max 100 or less, it is actually throttle. Remove temperature as variable
+        if t4max <= 100:
+            compute_T4 = False
+            data.pop(TEMPERATURE)
+            # temperature is assumed last in keys
+            gasp_keys.pop(-1)
+        else:
+            compute_T4 = True
+
+        # define header now that we know what is in the engine deck
+        header = {key: default_units[key] for key in gasp_keys}
+
+        if compute_T4:
+            # compute T4 using atmospheric model
+            prob = om.Problem()
+
+            prob.model.add_subsystem('T4T2', om.IndepVarComp('T4:T2',
+                                                             T4T2,
+                                                             units='unitless'),
+                                     promotes=['*'])
+
+            prob.model.add_subsystem(
+                Dynamic.Mission.MACH,
+                om.IndepVarComp(
+                    Dynamic.Mission.MACH,
+                    data[MACH],
+                    units='unitless'),
+                promotes=['*'])
+
+            prob.model.add_subsystem(
+                Dynamic.Mission.ALTITUDE,
+                om.IndepVarComp(
+                    Dynamic.Mission.ALTITUDE,
+                    data[ALTITUDE],
+                    units='ft'),
+                promotes=['*'])
+
+            prob.model.add_subsystem(
+                name='atmosphere',
+                subsys=USatm1976Comp(num_nodes=len(data[MACH])),
+                promotes_inputs=[('h', Dynamic.Mission.ALTITUDE)],
+                promotes_outputs=[('temp', Dynamic.Mission.TEMPERATURE)])
+
+            prob.model.add_subsystem(
+                name='conversion',
+                subsys=AtmosCalc(num_nodes=len(data[MACH])),
+                promotes_inputs=[Dynamic.Mission.MACH,
+                                 Dynamic.Mission.TEMPERATURE],
+                promotes_outputs=['t2']
+            )
+
+            prob.setup()
+            prob.run_model()
+
+            T2 = prob.get_val('t2')
+            T4 = T2 * T4T2
+            data[TEMPERATURE] = T4
+            # Throttle is T4 normalized from 0 to 1 (T4max)
+            # By always keeping minimum T4 zero for normalization, throttle stays
+            #   consistent with fraction of T4max
+            # TODO flight condition dependent throttle range?
+            # NOTE this often leaves max throttles less than 1 in the deck - this caues
+            #     problems when finding reference SLS thrust, as there is often no max
+            #     power data at that point in the engine deck. It is reccomended GASP
+            #     engine decks override Aircraft.Engine.REFERENCE_THRUST in EngineDecks
+            data[THROTTLE] = normalize(data[TEMPERATURE], minimum=0.0, maximum=t4max)
+
+            # remove all points above T4max
+            # TODO save these points as commented out?
+            valid_idx = np.where(data[THROTTLE] <= 1.0)
+            data[MACH] = data[MACH][valid_idx]
+            data[ALTITUDE] = data[ALTITUDE][valid_idx]
+            data[THROTTLE] = data[THROTTLE][valid_idx]
+            data[THRUST] = data[THRUST][valid_idx]
+            data[FUEL_FLOW] = data[FUEL_FLOW][valid_idx]
+            data[TEMPERATURE] = data[TEMPERATURE][valid_idx]
+
+        else:
+            data[THROTTLE] = T4T2
+
+        # data needs to be string so column length can be easily found later
+        for var in data:
+            data[var] = np.array([str(item) for item in data[var]])
+
+    else:
+        quit("Invalid engine deck format provided")
+
+    # sort data
+    # create parallel dict to data that stores floats
+    formatted_data = {}
+    for key in data:
+        formatted_data[key] = data[key].astype(float)
+
+    # convert engine_data from dict to list so it can be sorted
+    sorted_values = np.array([formatted_data[key] for key in formatted_data]).transpose()
+
+    # Sort by mach, then altitude, then throttle, then hybrid throttle
+    sorted_values = sorted_values[np.lexsort(
+        [formatted_data[THROTTLE],
+         formatted_data[ALTITUDE],
+         formatted_data[MACH]])]
+    for idx, key in enumerate(formatted_data):
+        formatted_data[key] = sorted_values[:, idx]
+
+    # rework formatted_data into 2d array
+    formatted_data = np.array([formatted_data[key]
+                              for key in header.keys()]).transpose().astype(float)
+
+    # store formatted data into NamedValues object
+    write_data = NamedValues()
+    for idx, key in enumerate(data):
+        write_data.set_val(header_names[key], data[key], default_units[key])
+
+    write_data_file(output_file, write_data, comments, include_timestamp=False)

+
+
+def _read_flops_engine(input_file):
+    '''
+    Read engine data file using FLOPS standard, which is column delimited data
+    always assumed to be in the order defined in the FLOPS manual
+    '''
+    for line in input_file:
+        sz = len(line)
+
+        if sz < 80:
+            line = line + (80 - sz) * ' '
+
+        if line[0] == '#':
+            data = line.strip()
+        else:
+            data = [
+                _flops_field_convert(line[0:5]),
+                _flops_field_convert(line[5:15]),
+                _flops_field_convert(line[15:20]),
+                _flops_field_convert(line[20:30]),
+                _flops_field_convert(line[30:40]),
+                _flops_field_convert(line[40:50]),
+                # intenional gap from 50:60 - column is left blank in FLOPS standard
+                _flops_field_convert(line[60:70]),
+                _flops_field_convert(line[70:80]),
+            ]
+
+        yield data
+
+
+def _flops_field_convert(arg: str):
+    rvalue = arg.strip()
+
+    if not rvalue:
+        rvalue = _flops_empty_field
+
+    return rvalue
+
+
+# in FLOPS, empty fields are converted to zero
+_flops_empty_field = '0'
+
+
+def _read_gasp_engine(fp):
+    """Read a GASP engine deck file and parse its scalars and tabular data.
+    Scalars (T4 max, SLS airflow, etc.) are read from the first line of the engine deck
+    (IREAD=1 is assumed) and returned in a dictionary.
+    Data tables are also returned as a dictionary, with separate tables for thrust,
+    fuelflow, and airflow, since they may have different grids in general.
+    Each table consists of both the independent variables and the dependent variable for
+    the corresponding field. The table is a "tidy format" 2D array where the first three
+    columns are the independent varaiables (altitude, T4/T2, and Mach number) and the
+    final column is the dependent variable (one of thrust, fuelflow, or airflow).
+    """
+    with open(fp, "r") as f:
+        scalars = _read_header(f)
+        tables = {k: _read_table(f) for k in ["thrust", "fuelflow", "airflow"]}
+
+    return scalars, tables
+
+
+def _read_header(f):
+    """Read GASP engine deck header, returning the engine scalars in a dict"""
+    # file header: FORMAT(2I5,10X,5F10.4)
+    iread, iprint, wamap, t4max, t4mcl, t4mc, sfnidl = _parse(
+        f, [*_rep(2, (int, 5)), (None, 10), *_rep(5, (float, 10))]
+    )
+
+    if iread != 1:
+        raise RuntimeError(f"IREAD=1 expected, got {iread}")
+
+    return {
+        "t4max": t4max,
+        "t4cruise": t4mc,
+        "t4climb": t4mcl,
+        "sls_airflow": wamap,
+        "sfn_idle": sfnidl,
+    }
+
+
+def _read_table(f):
+    """Read an entire table from a GASP engine deck file.
+    The table data is returned as a "tidy format" array with three columns for the
+    independent variables (altitude, T4/T2, and Mach number) and the final column for
+    the table field (one of thrust, fuelflow, or airflow).
+    """
+    tab_data = None
+
+    # table title
+    title = f.readline().strip()
+    # number of maps in the table
+    (nmaps,) = _parse(f, [(int, 5)])
+    # blank line
+    f.readline()
+
+    for i in range(nmaps):
+        map_data = _read_map(f)
+
+        # blank line following all but the last map in the table
+        if i < nmaps - 1:
+            f.readline()
+
+        if tab_data is None:
+            tab_data = map_data
+        else:
+            tab_data = np.r_[tab_data, map_data]
+
+    return tab_data
+
+
+def _rep(n, t):
+    """Shorthand for ``itertools.repeat`` with the multiplier first."""
+    return itertools.repeat(t, n)
+
+
+def _parse(f, fmt):
+    """Read a line from file ``f`` and parse it according to the given ``fmt``"""
+    return _strparse(f.readline(), fmt)
+
+
+def _strparse(s, fmt):
+    """Parse a string into fixed-width numeric fields.
+    ``fmt`` should be a list of tuples specifying (type, length) for each field in
+    string ``s``. Use None for the type to skip (i.e. not yield) that field.
+    """
+    p = 0
+    for typ, length in fmt:
+        sub = s[p: p + length]
+        if typ is not None:
+            yield typ(sub)
+        p += length
+
+
+def _read_map(f):
+    """Read a single map of a table from the engine deck file.
+    The map data is returned in the same format as in ``read_table``, except there is a
+    single altitude value per map.
+    """
+    # map dimensions: FORMAT(/2I5,F10.1,10X))
+    npts, nline, amap = _parse(f, [*_rep(2, (int, 5)), (float, 10)])
+
+    map_data = np.empty((npts * nline, 4))
+    map_data[:, 0] = amap
+
+    # number of points on a single line - wrapped if more than 6
+    nptloc = min(6, npts)
+
+    # point vals: FORMAT(10X,6F10.4,10X)
+    x = list(_parse(f, [(None, 10), *_rep(nptloc, (float, 10))]))
+    if npts > nptloc:
+        # remaining vals on wrapped line
+        x.extend(list(_parse(f, [(None, 10), *_rep(npts - nptloc, (float, 10))])))
+
+    map_data[:, 2] = np.tile(x, nline)
+
+    for j in range(nline):
+        # line (y) val then z vals: FORMAT(F10.4,6F10.1,10X,/(6F10.1,10X))
+        vals = list(_parse(f, [(float, 10), *_rep(nptloc, (float, 10))]))
+        y = vals[0]
+        z = vals[1:]
+        if npts > nptloc:
+            # ad remaining vals on warapped line
+            z.extend(list(_parse(f, _rep(npts - nptloc, (float, 10)))))
+
+        sl = slice(j * npts, (j + 1) * npts)
+        map_data[sl, 1] = y
+        map_data[sl, 3] = z
+
+    return map_data
+
+
+def _make_structured_grid(data, method="lagrange3"):
+    """Generate a structured grid of unique mach/T4:T2/alt values in the deck"""
+    # step size in t4/t2 ratio used in generating the structured grid
+    # t2t2_step = 0.5 # original value
+    t4t2_step = 0.5
+    # step size in mach number used in generating the structured grid
+    # mach_step = 0.02 # original value
+    mach_step = 0.05
+
+    structured_data = {}
+
+    tt4 = data['thrust'][:, 1]
+    tma = data['thrust'][:, 2]
+    t4t2s = np.arange(min(tt4), max(tt4) + t4t2_step, t4t2_step)
+    machs = np.arange(min(tma), max(tma) + mach_step, mach_step)
+
+    # need t4t2 in first column, mach varies on each row
+    pts = np.dstack(np.meshgrid(t4t2s, machs, indexing="ij")).reshape(-1, 2)
+    npts = pts.shape[0]
+
+    for field in ["thrust", "fuelflow", "airflow"]:
+        map_data = data[field]
+        all_alts = map_data[:, 0]
+        alts = np.unique(all_alts)
+
+        sizes = (alts.size, t4t2s.size, machs.size)
+        vals = np.zeros(np.prod(sizes), dtype=float)
+        alt_vec = np.zeros(np.prod(sizes), dtype=float)
+        mach_vec = np.zeros(np.prod(sizes), dtype=float)
+        t4t2_vec = np.zeros(np.prod(sizes), dtype=float)
+
+        for i, alt in enumerate(alts):
+            d = map_data[all_alts == alt]
+            t4t2 = np.unique(d[:, 1])
+            mach = np.unique(d[:, 2])
+            f = d[:, 3].reshape(t4t2.size, mach.size)
+
+            # would explicitly use lagrange3 here to mimic GASP, but some engine
+            # decks may not have enough points per dimension
+            interp = InterpND(
+                method="2D-" + method, points=(t4t2, mach), values=f, extrapolate=True
+            )
+            sl = slice(i * npts, (i + 1) * npts)
+            vals[sl] = interp.interpolate(pts)
+            alt_vec[sl] = [alt] * len(pts)
+            t4t2_vec[sl] = pts[:, 0]
+            mach_vec[sl] = pts[:, 1]
+
+        structured_data[field] = {
+            "vals": vals,
+            "alts": alt_vec,
+            "t4t2s": t4t2_vec,
+            "machs": mach_vec,
+        }
+
+    return structured_data
+
+
+def _generate_flight_idle(data, T4T2, ref_sls_airflow, ref_sfn_idle):
+    machs = np.unique(data[MACH])
+    alts = np.unique(data[ALTITUDE])
+
+    mach_list, alt_list = np.meshgrid(machs, alts)
+    mach_list = mach_list.flatten()
+    alt_list = alt_list.flatten()
+
+    nn = len(mach_list)
+
+    prob = om.Problem()
+
+    prob.model.add_subsystem(
+        Dynamic.Mission.MACH,
+        om.IndepVarComp(
+            Dynamic.Mission.MACH,
+            mach_list,
+            units='unitless'),
+        promotes=['*'])
+
+    prob.model.add_subsystem(
+        Dynamic.Mission.ALTITUDE,
+        om.IndepVarComp(
+            Dynamic.Mission.ALTITUDE,
+            alt_list,
+            units='ft'),
+        promotes=['*'])
+
+    prob.model.add_subsystem(
+        name='atmosphere', subsys=USatm1976Comp(
+            num_nodes=nn), promotes_inputs=[
+            ('h', Dynamic.Mission.ALTITUDE)], promotes_outputs=[
+                ('temp', Dynamic.Mission.TEMPERATURE), ('pres', Dynamic.Mission.STATIC_PRESSURE)])
+
+    prob.model.add_subsystem(
+        name='conversion',
+        subsys=AtmosCalc(
+            num_nodes=nn),
+        promotes_inputs=[
+            Dynamic.Mission.MACH,
+            Dynamic.Mission.TEMPERATURE,
+            Dynamic.Mission.STATIC_PRESSURE],
+        promotes_outputs=[
+            't2',
+            'p2'])
+
+    prob.model.add_subsystem(
+        name='flight_idle',
+        subsys=CalculateIdle(
+            num_nodes=nn,
+            ref_sfn_idle=ref_sfn_idle,
+            ref_sls_airflow=ref_sls_airflow),
+        promotes_inputs=[
+            't2',
+            'p2',
+            'pct_corr_airflow_idle',
+            'sfc_idle'],
+        promotes_outputs=[
+            'idle_thrust',
+            'idle_fuelflow'])
+
+    prob.setup()
+
+    prob.run_model()
+
+    idle_thrust = prob.get_val('idle_thrust')
+    idle_fuelflow = prob.get_val('idle_fuelflow')
+
+    data[MACH] = np.append(data[MACH], mach_list)
+    data[ALTITUDE] = np.append(data[ALTITUDE], alt_list)
+    data[THRUST] = np.append(data[THRUST], idle_thrust)
+    data[FUEL_FLOW] = np.append(data[FUEL_FLOW], idle_fuelflow)
+    T4T2 = np.append(T4T2, np.zeros(nn))
+
+    return data, T4T2
+
+
+_PSLS_PSF = 2116.22  # SLS pressure in psf
+_TSLS_DEGR = 518.67  # SLS temperature in deg R
+
+
+
[docs]class CalculateIdle(om.ExplicitComponent):
+    '''
+    Calculates idle conditions of a GASP engine at a specified flight condition
+    Vectorized to calculate values for entire flight regime
+    '''
+
+
[docs]    def initialize(self):
+        self.options.declare('num_nodes', types=int)
+
+        self.options.declare(
+            'ref_sfn_idle',
+            1.0,
+            desc='Idle thrust-specific fuel consumption, from engine deck')
+        self.options.declare(
+            'ref_sls_airflow',
+            1.0,
+            desc='Sea-level static airflow of the reference engine')

+
+
[docs]    def setup(self):
+        nn = self.options["num_nodes"]
+
+        self.add_input(
+            "t2", _TSLS_DEGR, units="degR", shape=nn, desc="Engine inlet temperature"
+        )
+        self.add_input(
+            "p2", _PSLS_PSF, units="psf", shape=nn, desc="Engine inlet pressure"
+        )
+        self.add_input(
+            "pct_corr_airflow_idle", 0.5, desc="Percent corrected airflow at idle"
+        )
+        self.add_input(
+            "sfc_idle",
+            1.0,
+            units="lbm/h/lbf",
+            desc="Thrust-specific fuel consumption at idle",
+        )
+
+        self.add_output("idle_thrust", units="lbf", shape=nn, desc="Idle thrust")
+        # self.add_output(
+        #     "idle_airflow", units="lbf/s", shape=nn, desc="Idle corrected airflow"
+        # )
+        self.add_output("idle_fuelflow", units="lbm/h", shape=nn, desc="Idle fuel flow")

+
+
[docs]    def compute(self, inputs, outputs):
+        (
+            t2,
+            p2,
+            pct_corr_airflow_idle,
+            sfc_idle,
+        ) = inputs.values()
+
+        ref_sls_airflow = self.options['ref_sls_airflow']
+        ref_sfn_idle = self.options['ref_sfn_idle']
+
+        rthet2 = np.sqrt(t2 / _TSLS_DEGR)
+        delta2 = p2 / _PSLS_PSF
+
+        airflow_ref = pct_corr_airflow_idle * ref_sls_airflow  # don't un-correct
+        thrust_ref = airflow_ref * delta2 / rthet2 * ref_sfn_idle
+        fuelflow_ref = thrust_ref * sfc_idle
+
+        outputs["idle_thrust"] = thrust_ref
+        # outputs["idle_airflow"] = airflow_ref
+        outputs["idle_fuelflow"] = fuelflow_ref

+
+
+
[docs]class AtmosCalc(om.ExplicitComponent):
+    '''
+    Calculates T2 and P2 given static temperature and pressure
+    '''
+
+
[docs]    def initialize(self):
+        self.options.declare('num_nodes', types=int)

+
+
[docs]    def setup(self):
+        nn = self.options['num_nodes']
+        self.add_input(Dynamic.Mission.MACH, val=np.zeros(nn),
+                       desc='current Mach number', units='unitless')
+        self.add_input(Dynamic.Mission.TEMPERATURE, val=np.zeros(nn),
+                       desc='current atmospheric temperature', units='degR')
+        self.add_input(
+            Dynamic.Mission.STATIC_PRESSURE,
+            _PSLS_PSF,
+            units="psf",
+            shape=nn,
+            desc="Ambient static pressure")
+
+        self.add_output(
+            "t2",
+            units="degR",
+            shape=nn,
+            desc="Engine inlet total temperature")
+        self.add_output("p2", units="psf", shape=nn, desc="Engine inlet total pressure")

+
+
[docs]    def compute(self, inputs, outputs):
+        mach, T, P = inputs.values()
+
+        gamma = 1.4
+        t2 = T * (1 + 0.5 * (gamma - 1) * mach**2)
+        p2 = P * (t2 / T) ** (gamma / (gamma - 1))
+
+        outputs["t2"] = t2
+        outputs["p2"] = p2

+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Converts FLOPS- or GASP-formatted '
+                                     'engine decks into Aviary csv format.\nFLOPS decks '
+                                     'are changed from column-delimited to csv format '
+                                     'with added headers.\nGASP decks are reorganized '
+                                     'into column based csv. T4 is recovered through '
+                                     'calculation. Data points whose T4 exceeds T4max '
+                                     'are removed.')
+    parser.add_argument('input_file', type=str,
+                        help='path to engine deck file to be converted')
+    parser.add_argument('output_file', type=str,
+                        help='path to file where new converted data will be written')
+    parser.add_argument('data_format', type=EngineDeckType, choices=list(EngineDeckType),
+                        help='data format used by input_file')
+
+    args = parser.parse_args()
+
+    EngineDeckConverter(**vars(args))
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/functions.html b/_modules/aviary/utils/functions.html new file mode 100644 index 000000000..85c70c4ce --- /dev/null +++ b/_modules/aviary/utils/functions.html @@ -0,0 +1,855 @@ + + + + + + + + + + + aviary.utils.functions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.functions

+import numpy as np
+import openmdao.api as om
+from pathlib import Path
+import csv
+import pkg_resources
+import os
+
+from aviary.utils.aviary_values import AviaryValues, get_keys
+from aviary.variable_info.enums import ProblemType, EquationsOfMotion, LegacyCode
+from aviary.variable_info.functions import add_aviary_output, add_aviary_input
+from aviary.variable_info.variable_meta_data import _MetaData
+
+
+
[docs]class Null:
+    '''
+    This can be used to divert outputs, such as stdout, to improve performance
+    '''
+
+
[docs]    def write(self, *args, **kwargs):
+        pass

+
+
[docs]    def flush(self, *args, **kwargs):
+        pass

+
+
+
[docs]def set_aviary_initial_values(model, inputs, meta_data=_MetaData):
+    '''
+    This function sorts through all the input
+    variables to an Aviary model, and for those
+    which are not options it sets the input
+    value to be the value in the inputs, or
+    to be the default if the value is not in the
+    inputs.
+
+    In the case when the value is not input nor
+    present in the default, nothing is set.
+    '''
+    for key in meta_data:
+        if ':' not in key or key.startswith('dynamic:'):
+            continue
+        if not meta_data[key]['option']:
+            if key in inputs:
+                val, units = inputs.get_item(key)
+            else:
+                val = meta_data[key]['default_value']
+                units = meta_data[key]['units']
+
+                if val is None:
+                    # optional, but no default value
+                    continue
+
+            model.set_input_defaults(key, val=val, units=units)

+
+
+
[docs]def apply_all_values(aircraft_values: AviaryValues, prob):
+    for var_name in get_keys(aircraft_values):
+        var_data, var_units = aircraft_values.get_item(var_name)
+        try:
+            prob.set_val(var_name, val=var_data, units=var_units)
+        except KeyError:
+            pass
+    return prob

+
+
+
[docs]def convert_strings_to_data(string_list):
+    # convert_strings_to_data will convert a list of strings to usable data.
+    # Strings that can't be converted to numbers will attempt to store as a logical,
+    # otherwise they are passed as is
+    value_list = [0]*len(string_list)
+    for ii, dat in enumerate(string_list):
+        dat = dat.strip('[]')
+        try:
+            # if the value is a number store it as a float or an int as appropriate
+            # BUG this returns floats that can be converted to int (e.g. 1.0) as an int (1), even if the variable requires floats
+            value_list[ii] = int(float(dat)) if float(
+                dat).is_integer() else float(dat)
+        except ValueError:
+            # store value as a logical if it is a string that represents True or False
+            if dat.lower() == 'true':
+                value_list[ii] = True
+            elif dat.lower() == 'false':
+                value_list[ii] = False
+            else:
+                # if the value isn't a number or a logial, store it as a string
+                value_list[ii] = dat
+        except Exception as e:
+            print('Exception', e)
+    return value_list

+
+
+
[docs]def set_value(var_name, var_value, aviary_values: AviaryValues, units=None, is_array=False, meta_data=_MetaData):
+    if var_name in aviary_values:
+        current_value, current_units = aviary_values.get_item(var_name)
+    else:
+        current_value = meta_data[var_name]['default_value']
+        current_units = meta_data[var_name]['units']
+
+    if units == None:
+        if current_units:
+            units = current_units
+        else:
+            units = meta_data[var_name]['units']
+        #     raise ValueError("You have specified a new variable without any units")
+
+    if is_array:
+        var_value = np.atleast_1d(var_value)
+    elif len(var_value) == 1 and not isinstance(current_value, list):
+        # if only a single value is provided, don't store it as a list
+        var_value = var_value[0]
+
+    # TODO handle enums in an automated method via checking metadata for enum type
+    if var_name == 'problem_type':
+        var_values = ProblemType[var_value]
+    if var_name == 'settings:equations_of_motion':
+        var_values = EquationsOfMotion(var_value)
+    if var_name == 'settings:mass_method':
+        var_values = LegacyCode(var_value)
+
+    aviary_values.set_val(var_name, val=var_value, units=units, meta_data=meta_data)
+    return aviary_values

+
+
+
[docs]def create_opts2vals(all_options: list, output_units: dict = {}):
+    """
+    create_opts2vals creates a component that converts options to outputs.
+
+    Parameters
+    ----------
+    all_options : list of strings
+        Each string is the name of an option in aviary_options.
+    output_units : dict of units, optional
+        This optional input allows the user to specify the units that will be used while
+        adding the outputs. Only the outputs that shouldn't use their default units need
+        to be specified. Each key should match one of the names in all_options, and each
+        value must be a string representing a valid unit in openMDAO.
+
+    Returns
+    -------
+    OptionsToValues : ExplicitComponent
+        An explicit component that takes in an AviaryValues object that contains any
+        options that need to be converted to outputs. There are no inputs to this
+        component, only outputs. If the resulting component is added directly to a
+        Group, the output variables will have the same name as the options they
+        represent. If you need to rename them to prevent conflicting names in the
+        group, running add_opts2vals will add the prefix "option:" to the name.
+    """
+
+    def configure_output(option_name: str, aviary_options: AviaryValues):
+        option_data = aviary_options.get_item(option_name)
+        out_units = output_units[option_name] if option_name in output_units.keys(
+        ) else option_data[1]
+        return {'val': option_data[0], 'units': out_units}
+
+    class OptionsToValues(om.ExplicitComponent):
+        def initialize(self):
+            self.options.declare(
+                'aviary_options', types=AviaryValues,
+                desc='collection of Aircraft/Mission specific options'
+            )
+
+        def setup(self):
+            for option_name in all_options:
+                output_data = configure_output(
+                    option_name, self.options['aviary_options'])
+                add_aviary_output(self, option_name,
+                                  val=output_data['val'], units=output_data['units'])
+
+        def compute(self, inputs, outputs):
+            aviary_options: AviaryValues = self.options['aviary_options']
+            for option_name in all_options:
+                output_data = configure_output(option_name, aviary_options)
+                outputs[option_name] = aviary_options.get_val(
+                    option_name, units=output_data['units'])
+
+    return OptionsToValues

+
+
+
[docs]def add_opts2vals(Group: om.Group, OptionsToValues, aviary_options: AviaryValues):
+    """
+    Add the OptionsToValues component to the specified Group.
+
+    Parameters
+    ----------
+    Group : Group
+        The group or model the component should be added to.
+    OptionsToValues : ExplicitComponent
+        This is the explicit component that was created by create_opts2vals.
+    aviary_options : AviaryValues
+        aviary_options is an AviaryValues object that contains all of the options
+        that need to be converted to outputs.
+
+    Returns
+    -------
+    Opts2Vals : Group
+        A group that wraps the OptionsToValues component in order to rename its
+        variables with a prefix to keep them separate from any similarly named
+        variables in the original group the component is being added to.
+    """
+
+    class Opts2Vals(om.Group):
+        def initialize(self):
+            self.options.declare(
+                'aviary_options', types=AviaryValues,
+                desc='collection of Aircraft/Mission specific options'
+            )
+
+        def setup(self):
+            self.add_subsystem('options_to_values', OptionsToValues(
+                aviary_options=aviary_options))
+
+        def configure(self):
+            all_output_data = self.options_to_values.list_outputs(out_stream=None)
+            list_of_outputs = [(name, 'option:'+name) for name, data in all_output_data]
+            self.promotes('options_to_values', list_of_outputs)
+
+    Group.add_subsystem('opts2vals', Opts2Vals(
+        aviary_options=aviary_options),
+        promotes_outputs=['*'])
+
+    return Group

+
+
+
[docs]def create_printcomp(all_inputs: list, input_units: dict = {}, meta_data=_MetaData):
+    """
+    Creates a component that prints the value of all inputs.
+
+    Parameters
+    ----------
+    all_inputs : list of strings
+        Each string is the name of a variable in the system
+    input_units : dict of units, optional
+        This optional input allows the user to specify the units that will be used while
+        adding the inputs. Only the variables that shouldn't use their default units need
+        to be specified. Each key should match one of the names in all_inputs, and each
+        value must be a string representing a valid unit in openMDAO.
+
+    Returns
+    -------
+    PrintComp : ExplicitComponent
+        An explicit component that can be added to a group to print the current values
+        of connected variables. There are no outputs from this component, only inputs.
+    """
+
+    def get_units(variable_name):
+        if variable_name in input_units.keys():
+            return input_units[variable_name]
+        elif variable_name in meta_data:
+            return meta_data[variable_name]['units']
+        else:
+            return None
+
+    class PrintComp(om.ExplicitComponent):
+
+        def setup(self):
+            for variable_name in all_inputs:
+                units = get_units(variable_name)
+                if ':' in variable_name:
+                    add_aviary_input(self, variable_name, units=units)
+                else:
+                    self.add_input(variable_name, units=units)
+
+        def compute(self, inputs, outputs):
+            print_string = ['v'*20]
+            for variable_name in all_inputs:
+                units = get_units(variable_name)
+                print_string.append('{} {} {}'.format(
+                    variable_name, inputs[variable_name], units))
+            print_string.append('^'*20)
+            print('\n'.join(print_string))
+
+    return PrintComp

+
+
+
[docs]def promote_aircraft_and_mission_vars(group):
+    external_outputs = []
+    for comp in group.system_iter(recurse=False):
+
+        # Skip all aviary systems.
+        if comp.name == 'core_subsystems':
+            continue
+
+        out_names = [item for item in comp._var_allprocs_prom2abs_list['output']]
+        in_names = [item for item in comp._var_allprocs_prom2abs_list['input']]
+
+        external_outputs.extend(out_names)
+
+        # Locally promote aircraft:* and mission:* only.
+        promote_in = []
+        promote_out = []
+
+        for stem in ['mission:', 'aircraft:', 'dynamic:']:
+            for name in out_names:
+                if name.startswith(stem):
+                    promote_out.append(f'{stem}*')
+                    break
+
+            for name in in_names:
+                if name.startswith(stem):
+                    promote_in.append(f'{stem}*')
+                    break
+
+        group.promotes(comp.name, outputs=promote_out, inputs=promote_in)
+
+    return external_outputs

+
+
+
[docs]def get_path(path: [str, Path], verbose: bool = False) -> Path:
+    """
+    Convert a string or Path object to an absolute Path object, prioritizing different locations.
+
+    This function attempts to find the existence of a path in the following order:
+    1. As an absolute path.
+    2. Relative to the current working directory.
+    3. Relative to the Aviary package.
+
+    If the path cannot be found in any of the locations, a FileNotFoundError is raised.
+
+    Parameters
+    ----------
+    path : str or Path
+        The input path, either as a string or a Path object.
+    verbose : bool, optional
+        If True, prints the final path being used. Default is False.
+
+    Returns
+    -------
+    Path
+        The absolute path to the file.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the path is not found in any of the prioritized locations.
+    """
+
+    # Store the original path for reference in error messages.
+    original_path = path
+
+    # If the input is a string, convert it to a Path object.
+    if isinstance(path, str):
+        path = Path(path)
+
+    # Check if the path exists as an absolute path.
+    if not path.exists():
+        # If not, try finding the path relative to the current working directory.
+        path = Path.cwd() / path
+
+    # If the path still doesn't exist, attempt to find it relative to the Aviary package.
+    if not path.exists():
+        # Determine the path relative to the Aviary package.
+        aviary_based_path = Path(
+            pkg_resources.resource_filename('aviary', original_path))
+        if verbose:
+            print(
+                f"Unable to locate '{original_path}' as an absolute or relative path. Trying Aviary package path: {aviary_based_path}")
+        path = aviary_based_path
+
+    # If the path still doesn't exist in any of the prioritized locations, raise an error.
+    if not path.exists():
+        raise FileNotFoundError(
+            f'File not found in absolute path: {original_path}, relative path:{Path.cwd() / path}, or Aviary-based path: {Path(pkg_resources.resource_filename("aviary", original_path))}'
+        )
+
+    # If verbose is True, print the path being used.
+    if verbose:
+        print(f'Using {path} for file.')
+
+    return path

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/merge_hierarchies.html b/_modules/aviary/utils/merge_hierarchies.html new file mode 100644 index 000000000..d05084cd1 --- /dev/null +++ b/_modules/aviary/utils/merge_hierarchies.html @@ -0,0 +1,679 @@ + + + + + + + + + + + aviary.utils.merge_hierarchies + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.merge_hierarchies

+import copy
+
+from aviary.utils.compare_hierarchies import (compare_hierarchies_to_merge,
+                                              compare_inner_classes)
+
+
+
[docs]def merge_attributes(base_class, merge_class, base_class_attributes, merge_class_attributes):
+    '''
+    Adds unique attributes of merge_class to base_class.
+
+    For all the attributes of merge_class that are not present in base_class we add them to base_class.
+    Attributes present in both classes are ignored because if they are variables they have already
+    been checked and found identical and if they are inner classes they will be addressed on a 
+    recursive call to this function. Attributes present only in base_class are ignored because we are
+    adding to base_class and thus all of its features are automatically preserved.
+
+    Parameters
+    ----------
+    base_class : class
+        A class that is all or part of a variable hierarchy. This can be the top=level
+        class in the hierarchy, or any inner class nested at any depth within that top-level class.
+
+    merge_class : class
+        A class that is all or part of a variable hierarchy. This can be the top=level
+        class in the hierarchy, or any inner class nested at any depth within that top-level class.
+
+    base_class_attributes : set of strings
+        A set of the name of all attributes (either variables, inner classes, or both) of base_class.
+
+    merge_class_attributes : set of strings
+        A set of the name of all attributes (either variables, inner classes, or both) of merge_class.
+
+    Returns
+    -------
+    base_class : class
+        A class that contains the merged together attributes of base_class and merge_class, with 
+        the exception that inner class base_class and merge_class share which have diverging attributes inside 
+        of them are not necessarily included.
+
+    Raises
+    ------
+    None
+        No exceptions raised by this method, although other methods called within may raise exceptions.
+    '''
+
+    merge_class_unique = merge_class_attributes - \
+        base_class_attributes  # attributes present only in merge_class
+
+    for attr in merge_class_unique:
+        setattr(base_class, attr, getattr(merge_class, attr))
+
+    return base_class

+
+
+
[docs]def recursive_merge(overlapping_inners, base_class, merge_class):
+    '''
+    Recursively compares all inner classes to an infinite depth and identifies mismatched string-named values.
+
+    For all of the inner class names provided in overlapping_inner_classes this function calls compare_inner_classes
+    and compares those inner classes recursively until it reaches the full depth to which outer_class_a and
+    outer_class_b have any inner classes in common.
+
+    Parameters
+    ----------
+    overlapping_inner_classes : set of strings
+        This is a set of strings where each string is the name of an inner class that outer_class_a
+        and outer_class_b have in common.
+
+    outer_class_a : class
+        A class that is all or part of a variable hierarchy. This can be the top-level class in the 
+        hierarchy, or any inner class nested at any depth within that top-level class.
+
+    outer_class_b : class
+        A class that is all or part of a variable hierarchy. This can be the top-level class in the 
+        hierarchy, or any inner class nested at any depth within that top-level class.
+
+    Returns
+    ------- 
+    None
+        No variables returned by this method.
+
+    Raises
+    ----------
+    None
+        No exceptions raised by this method, although other methods called within may raise exceptions.
+    '''
+
+    for overlapping_class_name in overlapping_inners:
+        overlapping_inner_class_base = getattr(base_class, overlapping_class_name)
+        overlapping_inner_class_merge = getattr(merge_class, overlapping_class_name)
+        [overlapping_second_inners, vars_base_inner, vars_merge_inner, inners_base_inner, inners_merge_inner] = compare_inner_classes(
+            overlapping_inner_class_base, overlapping_inner_class_merge, show_all=True)
+        merge_attributes(overlapping_inner_class_base,
+                         overlapping_inner_class_merge, vars_base_inner, vars_merge_inner)
+        merge_attributes(overlapping_inner_class_base,
+                         overlapping_inner_class_merge, inners_base_inner, inners_merge_inner)
+        recursive_merge(overlapping_second_inners,
+                        overlapping_inner_class_base, overlapping_inner_class_merge)

+
+
+
[docs]def merge_two_hierarchies(base_hierarchy, hierarchy_b):
+    '''
+    Merge two variable hierarchies together by adding the second into the first.
+
+    Add the attributes (variables and inner classes) of two variable hierarchies together, so that
+    the attributes that are unique to each hierarchy are combined in the resultant hierarchy. This
+    is accomplished by adding on to the first of the two provided hierarchies, and returning it.
+
+    Parameters
+    ----------
+    base_hierarchy : class
+        An Aviary variable hierarchy. This hierarchy will function as the 'base' hierarchy,
+        which is the hierarchy that has attributes added onto it from another hierarchy in order to combine
+        the attributes of the base and the other hierarchy.
+
+    hierarchy_b : class
+        An Aviary variable hierarchy. This hierarchy will function as the 'auxiliary' hierarhcy,
+        which is the hierarchy whose unique attributes are added onto a base in order to combine the 
+        attributes of the base and the auxiliary.
+
+    Returns
+    -------
+    base_hierarchy : class
+        An Aviary variable hierarchy which includes both the attributes of the inputted base_hierarchy
+        and hierarchy_b. This is the same object as the inputted base_hierarchy and has been updated through 
+        mutability.
+
+    Raises
+    ----------
+    None
+        No exceptions raised by this method, although other methods called within may raise exceptions.
+    '''
+    [overlapping_inners, merged_vars, b_vars, merged_inners, b_inners] = compare_inner_classes(
+        base_hierarchy, hierarchy_b, show_all=True)
+    # this adds the variables of hierarchy_b which are not in base_hierarchy to the overall merged hierarchy
+    base_hierarchy = merge_attributes(
+        base_hierarchy, hierarchy_b, merged_vars, b_vars)
+    # this adds the inner classes of hierarchy_b which are not in base_hierarchy to the overall merged hierarchy
+    base_hierarchy = merge_attributes(
+        base_hierarchy, hierarchy_b, merged_inners, b_inners)
+    recursive_merge(overlapping_inners, base_hierarchy, hierarchy_b)
+
+    return base_hierarchy

+
+
+
[docs]def merge_hierarchies(hierarchies_to_merge):
+    '''
+    Combines all provided variable hierarchies into one unified variable hierarchy.
+
+    Performs checks on the user-provided list of variable hierarchies in order to ensure that they are 
+    compatible for merge. Ensures that they are not derived from different superclasses, and that they do
+    not have conflicting values. Assuming all checks pass, the provided hierarchies are combined into a
+    single hierarchy.
+
+    Parameters
+    ----------
+    hierarchies_to_merge : list of classes
+        This is a list of all the variable hierarchies which should be merged into a single hierarchy. This list should not include hierarchies of multiple types (i.e. an av.Mission hierarchy extension should not be mixed with an av.Aircraft hierarchy extension)
+
+    Returns
+    -------
+    merged_hierarchy : class
+        Aviary variable hierarchy that includes all the variables present in the inputted hierarchy list. Duplicates have been removed, and conflicting duplicates are not possible.
+
+    Raises
+    ------
+    ValueError
+        Raises an exception if the list of inputted variable hierarchies includes hierarchies that have been subclassed from different superclasses.
+    '''
+    compare_hierarchies_to_merge(hierarchies_to_merge)
+    subclass_type = None
+    subclass_hierarchy = None
+    for hierarchy in hierarchies_to_merge:  # check that there are not hierarchies subclassing from different classes that we are attempting to merge
+        # checks if the given hierarchy is the first subclass of the hierarchies
+        if (len(hierarchy.__mro__) > 2) and (subclass_type == None):
+            # gets highest level superclass of the class before "class" itself
+            subclass_type = copy.deepcopy(hierarchy.__mro__[-2])
+            subclass_hierarchy = copy.deepcopy(hierarchy)
+        elif (len(hierarchy.__mro__) > 2):  # checks if the given hierarchy is a subclass
+            if hierarchy.__mro__[-2] != subclass_type:
+                raise ValueError(
+                    f"You have attempted to merge together variable hierarchies that subclass from different superclasses. '{subclass_hierarchy.__qualname__}' is a subclass of '{subclass_type}' and '{hierarchy.__qualname__}' is a subclass of '{hierarchy.__mro__[-2]}'.")
+
+    if subclass_hierarchy != None:  # ensure that we build on the subclassed hierarchy if we have one, that way the super class information is not lost
+        merged_hierarchy = subclass_hierarchy
+    else:
+        merged_hierarchy = copy.deepcopy(hierarchies_to_merge[0])
+
+    for hierarchy in hierarchies_to_merge:
+        merged_hierarchy = merge_two_hierarchies(merged_hierarchy, hierarchy)
+
+    return merged_hierarchy

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/merge_variable_metadata.html b/_modules/aviary/utils/merge_variable_metadata.html new file mode 100644 index 000000000..67c269290 --- /dev/null +++ b/_modules/aviary/utils/merge_variable_metadata.html @@ -0,0 +1,595 @@ + + + + + + + + + + + aviary.utils.merge_variable_metadata + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.merge_variable_metadata

+import numpy as np
+
+
+
[docs]def almost_equal(a, b, rel_tol=1e-8, abs_tol=0.0):
+    if isinstance(a, (float, np.float32, np.float64)) and isinstance(b, (float, np.float32, np.float64)):
+        return np.isclose(a, b, rtol=rel_tol, atol=abs_tol)
+
+    if isinstance(a, np.ndarray) and isinstance(b, np.ndarray):
+        return np.allclose(a, b, rtol=rel_tol, atol=abs_tol)
+
+    if isinstance(a, dict) and isinstance(b, dict):
+        if a.keys() != b.keys():
+            return False
+        for key in a.keys():
+            if not almost_equal(a[key], b[key]):
+                return False
+        return True
+
+    return a == b

+
+
+
[docs]def merge_2_meta_data_dicts(dict1, dict2):
+    '''
+    Combines metadata from two dictionaries into a single dictionary containing metadata of both.
+
+    Performs a check to ensure that the two dictionaries don't have the same variable with conflicting
+    metadata. Assuming that check passes, the variables and their associated metadata from both
+    dictionaries are combined into one dictionary.
+
+    Parameters
+    ----------
+    dict1, dict2 : dict
+        Dictionaries with keys of Aviary variables and values of their associated metadata.
+
+    Returns
+    -------
+    new_dict : dict
+        Single dictionary with all the combined entries from the two input Aviary metadata dictionaries.
+
+    Raises
+    ------
+    ValueError
+        Raises error if dict1 and dict2 have differing metadata for the same variable.
+    '''
+
+    dict1_keys = set(dict1.keys())  # get keys of provided dictionaries
+    dict2_keys = set(dict2.keys())  # get keys of provided dictionaries
+    # get keys that are unique to each dictionary
+    all_unique_keys = (dict1_keys | dict2_keys) - (dict1_keys & dict2_keys)
+    # get all keys that are repeated in both dictionaries
+    all_duplicate_keys = dict1_keys & dict2_keys
+    # merge the two dictionaries, and allow the repeated keys to be overwritten
+    merged = {**dict1, **dict2}
+
+    dict_of_unique_variables = dict(
+        # get a dictionary of all the unique keys (and their values) from the input dictionaries
+        map(lambda key: (key, merged.get(key, None)), all_unique_keys))
+
+    # initialize a dictionary of the values with duplicated keys in both input dictionaries
+    dict_of_duplicate_variables = {}
+
+    for key in sorted(all_duplicate_keys):
+        # check that the metadata in both dictionaries associated with the same key is the same
+        value1, value2 = dict1[key], dict2[key]
+        # throw an error if the dicts have the same key with different metadata
+        if not almost_equal(value1, value2):
+            raise ValueError(
+                f'You have attempted to merge metadata dictionaries that contain the same variable with different metadata. The offending variable present in multiple dictionaries is "{key}".')
+
+        # add the key and metadata to the dictionary of duplicate variables
+        dict_of_duplicate_variables[key] = dict1[key]
+
+    # merge together the final dictionary
+    new_dict = {**dict_of_duplicate_variables, **dict_of_unique_variables}
+
+    return new_dict

+
+
+
[docs]def merge_meta_data(dicts_to_merge):
+    '''
+    Merges the metadata of multiple Aviary metadata dictionaries into a single metadata dictionary.
+
+    Checks the metadata of all the provided Aviary metadata dictionaries to see if there are identical
+    variables with conflicting metadata. Assuming this check passes, the input dictionaries are merged
+    together into a single dictionary containing all their information.
+
+    Parameters
+    ----------
+    dicts_to_merge : list of dicts
+        List of Aviary metadata dictionaries to be merged.
+
+    Returns
+    -------
+    merged_dict : dict
+        Single Aviary metadata dictionary with all the information of the inputted metadata dictionaries.
+
+    Raises
+    ------
+    None
+        No exceptions raised by this method, although other methods called within may raise exceptions.
+    '''
+    merged_dict = dicts_to_merge[0]
+
+    # iterate through all the dictionaries and merge them together into one, two by two
+    for dict_item in dicts_to_merge:
+        merged_dict = merge_2_meta_data_dicts(merged_dict, dict_item)
+
+    return merged_dict

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/named_values.html b/_modules/aviary/utils/named_values.html new file mode 100644 index 000000000..cee0c8652 --- /dev/null +++ b/_modules/aviary/utils/named_values.html @@ -0,0 +1,826 @@ + + + + + + + + + + + aviary.utils.named_values + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.named_values

+'''
+Define utilities for using named values with associated units.
+
+Utilities
+---------
+Units : type alias
+    define a type hint for associated units
+
+ValueAndUnits : type alias
+    define a type hint for a single value paired with its associated units
+
+OptionalValueAndUnits : type alias
+    define a type hint for an optional single value paired with its associated units
+
+class NamedValues
+    define a collection of named values with associated units
+'''
+import copy
+from collections.abc import Collection
+from typing import Any, Tuple, Union
+
+from openmdao.core.constants import _UNDEFINED
+from openmdao.utils.units import convert_units as _convert_units
+
+Units = str
+ValueAndUnits = Tuple[Any, Units]
+OptionalValueAndUnits = Union[ValueAndUnits, Any]
+
+
+
[docs]class NamedValues(Collection):
+    '''
+    Define a collection of named values with associated units.
+    '''
+
+
[docs]    def __init__(self, other=None, **kwargs):
+        '''
+        Initialize this collection.
+
+        Notes
+        -----
+        When intializing from another collection, the following types of
+        collections are supported:
+
+            * `NamedValues`
+            * `Dict[str, ValueAndUnits]`
+            * `Iterable[Tuple[str, ValueAndUnits]]`
+
+        When initializing from keyword arguments, the mapped item must be of a
+        type of `ValueAndUnits`.
+        '''
+        self._mapping = {}
+
+        self.update(other, **kwargs)

+
+
[docs]    def get_item(self, key, default=(None, None)) -> OptionalValueAndUnits:
+        '''
+        Return the named value and its associated units.
+
+        Note, this method never raises `KeyError` or `TypeError`.
+
+        Parameters
+        ----------
+        key : str
+            the name of the item
+
+        default : OptionalValueAndUnits (None, None)
+            if the item does not exist, return this object
+
+        Returns
+        -------
+        OptionalValueAndUnits
+
+        See Also
+        --------
+        get_val
+        set_val
+        '''
+        item = self._mapping.get(key, _UNDEFINED)
+
+        if item is _UNDEFINED:
+            return default
+
+        return item

+
+
[docs]    def copy(self):
+        '''
+        Return a copy of the instance of this class.
+
+        Parameters
+        ---------
+        None
+
+        Returns
+        -------
+        NamedValues()
+        '''
+        return copy.copy(self)

+
+
[docs]    def deepcopy(self):
+        '''
+        Return a deep copy of the instance of this class.
+
+        Parameters
+        ---------
+        None
+
+        Returns
+        -------
+        NamedValues()
+        '''
+        return copy.deepcopy(self)

+
+
[docs]    def get_val(self, key, units='unitless') -> Any:
+        '''
+        Return the named value in the specified units.
+
+        Note, requesting a named value that does not exist will raise `KeyError`.
+
+        Note, specifying units of `None` or units of any type other than `str` will raise
+        `TypeError`.
+
+        Parameters
+        ----------
+        key : str
+            the name of the item
+
+        units : str ('unitless')
+            the units of the returned value
+
+        Returns
+        -------
+        val
+
+        Raises
+        ------
+        KeyError
+            if the named value does not exist
+
+        TypeError
+            if units of `None` were specified or units of any type other than `str`
+        '''
+        self._check_units('get_val', key, units)
+
+        item = self._mapping.get(key, _UNDEFINED)
+
+        if item is _UNDEFINED:
+            raise KeyError(f'KeyError: key not found: {key}')
+
+        val, old_units = item
+
+        if isinstance(val, tuple):
+            val = tuple(_convert_units(v, old_units, units) for v in val)
+        elif old_units != units:
+            val = _convert_units(val, old_units, units)
+
+        return val

+
+
[docs]    def set_val(self, key, val, units='unitless'):
+        '''
+        Update the named value and its associated units.
+
+        Note, specifying units of `None` or units of any type other than `str` will raise
+        `Typerror`.
+
+        Parameters
+        ----------
+        key : str
+            the name of the item
+
+        val : Any
+            the new value of the item
+
+        units : str ('unitless')
+            the units associated with the new value, if any
+
+        Raises
+        ------
+        TypeError
+            if units of `None` were specified or units of any type other than `str`
+        '''
+        self._check_units('set_val', key, units)
+
+        self._mapping[key] = (val, units)

+
+    def __repr__(self):
+        '''
+        Return a string containing a printable representation of the collection.
+        '''
+        return repr(self._mapping)
+
+
[docs]    def clear(self):
+        '''
+        Remove all items from the collection.
+        '''
+        self._mapping.clear()

+
+
[docs]    def update(self, other=None, **kwargs):
+        '''
+        Assign named values and their associated units found in another
+        collection to this collection, overwriting existing items.
+
+        If keyword arguments are specified, the collection is then assigned those
+        named values and their associated units, overwriting existing items.
+
+        Parameters
+        ----------
+        other (None)
+            a collection of named values and their associated units
+
+        **kwargs (optional)
+            individual named values and their associated units
+
+        Notes
+        -----
+        The following types of collections are supported
+            * `NamedValues`
+            * `Dict[str, ValueAndUnits]`
+            * `Iterable[Tuple[str, ValueAndUnits]]`
+
+        When assigning from keyword arguments, the mapped item must be of a
+        type of `ValueAndUnits`.
+        '''
+        if not (other or kwargs):
+            return
+
+        set_val = self.set_val
+
+        if isinstance(other, type(self)):
+            # NamedValues
+            other = other._mapping
+
+        if other is not None:
+            # check for dictionary
+            keys = getattr(other, 'keys', None)
+
+            if keys is None:
+                # iterable, but not dictionary
+                for key, (val, units) in other:
+                    set_val(key, val, units)
+
+            else:
+                # dictionary
+                for key in keys():
+                    val, units = other[key]
+                    set_val(key, val, units)
+
+        for key, (val, units) in kwargs.items():
+            set_val(key, val, units)

+
+
[docs]    def delete(self, key):
+        '''
+        Remove the named value and its associated units.
+
+        Raises
+        ------
+        KeyError
+            if the named value does not exist
+        '''
+        try:
+            del self._mapping[key]
+
+        except KeyError:
+            raise KeyError(f'KeyError: key not found: {key}')

+
+    def __eq__(self, other):
+        '''
+        Return whether or not this collection is equivalent to another.
+        '''
+        collection = self._mapping
+
+        if isinstance(other, type(self)):
+            return collection == other._mapping
+
+        return collection == other
+
+
[docs]    def __contains__(self, key):
+        '''
+        Return whether or not the named value exists.
+        '''
+        return key in self._mapping

+
+
[docs]    def __iter__(self):
+        '''
+        Return an iterator over the `(key, (val, units))` data stored in this collection.
+        '''
+        items = self._mapping.items()
+
+        yield from items

+
+    def __len__(self):
+        '''
+        Return the number of items in this collection.
+        '''
+        return len(self._mapping)
+
+    def _check_units(self, funcname, key, units):
+        '''
+        If units of `None` were specified or units of any type other than `str`, raise
+        `TypeError`. Otherwise, do nothing.
+
+        Parameters
+        ----------
+        funcname : str
+            the name of a method/function
+
+        key : str
+            the name of the item
+
+        units : Any
+            the units to check
+        '''
+        if ((units is None) or not isinstance(units, str)):
+            raise TypeError(
+                f'{self.__class__.__name__}: {funcname}({key}):'
+                f' unsupported units: {units}'
+            )
+
+    __slots__ = ('_mapping',)

+
+
+
[docs]def get_keys(named_values: NamedValues):
+    '''
+    Return a new view of the collection's names.
+    '''
+    return named_values._mapping.keys()

+
+
+
[docs]def get_items(named_values: NamedValues):
+    '''
+    Return a new view of the collection's `(key, (val, units))`.
+    '''
+    return named_values._mapping.items()

+
+
+
[docs]def get_values(named_values: NamedValues):
+    '''
+    Return a new view of the collection's `(val, units)`.
+    '''
+    return named_values._mapping.values()

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/options.html b/_modules/aviary/utils/options.html new file mode 100644 index 000000000..b6a031afa --- /dev/null +++ b/_modules/aviary/utils/options.html @@ -0,0 +1,529 @@ + + + + + + + + + + + aviary.utils.options + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.options

+from openmdao.core.system import System
+
+from aviary.utils.aviary_values import AviaryValues, get_keys
+
+
+
[docs]def list_options(model: System, aviary_keys: list = None):
+    """
+    Lists all option values in the provided model. All top-level option values will
+    be listed, and items in model.options['aviary_options'] will also be listed.
+    A list of keys may be provided to limit the list of items in aviary_options.
+
+    Parameters
+    ----------
+    model : System
+        A model.
+    aviary_keys: iter of str
+        List of aviary_options keys whose values will be looked up and
+        listed in the options printout. If None, all items in
+        model.options['aviary_options'] will be listed.
+    """
+    print('\nOptions:\n')
+    for subsystem in model.system_iter():
+        if subsystem.name == '_auto_ivc':
+            continue
+        print(subsystem.name)
+        for (key, obj) in subsystem.options.items():
+            if isinstance(obj, AviaryValues):
+                aviary_options = obj
+                print('  aviary_options:')
+                if isinstance(aviary_keys, list):
+                    keys = aviary_keys
+                else:
+                    keys = get_keys(aviary_options)
+                for key in keys:
+                    (val, units) = aviary_options.get_item(key)
+                    if units == 'unitless':
+                        print(f'    {key} = {val}')
+                    else:
+                        print(f'    {key} = {val} {units}')
+            else:
+                print(f'  {key} = {str(obj)[0:80]}')
+    print()

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/preprocessors.html b/_modules/aviary/utils/preprocessors.html new file mode 100644 index 000000000..1218dd71f --- /dev/null +++ b/_modules/aviary/utils/preprocessors.html @@ -0,0 +1,816 @@ + + + + + + + + + + + aviary.utils.preprocessors + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.preprocessors

+import numpy as np
+import math
+import openmdao.api as om
+
+from aviary.subsystems.propulsion.engine_deck import EngineDeck
+from aviary.utils.aviary_values import AviaryValues
+from aviary.utils.named_values import get_keys
+from aviary.variable_info.variable_meta_data import _MetaData
+from aviary.variable_info.variables import Aircraft, Mission
+
+
+
[docs]def preprocess_options(aviary_options: AviaryValues):
+    """
+    Run all preprocessors on provided AviaryValues object
+
+    Parameters
+    ----------
+    aviary_options : AviaryValues
+        Options to be updated
+    """
+    preprocess_crewpayload(aviary_options)
+    try:
+        engine_models = aviary_options.get_val('engine_models')
+    except KeyError:
+        preprocess_propulsion(aviary_options)
+    else:
+        # don't catch stray exceptions in preprocess_propulsion
+        preprocess_propulsion(aviary_options, engine_models)

+
+
+
[docs]def preprocess_crewpayload(aviary_options: AviaryValues):
+    """
+    Calculates option values that are derived from other options, and are not direct inputs.
+    This function modifies the entries in the supplied collection, and for convenience also
+    returns the modified collection.
+    """
+
+    if Aircraft.CrewPayload.NUM_PASSENGERS not in aviary_options:
+        passenger_count = 0
+        for key in (Aircraft.CrewPayload.NUM_FIRST_CLASS,
+                    Aircraft.CrewPayload.NUM_BUSINESS_CLASS,
+                    Aircraft.CrewPayload.NUM_TOURIST_CLASS):
+            if key in aviary_options:
+                passenger_count += aviary_options.get_val(key)
+        if passenger_count == 0:
+            passenger_count = 1
+
+        aviary_options.set_val(
+            Aircraft.CrewPayload.NUM_PASSENGERS, passenger_count)
+    else:
+        passenger_count = aviary_options.get_val(
+            Aircraft.CrewPayload.NUM_PASSENGERS)
+        # check in here to ensure that in this case passenger count is the sum of the first class, business class, and tourist class counts.
+        passenger_check = aviary_options.get_val(Aircraft.CrewPayload.NUM_FIRST_CLASS)
+        passenger_check += aviary_options.get_val(
+            Aircraft.CrewPayload.NUM_BUSINESS_CLASS)
+        passenger_check += aviary_options.get_val(Aircraft.CrewPayload.NUM_TOURIST_CLASS)
+        # if passenger_count != passenger_check:
+        # raise om.AnalysisError(
+        #     "ERROR: In preprocesssors.py: passenger_count does not equal the sum of firt class + business class + tourist class passengers.")
+
+    if Aircraft.CrewPayload.NUM_FLIGHT_ATTENDANTS not in aviary_options:
+        flight_attendants_count = 0  # assume no passengers
+
+        if 0 < passenger_count:
+            if passenger_count < 51:
+                flight_attendants_count = 1
+
+            else:
+                flight_attendants_count = passenger_count // 40 + 1
+
+        aviary_options.set_val(
+            Aircraft.CrewPayload.NUM_FLIGHT_ATTENDANTS, flight_attendants_count)
+
+    if Aircraft.CrewPayload.NUM_GALLEY_CREW not in aviary_options:
+        galley_crew_count = 0  # assume no passengers
+
+        if 150 < passenger_count:
+            galley_crew_count = passenger_count // 250 + 1
+
+        aviary_options.set_val(Aircraft.CrewPayload.NUM_GALLEY_CREW, galley_crew_count)
+
+    if Aircraft.CrewPayload.NUM_FLIGHT_CREW not in aviary_options:
+        flight_crew_count = 3
+
+        if passenger_count < 151:
+            flight_crew_count = 2
+
+        aviary_options.set_val(Aircraft.CrewPayload.NUM_FLIGHT_CREW, flight_crew_count)
+
+    if (Aircraft.CrewPayload.BAGGAGE_MASS_PER_PASSENGER not in aviary_options and
+            Mission.Design.RANGE in aviary_options):
+        design_range = aviary_options.get_val(Mission.Design.RANGE, 'nmi')
+
+        if design_range <= 900.0:
+            baggage_mass_per_pax = 35.0
+        elif design_range <= 2900.0:
+            baggage_mass_per_pax = 40.0
+        else:
+            baggage_mass_per_pax = 44.0
+
+        aviary_options.set_val(Aircraft.CrewPayload.BAGGAGE_MASS_PER_PASSENGER,
+                               val=baggage_mass_per_pax, units='lbm')
+
+    return aviary_options

+
+
+
[docs]def preprocess_propulsion(aviary_options: AviaryValues, engine_models: list = None):
+    '''
+    Updates AviaryValues object with values taken from provided EngineModels.
+
+    If no EngineModels are provided, either in engine_models or included in
+    aviary_options, an EngineDeck is created using avaliable inputs and options in
+    aviary_options.
+
+    Vectorizes variables in aviary_options in the correct order for multi-engine
+    vehicles.
+
+    Performs basic sanity checks on inputs that are universal to all EngineModels.
+
+    !!! WARNING !!!
+    Values in aviary_options are overwritten with corresponding values in engine_models!
+
+    Parameters
+    ----------
+    aviary_options : AviaryValues
+        Options to be updated. EngineModels (provided or generated) are added, and
+        Aircraft:Engine:* and Aircraft:Nacelle:* variables are vectorized as numpy arrays
+
+    engine_models : <list of EngineModels> (optional)
+        EngineModel objects to be added to aviary_options. Replaced existing EngineModels
+        in aviary_options
+    '''
+    ########################
+    # Create Engine Models #
+    ########################
+    # Check if EngineModels are provided, either as an argument or in aviary_options
+    # Build new engines if no engine models provided by the user in any capacity, such as
+    # from an input deck
+    build_engines = False
+    if not engine_models:
+        try:
+            engine_models = aviary_options.get_val('engine_models')
+        except KeyError:
+            build_engines = True
+    else:
+        # Add engine models to aviary options for component access
+        # TODO this overwrites any engine models already in aviary_options without
+        #      warning - should they get combined into the engine_models list instead?
+        aviary_options.set_val('engine_models', engine_models)
+
+    # If engine models are not provided, build a single engine deck, ignore vectorization
+    # of AviaryValues (use first index)
+    # TODO build test to verify this works as expected
+    if build_engines:
+        engine_options = AviaryValues()
+        for entry in Aircraft.Engine.__dict__:
+            var = getattr(Aircraft.Engine, entry)
+            # check if this variable exist with useable metadata
+            try:
+                units = _MetaData[var]['units']
+                try:
+                    # add value from aviary_options to engine_options
+                    default_val = aviary_options.get_val(var, units)
+                    if type(default_val) in (list, np.ndarray):
+                        default_val = default_val[0]
+                    engine_options.set_val(default_val)
+                # if not, use default value from _MetaData
+                except KeyError:
+                    engine_options.set_val(_MetaData[var]['default_value'], units)
+            except KeyError:
+                continue
+
+        engine_deck = EngineDeck(engine_options)
+        engine_models = [engine_deck]
+
+    count = len(engine_models)
+    # keys of originally provided aviary_options
+    # currently not used but might be useful in the future
+    # aviary_mapping = get_keys(aviary_options.deepcopy())
+
+    ##############################
+    # Vectorize Engine Variables #
+    ##############################
+    # Only vectorize variables user has defined in some way or engine has calculated
+    # Combine aviary_options and all engine options into single AviaryValues
+    # It is assumed that all EngineModels are up-to-date at this point and will NOT
+    # be changed in the future (otherwise preprocess_propulsion must be run again)
+    complete_options_list = AviaryValues(aviary_options)
+    for engine in engine_models:
+        complete_options_list.update(engine.options)
+
+    # update_list has keys of all variables that are already defined, and must
+    # be vectorized
+    update_list = list(get_keys(complete_options_list))
+
+    # Vectorize engine variables. Only update variables in update_list that are relevant
+    # to engines (defined by _get_engine_variables())
+    for var in _get_engine_variables():
+        if var in update_list:
+            dtype = _MetaData[var]['types']
+            default_value = _MetaData[var]['default_value']
+            # if default_value is in an array, pull out first index as default
+            if type(default_value) in (list, np.ndarray, tuple):
+                default_value = default_value[0]
+            # if dtype has multiple options, use type of default value
+            if type(dtype) in (list, tuple):
+                dtype = type(default_value)
+            units = _MetaData[var]['units']
+            vec = [default_value] * count
+
+            # TODO is priority order consistent with expected behavior for overriding?
+            #      EngineModel.options overwrite aviary_options, which overwrite defaults
+            for i, engine in enumerate(engine_models):
+                # test to see if engine has this variable - if so, use it
+                try:
+                    engine_val = engine.get_val(var, units)
+                    vec[i] = engine_val
+                # if the variable is not in the engine model, pull from aviary options
+                except KeyError:
+                    # check if variable is defined in aviary options (for this engine's
+                    # index) - if so, use it
+                    try:
+                        aviary_val = aviary_options.get_val(var, units)
+                        if type(aviary_val) in (list, np.ndarray, tuple):
+                            aviary_val = aviary_val[i]
+                        vec[i] = aviary_val
+                    # if not, use default value from _MetaData (already in array)
+                    except (KeyError, IndexError):
+                        continue
+                # TODO update each engine's options with "new" values? Allows each engine
+                #      to have a copy of all options/inputs, beyond what it was
+                #      originally initialized with
+            # update aviary options and outputs with new vectors
+            # if data is numerical, store in a numpy array
+            if type(vec[0]) in (int, float, np.int64, np.float64):
+                vec = np.array(vec, dtype=dtype)
+            aviary_options.set_val(var, vec, units)
+
+    ###################################
+    # Input/Option Consistency Checks #
+    ###################################
+    # Make sure number of engines based on mount location match expected total
+    try:
+        num_engines_all = aviary_options.get_val(Aircraft.Engine.NUM_ENGINES)
+    except KeyError:
+        num_engines_all = np.zeros(count).astype(int)
+    try:
+        num_fuse_engines_all = aviary_options.get_val(
+            Aircraft.Engine.NUM_FUSELAGE_ENGINES)
+    except KeyError:
+        num_fuse_engines_all = np.zeros(count).astype(int)
+    try:
+        num_wing_engines_all = aviary_options.get_val(Aircraft.Engine.NUM_WING_ENGINES)
+    except KeyError:
+        num_wing_engines_all = np.zeros(count).astype(int)
+
+    for i, engine in enumerate(engine_models):
+        num_engines = num_engines_all[i]
+        num_fuse_engines = num_fuse_engines_all[i]
+        num_wing_engines = num_wing_engines_all[i]
+        total_engines_calc = num_fuse_engines + num_wing_engines
+
+        # if engine mount type is not specified at all, default to wing
+        if total_engines_calc == 0:
+            eng_name = engine.name
+            num_wing_engines_all[i] = num_engines
+            # TODO is a warning overkill here? It can be documented wing mounted engines
+            # are assumed default
+            UserWarning(
+                f'Mount location for engines of type <{eng_name}> not specified. '
+                'Wing-mounted engines are assumed.')
+
+        # If wing mount type are specified but inconsistent, default num_engines to sum
+        # of specified mounted engines
+        elif total_engines_calc != num_engines:
+            eng_name = engine.name
+            num_engines_all[i] = total_engines_calc
+            UserWarning(
+                'Sum of aircraft:engine:num_fueslage_engines and '
+                'aircraft:engine:num_wing_engines do not match '
+                f'aircraft:engine:num_engines for EngineModel <{eng_name}>. Overwriting '
+                'with the sum of wing and fuselage mounted engines.')
+
+    aviary_options.set_val(Aircraft.Engine.NUM_ENGINES, num_engines_all)
+    aviary_options.set_val(Aircraft.Engine.NUM_WING_ENGINES, num_wing_engines_all)
+    aviary_options.set_val(Aircraft.Engine.NUM_FUSELAGE_ENGINES, num_fuse_engines_all)
+
+    num_engines = aviary_options.get_val(Aircraft.Engine.NUM_ENGINES)
+    total_num_engines = int(sum(num_engines_all))
+    total_num_fuse_engines = int(sum(num_fuse_engines_all))
+    total_num_wing_engines = int(sum(num_wing_engines_all))
+
+    # compute propulsion-level engine count totals here
+    aviary_options.set_val(
+        Aircraft.Propulsion.TOTAL_NUM_ENGINES, total_num_engines)
+    aviary_options.set_val(
+        Aircraft.Propulsion.TOTAL_NUM_FUSELAGE_ENGINES, total_num_fuse_engines)
+    aviary_options.set_val(
+        Aircraft.Propulsion.TOTAL_NUM_WING_ENGINES, total_num_wing_engines)

+
+
+def _get_engine_variables():
+    '''
+    Yields all propulsion-related variables in Aircraft that need to be vectorized
+    '''
+    for entry in Aircraft.Engine.__dict__:
+        var = getattr(Aircraft.Engine, entry)
+        # does this variable exist, and have useable metadata?
+        try:
+            _MetaData[var]
+        except (TypeError, KeyError):
+            continue
+        # valid variable found, proceed
+        else:
+            yield var
+
+    for entry in Aircraft.Nacelle.__dict__:
+        var = getattr(Aircraft.Nacelle, entry)
+        # does this variable exist, and have useable metadata?
+        try:
+            _MetaData[var]
+        except (TypeError, KeyError):
+            continue
+        # valid variable found, proceed
+        else:
+            # don't vectorize aircraft-level total values
+            if 'total' not in var:
+                yield var
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/process_input_decks.html b/_modules/aviary/utils/process_input_decks.html new file mode 100644 index 000000000..d7fddd923 --- /dev/null +++ b/_modules/aviary/utils/process_input_decks.html @@ -0,0 +1,862 @@ + + + + + + + + + + + aviary.utils.process_input_decks + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.process_input_decks

+"""
+This module, process_input_decks.py, is responsible for reading vehicle input decks, initializing options, 
+and setting initial guesses for aircraft design parameters. It works primarily with .csv files,
+allowing for the specification of units, comments, and lists within these files. 
+
+The module supports various functions like creating a vehicle, parsing input files, updating options based
+on inputs, and handling initial guesses for different aircraft design aspects. It heavily relies on the 
+aviary and openMDAO libraries for processing and interpreting the aircraft design parameters.
+
+Functions:
+    create_vehicle(vehicle_deck=''): Create and initialize a vehicle with default or specified parameters.
+    parse_inputs(vehicle_deck, aircraft_values): Parse input files and update aircraft values and initial guesses.
+    update_options(aircraft_values, initial_guesses): Update dependent options based on current aircraft values.
+    update_dependent_options(aircraft_values, dependent_options): Update options that depend on the value of an input variable.
+    initial_guessing(aircraft_values): Set initial guesses for aircraft parameters based on problem type and other factors.
+"""
+
+import warnings
+from operator import eq, ge, gt, le, lt, ne
+
+import numpy as np
+from openmdao.utils.units import valid_units
+
+from aviary.utils.aviary_values import AviaryValues, get_keys
+from aviary.utils.functions import convert_strings_to_data, set_value
+from aviary.variable_info.options import get_option_defaults
+from aviary.variable_info.enums import ProblemType
+from aviary.variable_info.variable_meta_data import _MetaData
+from aviary.variable_info.variables import Aircraft, Mission
+from aviary.utils.functions import get_path
+
+
+operation_dict = {"<": lt, "<=": le, "==": eq, "!=": ne,
+                  ">=": ge, ">": gt, "isinstance": isinstance}
+problem_types = {'sizing': ProblemType.SIZING,
+                 'alternate': ProblemType.ALTERNATE, 'fallout': ProblemType.FALLOUT}
+
+
+
[docs]def create_vehicle(vehicle_deck=''):
+    """
+    Creates and initializes a vehicle with default or specified parameters. It sets up the aircraft values
+    and initial guesses based on the input from the vehicle deck.
+
+    Parameters
+    ----------
+    vehicle_deck (str): Path to the vehicle deck file. Default is an empty string.
+
+    Returns
+    -------
+    tuple: Returns a tuple containing aircraft values and initial guesses.
+    """
+    aircraft_values = get_option_defaults(engine=False)
+
+    # TODO remove all hardcoded GASP values here, find appropriate place for them
+    aircraft_values.set_val('debug_mode', val=False)
+    aircraft_values.set_val('INGASP.JENGSZ', val=4)
+    aircraft_values.set_val('test_mode', val=False)
+    aircraft_values.set_val('use_surrogates', val=True)
+    aircraft_values.set_val('mass_defect', val=10000, units='lbm')
+    aircraft_values.set_val('problem_type', val=ProblemType.SIZING)
+    aircraft_values.set_val(Aircraft.Electrical.HAS_HYBRID_SYSTEM, val=False)
+    aircraft_values.set_val(Aircraft.Design.RESERVES, val=4998)
+
+    vehicle_deck = get_path(vehicle_deck)
+
+    parse_inputs(vehicle_deck, aircraft_values)
+    # update the dependent options with the current values
+    update_options(aircraft_values, initial_guesses)
+
+    return aircraft_values, initial_guesses

+
+
+
[docs]def parse_inputs(vehicle_deck, aircraft_values: AviaryValues(), meta_data=_MetaData):
+    """
+    Parses the input files and updates the aircraft values and initial guesses. The function reads the
+    vehicle deck file, processes each line, and updates the aircraft_values object based on the data found.
+
+    Parameters
+    ----------
+    vehicle_deck (str): The vehicle deck file path.
+    aircraft_values (AviaryValues): An instance of AviaryValues to be updated.
+
+    Returns
+    -------
+    tuple: Updated aircraft values and initial guesses.
+    """
+    guess_names = list(initial_guesses.keys())
+
+    with open(vehicle_deck, newline='') as f_in:
+        for line in f_in:
+            used, data_units = False, None
+
+            tmp = [*line.split('#', 1), '']
+            line, comment = tmp[0], tmp[1]  # anything after the first # is a comment
+
+            data = ''.join(line.rstrip(',').split())  # remove all white space
+
+            if len(data) == 0:
+                continue  # skip line it contained only commas
+
+            # remove any elements that are empty (caused by trailing commas or extra commas)
+            data_list = [dat for dat in data.split(',') if dat != '']
+
+            # continue if there's no data in the line but there are commas
+            # this might occur if someone edits a .csv file in Excel
+            if len(data_list) == 0:
+                continue
+            var_name = data_list.pop(0)
+            if valid_units(data_list[-1]):
+                # if the last element is a unit, remove it from the list and update the variable's units
+                data_units = data_list.pop()
+
+            is_array = False
+            if '[' in data_list[0]:
+                is_array = True
+
+            var_values = convert_strings_to_data(data_list)
+
+            if var_name == 'debug_mode':
+                aircraft_values = set_value(var_name, var_values, aircraft_values)
+                continue
+
+            elif var_name in meta_data.keys():
+                aircraft_values = set_value(
+                    var_name, var_values, aircraft_values, units=data_units, is_array=is_array, meta_data=meta_data)
+                continue
+
+            elif var_name in guess_names:
+                # all initial guesses take only a single value
+                initial_guesses[var_name] = float(var_values[0])
+                continue
+
+            if 'debug_mode' in aircraft_values and aircraft_values.get_val('debug_mode'):
+                print('Unused:', var_name, var_values, comment)
+
+    return aircraft_values, initial_guesses

+
+
+
[docs]def update_options(aircraft_values: AviaryValues(), initial_guesses):
+    """
+    Updates options based on the current values in aircraft_values. This function also handles special cases 
+    and prints debug information if the debug mode is active.
+
+    Parameters
+    ----------
+    aircraft_values (AviaryValues): An instance of AviaryValues containing current aircraft values.
+    initial_guesses (dict): A dictionary of initial guesses for various parameters.
+
+    Returns
+    -------
+    tuple: Updated aircraft values and initial guesses.
+    """
+    # update the options that depend on variables
+    update_dependent_options(aircraft_values, dependent_options)
+
+    # TODO this is GASP only, don't always run it! These should go in a GASP-only options
+    #      preprocessor
+    ## STRUT AND FOLD ##
+    if not aircraft_values.get_val(Aircraft.Wing.HAS_STRUT):
+        aircraft_values.set_val(
+            Aircraft.Strut.DIMENSIONAL_LOCATION_SPECIFIED, val=False)
+
+    if aircraft_values.get_val(Aircraft.Wing.HAS_FOLD):
+        if not aircraft_values.get_val(Aircraft.Wing.CHOOSE_FOLD_LOCATION):
+            aircraft_values.set_val(
+                Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED, val=True)
+        else:
+            dim_loc_spec = aircraft_values.get_val(
+                Aircraft.Strut.DIMENSIONAL_LOCATION_SPECIFIED)
+            aircraft_values.set_val(
+                Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED, val=dim_loc_spec)
+    else:
+        aircraft_values.set_val(Aircraft.Wing.CHOOSE_FOLD_LOCATION, val=True)
+        aircraft_values.set_val(
+            Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED, val=False)
+
+    initial_guessing(aircraft_values)
+
+    if aircraft_values.get_val('debug_mode'):
+        print('\nOptions')
+        for key in get_keys(aircraft_values):
+            val, units = aircraft_values.get_item(key)
+            print(key, val)
+        print('\nInitial Guesses')
+        for key, value in initial_guesses.items():
+            print(key, value)
+
+    return aircraft_values, initial_guesses

+
+
+
[docs]def update_dependent_options(aircraft_values: AviaryValues(), dependent_options):
+    """
+    Updates options that are dependent on the value of an input variable or option. The function iterates 
+    through each dependent option and sets its value based on the current aircraft values.
+
+    Parameters
+    ----------
+    aircraft_values (AviaryValues): An instance of AviaryValues containing current aircraft values.
+    dependent_options (list): A list of dependent options and their dependencies.
+
+    Returns
+    -------
+    AviaryValues: Updated aircraft values with modified dependent options.
+    """
+    # gets the names of all the variables that affect dependent options
+    for var_name, dependency in dependent_options:
+        if var_name in get_keys(aircraft_values):
+            var_value, var_units = aircraft_values.get_item(var_name)
+            # dependency is a dictionary that contains the target option, the relationship to the variable and the output values
+            if dependency['relation'] in operation_dict:
+                comp = operation_dict[dependency['relation']]
+                outcome = dependency['result'] if comp(
+                    var_value, dependency['val']) else dependency['alternate']
+            elif dependency['relation'] == "in":
+                outcome = dependency['result'] if var_value in dependency['val'] else dependency['alternate']
+            else:
+                warnings.warn(dependency['relation'] +
+                              ' is not a valid selection')
+            aircraft_values.set_val(dependency['target'], val=outcome)
+    return aircraft_values

+
+
+
[docs]def initial_guessing(aircraft_values: AviaryValues()):
+    """
+    Sets initial guesses for various aircraft parameters based on the current problem type, aircraft values,
+    and other factors. It calculates and sets values like takeoff mass, cruise mass, flight duration, etc.
+
+    Parameters
+    ----------
+    aircraft_values (AviaryValues): An instance of AviaryValues containing current aircraft values.
+
+    Returns
+    -------
+    tuple: Updated aircraft values and initial guesses.
+    """
+    problem_type = aircraft_values.get_val('problem_type')
+    reserves = aircraft_values.get_val(
+        Aircraft.Design.RESERVES) if initial_guesses['reserves'] == 0 else initial_guesses['reserves']
+    num_pax = aircraft_values.get_val(Aircraft.CrewPayload.NUM_PASSENGERS)
+
+    if Mission.Summary.GROSS_MASS in aircraft_values:
+        mission_mass = aircraft_values.get_val(Mission.Summary.GROSS_MASS, units='lbm')
+    else:
+        mission_mass = aircraft_values.get_val(Mission.Design.GROSS_MASS, units='lbm')
+
+    if Mission.Summary.CRUISE_MASS_FINAL in aircraft_values:
+        cruise_mass_final = aircraft_values.get_val(
+            Mission.Summary.CRUISE_MASS_FINAL, units='lbm')
+    else:
+        cruise_mass_final = initial_guesses['cruise_mass_final']
+
+    if reserves < 0:
+        reserves *= -(num_pax *
+                      initial_guesses['fuel_burn_per_passenger_mile'] * aircraft_values.get_val(Mission.Design.RANGE, units='NM'))
+    initial_guesses['reserves'] = reserves
+
+    # takeoff mass not given
+    if mission_mass <= 0:
+        if problem_type == ProblemType.ALTERNATE:
+            fuel_mass = num_pax * (
+                initial_guesses['fuel_burn_per_passenger_mile'] * aircraft_values.get_val(Mission.Design.RANGE, units='NM')) + reserves
+            mission_mass = initial_guesses['operating_empty_mass'] + (
+                num_pax * aircraft_values.get_val(Aircraft.CrewPayload.PASSENGER_MASS_WITH_BAGS, units='lbm')) + fuel_mass
+        elif problem_type == ProblemType.FALLOUT or problem_type == ProblemType.SIZING:
+            mission_mass = aircraft_values.get_val(
+                Mission.Design.GROSS_MASS, units='lbm')
+    initial_guesses['actual_takeoff_mass'] = mission_mass
+
+    if cruise_mass_final == 0:  # no guess given
+        if problem_type == ProblemType.SIZING:
+            cruise_mass_final = .8
+        elif problem_type == ProblemType.ALTERNATE:
+            cruise_mass_final = -1
+    # estimation based on payload and fuel
+    if cruise_mass_final <= 0:
+        cruise_mass_final = initial_guesses['operating_empty_mass'] + \
+            num_pax * \
+            aircraft_values.get_val(
+                Aircraft.CrewPayload.PASSENGER_MASS_WITH_BAGS, units='lbm') + reserves
+    # fraction of takeoff mass
+    elif cruise_mass_final <= 1:
+        cruise_mass_final = mission_mass * \
+            cruise_mass_final
+    initial_guesses['cruise_mass_final'] = cruise_mass_final
+
+    if initial_guesses['rotation_mass'] <= 1:  # fraction of takeoff mass
+        initial_guesses['rotation_mass'] = mission_mass * \
+            initial_guesses['rotation_mass']
+
+    if Mission.Design.MACH in aircraft_values:
+        cruise_mach = aircraft_values.get_val(Mission.Design.MACH)
+    else:
+        cruise_mach = aircraft_values.get_val(Mission.Summary.CRUISE_MACH)
+
+    if initial_guesses['flight_duration'] <= 0:  # estimation based on mach
+        initial_guesses['flight_duration'] = aircraft_values.get_val(
+            Mission.Design.RANGE, units='NM') / (667 * cruise_mach) * (60 * 60)
+    elif initial_guesses['flight_duration'] <= 15:  # duration entered in hours
+        initial_guesses['flight_duration'] = initial_guesses['flight_duration'] * \
+            (60 * 60)
+
+    total_thrust = aircraft_values.get_val(
+        Aircraft.Engine.SCALED_SLS_THRUST, 'lbf') * aircraft_values.get_val(Aircraft.Engine.NUM_ENGINES)
+    gamma_guess = np.arcsin(.5*total_thrust / mission_mass)
+    avg_speed_guess = (.5 * 667 * cruise_mach)  # kts
+
+    if initial_guesses['time_to_climb'] <= 0:  # no guess given
+        initial_guesses['time_to_climb'] = aircraft_values.get_val(Mission.Design.CRUISE_ALTITUDE, units='ft') / \
+            (avg_speed_guess * np.sin(gamma_guess))
+    elif initial_guesses['time_to_climb'] <= 2:  # duration entered in hours
+        initial_guesses['time_to_climb'] = initial_guesses['time_to_climb'] * (60 * 60)
+    elif initial_guesses['time_to_climb'] <= 200:  # average climb rate in ft/s
+        initial_guesses['time_to_climb'] = aircraft_values.get_val(Mission.Design.CRUISE_ALTITUDE, units='ft') / \
+            initial_guesses['time_to_climb']
+
+    # range covered using an average speed from 0 to cruise
+    if initial_guesses['climb_range'] <= 0:
+        initial_guesses['climb_range'] = initial_guesses['time_to_climb'] / \
+            (60 * 60) * (avg_speed_guess * np.cos(gamma_guess))
+
+    return aircraft_values, initial_guesses

+
+
+dependent_options = [
+    # dependent_options is a list that is used to update options that depend on the value of
+    # an input variable or option.
+    # Each dependency comes in the form of a list with the variable name and a dictionary.
+    # The dictionary contains a value that the variable will be compared against (val), the
+    # particular mathematical comparison (relation), the option that is effected (target), and
+    # the value the option should be set to based on whether the relation is true (result) or
+    # false (alternate)
+    # For example, an aircraft's engines are on the fuselage if the span fraction on the wing is 0.
+    # In this case the value of Aircraft.Engine.WING_LOCATIONS is compared to 0. If the span location
+    # is exactly equal to zero, engine_on_fuselage is set to to True, otherwise it is set to False.
+    # One variable can be used to set the value of any number of options, but an option can only be
+    # set by one variable
+
+    # [Aircraft.Engine.WING_LOCATIONS, {
+    #     'val': 0, 'relation': '==', 'target': Aircraft.Engine.FUSELAGE_MOUNTED, 'result': True, 'alternate': False}],
+    [Aircraft.Fuselage.WETTED_AREA_FACTOR, {
+        'val': 10, 'relation': '>', 'target': Aircraft.Fuselage.PROVIDE_SURFACE_AREA, 'result': True, 'alternate': False}],
+    [Aircraft.Wing.LOADING, {'val': 20, 'relation': '>',
+                             'target': Aircraft.Wing.LOADING_ABOVE_20, 'result': True, 'alternate': False}],
+    [Aircraft.Strut.ATTACHMENT_LOCATION, {
+        'val': 0, 'relation': '!=', 'target': Aircraft.Wing.HAS_STRUT, 'result': True, 'alternate': False}],
+    [Aircraft.Strut.ATTACHMENT_LOCATION, {
+        'val': 1, 'relation': '>', 'target': Aircraft.Strut.DIMENSIONAL_LOCATION_SPECIFIED, 'result': True, 'alternate': False}],
+    [Aircraft.Wing.FOLD_MASS_COEFFICIENT, {
+        'val': 0, 'relation': '>', 'target': Aircraft.Wing.HAS_FOLD, 'result': True, 'alternate': False}],
+    [Aircraft.Wing.FOLDED_SPAN, {'val': 1, 'relation': '>', 'target': Aircraft.Wing.FOLD_DIMENSIONAL_LOCATION_SPECIFIED,
+                                 'result': True, 'alternate': False}],
+    [Aircraft.Design.PART25_STRUCTURAL_CATEGORY, {
+        'val': 0, 'relation': '<', 'target': Aircraft.Design.ULF_CALCULATED_FROM_MANEUVER, 'result': True, 'alternate': False}],
+    [Aircraft.Engine.TYPE, {
+        'val': [1, 2, 3, 4, 11, 12, 13, 14], 'relation': 'in', 'target': Aircraft.Engine.HAS_PROPELLERS, 'result': True, 'alternate': False}],
+    ['JENGSZ', {
+        'val': 4, 'relation': '!=', 'target': Aircraft.Engine.SCALE_PERFORMANCE, 'result': True, 'alternate': False}],
+    [Aircraft.HorizontalTail.VOLUME_COEFFICIENT, {
+        'val': 0, 'relation': '==', 'target': Aircraft.Design.COMPUTE_HTAIL_VOLUME_COEFF, 'result': True, 'alternate': False}],
+    [Aircraft.VerticalTail.VOLUME_COEFFICIENT, {
+        'val': 0, 'relation': '==', 'target': Aircraft.Design.COMPUTE_VTAIL_VOLUME_COEFF, 'result': True, 'alternate': False}],
+]
+
+initial_guesses = {
+    # initial_guesses is a dictionary that contains values used to initialize the trajectory
+    'actual_takeoff_mass': 0,
+    'rotation_mass': .99,
+    'operating_empty_mass': 0,
+    'fuel_burn_per_passenger_mile': 0.1,
+    'cruise_mass_final': 0,
+    'flight_duration': 0,
+    'time_to_climb': 0,
+    'climb_range': 0,
+    'reserves': 0
+}
+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/report.html b/_modules/aviary/utils/report.html new file mode 100644 index 000000000..ac70367a4 --- /dev/null +++ b/_modules/aviary/utils/report.html @@ -0,0 +1,830 @@ + + + + + + + + + + + aviary.utils.report + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.report

+import numpy as np
+from openmdao.utils.assert_utils import assert_near_equal
+
+from aviary.variable_info.variables import Aircraft, Dynamic, Mission
+
+
+
[docs]def report_cruise(prob, remote=False, file=None):
+    variables = [
+        ("mass", "lbm", "mass_initial", "mass_final"),
+        ("alpha", "deg", "aero_initial.alpha", "aero_final.alpha"),
+        ("CL", "", "aero_initial.CL", "aero_final.CL"),
+        ("CD", "", "aero_initial.CD", "aero_final.CD"),
+        (Dynamic.Mission.THRUST_TOTAL, "lbf", "prop_initial.thrust_net_total",
+         "prop_final.thrust_net_total"),
+        (Dynamic.Mission.FUEL_FLOW_RATE_TOTAL, "lbm/s",
+         "fuel_flow_initial", "fuel_flow_final"),
+        ("TSFC", "1/h", "prop_initial.sfc", "prop_final.sfc"),
+    ]
+
+    print(60 * "=", file=file)
+    print("{:^60}".format("cruise performance"), file=file)
+    print("{:<21}   {:>15}   {:>15}".format("variable", "initial", "final"), file=file)
+    print(60 * "-", file=file)
+    for name, unstr, pathi, pathf in variables:
+        units = None if unstr == "" else unstr
+        vali = prob.get_val(f"cruise.{pathi}", units=units, get_remote=remote)[0]
+        valf = prob.get_val(f"cruise.{pathf}", units=units, get_remote=remote)[0]
+        print(f"{name:<10} {unstr:>10} | {vali:15.4f} | {valf:15.4f}", file=file)
+    print(60 * "=", file=file)

+
+
+
[docs]def report_fuelburn(prob, remote=False, file=None):
+    traj_phases = {
+        "traj": [
+            "groundroll",
+            "rotation",
+            "ascent",
+            "accel",
+            "climb1",
+            "climb2",
+            "cruise",
+            "desc1",
+            "desc2",
+        ]
+    }
+
+    print(40 * "=", file=file)
+    print("{:^40}".format("fuel burn in each phase"), file=file)
+    print(40 * "-", file=file)
+    for traj, phaselist in traj_phases.items():
+        for phase in phaselist:
+            if phase == 'cruise':
+                vals = prob.get_val(
+                    f"{traj}.{phase}.timeseries.mass",
+                    units="lbm",
+                    indices=[-1, 0],
+                    get_remote=remote,
+                )
+            else:
+                vals = prob.get_val(
+                    f"{traj}.{phase}.states:mass",
+                    units="lbm",
+                    indices=[-1, 0],
+                    get_remote=remote,
+                )
+            diff = np.diff(vals, axis=0)[0, 0]
+            print(f"{phase:<12} {diff:>8.2f} lbm", file=file)
+    print(40 * "=", file=file)

+
+
+
[docs]def report_gasp_comparison(prob, rtol=0.1, remote=False, file=None):
+    # values from GASP output of large single aisle 1 at constant altitude using (I think) turbofan_23k_1
+    expected_vals = [
+        (
+            "Design GTOW (lb)",
+            175400.0,
+            prob.get_val(Mission.Design.GROSS_MASS, get_remote=remote)[0],
+        ),
+        (
+            "Actual GTOW (lb)",
+            175400.0,
+            prob.get_val(Mission.Summary.GROSS_MASS, get_remote=remote)[0],
+        ),
+        (
+            "OEM (lb)",
+            96348.0,
+            prob.get_val(Aircraft.Design.OPERATING_MASS, get_remote=remote)[0],
+        ),
+        # mass at end of descent
+        (
+            "final mass (lb)",
+            137348.0,
+            prob.get_val(Mission.Landing.TOUCHDOWN_MASS, get_remote=remote)[0],
+        ),
+        # block fuel, includes reserves
+        (
+            "block fuel (lb)",
+            43049.6,
+            prob.get_val(Mission.Summary.TOTAL_FUEL_MASS, get_remote=remote)[0],
+        ),
+        (
+            "landing distance (ft)",
+            2980.0,
+            prob.get_val('landing.'+Mission.Landing.GROUND_DISTANCE,
+                         get_remote=remote)[0],
+        ),
+        (
+            "flight distance (NM)",
+            3675.0,
+            prob.get_val(
+                "traj.desc2.timeseries.states:distance", units="NM", get_remote=remote
+            )[-1][0],
+        ),
+        # ROC @ 49 seconds to get from 456.3 ft to 500 ft minus liftoff time
+        (
+            "ascent duration (s)",
+            49 + (500 - 465.3) / (2674.4 / 60) - 31.2,
+            prob.get_val("traj.ascent.t_duration", get_remote=remote)[0],
+        ),
+        # AEO takeoff table
+        (
+            "gear retraction time (s)",
+            37.3,
+            prob.get_val("h_fit.t_init_gear", get_remote=remote)[0],
+        ),
+        (
+            "flaps retraction time (s)",
+            47.6,
+            prob.get_val("h_fit.t_init_flaps", get_remote=remote)[0],
+        ),
+        # block time minus taxi time, no final descent
+        (
+            "flight time (hr)",
+            8.295 - 10 / 60,
+            prob.get_val("traj.desc2.timeseries.time", units="h", get_remote=remote)[
+                -1
+            ][0],
+        ),
+    ]
+
+    print(80 * "=", file=file)
+    print("{:^80}".format("comparison with reference GASP Large Single Aisle 1"), file=file)
+    print(
+        "{:<28} | {:>15} | {:>15} | {:>10}".format(
+            "variable", "GASP vals", "Aviary actual", "rel. err."
+        ),
+        file=file,
+    )
+    print(80 * "-", file=file)
+    results = {
+        item[0]: {
+            "desired": item[1],
+            "actual": item[2],
+            "rerr": (item[2] - item[1]) / item[1],
+        }
+        for item in expected_vals
+    }
+    for label, desired, actual in expected_vals:
+        mark = ""
+        rerr = (actual - desired) / desired
+        if abs(rerr) > rtol:
+            mark = "X"
+        try:
+            assert_near_equal(actual, desired, tolerance=rtol)
+        except ValueError:
+            mark = "X"
+        print(
+            f"{label:<28} | {desired:15.4f} | {actual:15.4f} | {rerr:> .2e} {mark}",
+            file=file,
+        )
+    print(80 * "=", file=file)
+    return results

+
+
+
[docs]def report_benchmark_comparison(
+    prob, rtol=0.1, remote=False, file=None, size_engine=False, base='GASP'
+):
+    # values from GASP output of large single aisle 1 at constant altitude using (I think) turbofan_23k_1
+
+    no_size = [
+        175310.9512,
+        175310.9512,
+        96457.2320,
+        137455.2320,
+        42853.7192,
+        2615.5252,
+        3675.0000,
+        17.3416,
+        38.2458,
+        48.2047,
+        8.1171,
+    ]
+    yes_size = [
+        175539.0746,
+        175539.0746,
+        96587.0999,
+        137585.1013,
+        42951.9734,
+        2568.6457,
+        3675.0000,
+        21.4275,
+        37.9418,
+        49.8459,
+        8.1145,
+    ]
+    # no_size_yes_pyCycle = [
+    #     175394.6488,
+    #     175394.6488,
+    #     95820.0936,
+    #     136997.9090,
+    #     43394.7398,
+    #     2560.4481,
+    #     3675.0000,
+    #     10.0131,
+    #     33.2441,
+    #     40.2571,
+    #     9.5767,
+    # ]
+
+    FLOPS_base = [
+        173370.02714369,
+        0.000001,  # not exactly zero to avoid divide by zero errors
+        95569.5191,
+        136425.51908379,
+        39944.5081,
+        7732.7314,
+        3378.7,
+    ]
+    if size_engine:
+        check_val = yes_size
+    elif not size_engine:
+        check_val = no_size
+    # elif not size_engine and pyCycle_used:
+    #     check_val = no_size_yes_pyCycle
+    if base == 'FLOPS':
+        check_val = FLOPS_base
+        distance_name = 'traj.descent.timeseries.states:range'
+        landing_dist_name = Mission.Landing.GROUND_DISTANCE
+    else:
+        distance_name = "traj.desc2.timeseries.states:distance"
+        landing_dist_name = 'landing.'+Mission.Landing.GROUND_DISTANCE
+
+    expected_vals = [
+        (
+            "Design GTOW (lb)",
+            check_val[0],
+            prob.get_val(Mission.Design.GROSS_MASS, get_remote=remote)[0],
+        ),
+        (
+            "Actual GTOW (lb)",
+            check_val[1],
+            prob.get_val(Mission.Summary.GROSS_MASS, get_remote=remote)[0],
+        ),
+        (
+            "OEW (lb)",
+            check_val[2],
+            prob.get_val(Aircraft.Design.OPERATING_MASS, get_remote=remote)[0],
+        ),
+        # mass at end of descent
+        (
+            "final mass (lb)",
+            check_val[3],
+            prob.get_val(Mission.Landing.TOUCHDOWN_MASS, get_remote=remote)[0],
+        ),
+        # block fuel, includes reserves
+        (
+            "block fuel (lb)",
+            check_val[4],
+            prob.get_val(Mission.Summary.TOTAL_FUEL_MASS, get_remote=remote)[0],
+        ),
+        (
+            "landing distance (ft)",
+            check_val[5],
+            prob.get_val(landing_dist_name,
+                         get_remote=remote)[0],
+        ),
+        (
+            "flight distance (NM)",
+            check_val[6],
+            prob.get_val(
+                distance_name, units="NM", get_remote=remote
+            )[-1][0],
+        ),
+    ]
+
+    if base != 'FLOPS':
+        GASP_vals = [
+            # ROC @ 49 seconds to get from 456.3 ft to 500 ft minus liftoff time
+            (
+                "ascent duration (s)",
+                check_val[7],
+                prob.get_val("traj.ascent.t_duration", get_remote=remote)[0],
+            ),
+            # AEO takeoff table
+            (
+                "gear retraction time (s)",
+                check_val[8],
+                prob.get_val("h_fit.t_init_gear", get_remote=remote)[0],
+            ),
+            (
+                "flaps retraction time (s)",
+                check_val[9],
+                prob.get_val("h_fit.t_init_flaps", get_remote=remote)[0],
+            ),
+            # block time minus taxi time, no final descent
+            (
+                "flight time (hr)",
+                check_val[10],
+                prob.get_val("traj.desc2.timeseries.time", units="h", get_remote=remote)[
+                    -1
+                ][0],
+            ),
+        ]
+        expected_vals = expected_vals + GASP_vals
+
+    print(80 * "=", file=file)
+    print(
+        "{:^80}".format(
+            "comparison with reference value (not a validated value, just a point to check against)"
+        ),
+        file=file,
+    )
+    print(
+        "{:<28} | {:>15} | {:>15} | {:>10}".format(
+            "variable", "original vals", "Aviary actual", "rel. err."
+        ),
+        file=file,
+    )
+    print(80 * "-", file=file)
+    for label, desired, actual in expected_vals:
+        mark = ""
+        rerr = (actual - desired) / desired
+        if abs(rerr) > rtol:
+            mark = "X"
+        try:
+            assert_near_equal(actual, desired, tolerance=rtol)
+        except ValueError:
+            mark = "X"
+        print(
+            f"{label:<28} | {desired:15.4f} | {actual:15.4f} | {rerr:> .2e} {mark}",
+            file=file,
+        )
+    print(80 * "=", file=file)

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/utils/set_mass_defaults.html b/_modules/aviary/utils/set_mass_defaults.html new file mode 100644 index 000000000..c13985584 --- /dev/null +++ b/_modules/aviary/utils/set_mass_defaults.html @@ -0,0 +1,743 @@ + + + + + + + + + + + aviary.utils.set_mass_defaults + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.utils.set_mass_defaults

+from aviary.variable_info.variables import Aircraft
+
+
+
[docs]def mass_defaults(prob):
+    prob.model.set_input_defaults(
+        Aircraft.Strut.ATTACHMENT_LOCATION, val=0, units='unitless')
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.ASPECT_RATIO, val=1.67, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.HorizontalTail.TAPER_RATIO, val=0.352, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Engine.WING_LOCATIONS, val=0.35, units="unitless")
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.PRESSURE_DIFFERENTIAL, val=7.5, units="psi"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuel.WING_FUEL_FRACTION, 0.6, units="unitless")
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.TAPER_RATIO, val=0.801, units="unitless"
+    )
+
+    prob.model.set_input_defaults(
+        Aircraft.HorizontalTail.VOLUME_COEFFICIENT, val=1.189, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.VOLUME_COEFFICIENT, 0.145, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.DELTA_DIAMETER, 4.5, units="ft"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.PILOT_COMPARTMENT_LENGTH, 9.5, units="ft"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.NOSE_FINENESS, 1, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.TAIL_FINENESS, 3, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.WETTED_AREA_FACTOR, 4000, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.MOMENT_RATIO, 2.362, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.HorizontalTail.ASPECT_RATIO, val=4.75, units="unitless"
+    )
+    prob.model.set_input_defaults(Aircraft.Engine.REFERENCE_DIAMETER, 5.8, units="ft")
+    prob.model.set_input_defaults(
+        Aircraft.Nacelle.CORE_DIAMETER_RATIO, 1.25, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Nacelle.FINENESS, 2, units="unitless")
+
+    prob.model.set_input_defaults(
+        Aircraft.Design.MAX_STRUCTURAL_SPEED,
+        val=402.5,
+        units="mi/h",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Design.LIFT_CURVE_SLOPE,
+        val=7.1765,
+        units="unitless",
+    )
+
+    prob.model.set_input_defaults(
+        Aircraft.CrewPayload.CARGO_MASS, val=10040, units="lbm"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.HorizontalTail.MASS_COEFFICIENT,
+        val=0.232,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.LandingGear.TAIL_HOOK_MASS_SCALER, val=1,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.MASS_COEFFICIENT,
+        val=0.289,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.HorizontalTail.THICKNESS_TO_CHORD,
+        val=0.12,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.THICKNESS_TO_CHORD,
+        val=0.12,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Wing.HIGH_LIFT_MASS_COEFFICIENT,
+        val=2.66,
+        units="lbm/ft**2",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Wing.SURFACE_CONTROL_MASS_COEFFICIENT,
+        val=0.95,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Design.COCKPIT_CONTROL_MASS_COEFFICIENT,
+        val=16.5,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Controls.STABILITY_AUGMENTATION_SYSTEM_MASS, val=0, units="lbm"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Controls.COCKPIT_CONTROL_MASS_SCALER, val=1, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Wing.SURFACE_CONTROL_MASS_SCALER, val=1, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Controls.STABILITY_AUGMENTATION_SYSTEM_MASS_SCALER, val=1, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Controls.TOTAL_MASS,
+        val=0,
+        units="lbm",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.LandingGear.MASS_COEFFICIENT, val=0.04,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.LandingGear.MAIN_GEAR_MASS_COEFFICIENT, val=0.85,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Nacelle.CLEARANCE_RATIO,
+        val=0.2,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Engine.MASS_SPECIFIC,
+        val=0.21366,
+        units="lbm/lbf",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Nacelle.MASS_SPECIFIC,
+        val=3,
+        units="lbm/ft**2",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Engine.PYLON_FACTOR, val=1.25,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Engine.ADDITIONAL_MASS_FRACTION, val=0.14,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Engine.MASS_SCALER, val=1, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Propulsion.MISC_MASS_SCALER, val=1, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.LandingGear.MAIN_GEAR_LOCATION,
+        val=0.15,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Design.EQUIPMENT_MASS_COEFFICIENTS,
+        val=[
+            928.0,
+            0.0736,
+            0.112,
+            0.14,
+            1959.0,
+            1.65,
+            551.0,
+            11192.0,
+            5.0,
+            3.0,
+            50.0,
+            7.6,
+            12.0,
+        ],
+        units="unitless",
+    )
+
+    prob.model.set_input_defaults(
+        Aircraft.Wing.MASS_COEFFICIENT,
+        val=102.5,
+        units="unitless",
+    )
+
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.MASS_COEFFICIENT,
+        val=128,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        "static_analysis.total_mass.fuel_mass.fus_and_struct.pylon_len",
+        val=0,
+        units='ft',
+    )
+    prob.model.set_input_defaults(
+        "static_analysis.total_mass.fuel_mass.fus_and_struct.MAT", val=0,
+        units='lbm'
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Wing.MASS_SCALER, val=1,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.HorizontalTail.MASS_SCALER, val=1,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.MASS_SCALER, val=1,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuselage.MASS_SCALER, val=1,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.LandingGear.TOTAL_MASS_SCALER, val=1,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Engine.POD_MASS_SCALER, val=1,
+        units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Design.STRUCTURAL_MASS_INCREMENT,
+        val=0,
+        units='lbm',
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuel.FUEL_SYSTEM_MASS_SCALER, val=1, units="unitless"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuel.FUEL_SYSTEM_MASS_COEFFICIENT,
+        val=0.041,
+        units="unitless",
+    )
+    prob.model.set_input_defaults(
+        Aircraft.Fuel.DENSITY, val=6.687, units="lbm/galUS"
+    )
+    prob.model.set_input_defaults(
+        Aircraft.VerticalTail.SWEEP,
+        val=25.0,
+        units="deg",
+    )
+
+    return prob

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/variable_info/enums.html b/_modules/aviary/variable_info/enums.html new file mode 100644 index 000000000..efb7e946f --- /dev/null +++ b/_modules/aviary/variable_info/enums.html @@ -0,0 +1,670 @@ + + + + + + + + + + + aviary.variable_info.enums + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.variable_info.enums

+from enum import Enum, auto, unique
+
+
+
[docs]class AlphaModes(Enum):
+    '''
+    AlphaModes is used to specify how angle of attack is defined during
+        climb and descent.
+    DEFAUT:
+        Alpha is an input
+    ROTATION
+        Alpha is calculated as the initial angle plus the rotation rate
+        times the duration of the rotation.
+    LOAD_FACTOR
+        Alpha is limited to ensure the load factor never exceeds a
+        specified maximum.
+    FUSELAGE_PITCH
+        Alpha is calculated to set a particular floor angle given the 
+        current flight path angle.
+    DECELERATION
+        Alpha is calculated to target a specified TAS rate, the default
+        is a TAS rate of 0 (Constant TAS).
+    REQUIRED_LIFT
+        Alpha is calculated such that the aircraft produces a particular
+        lifting force.
+    ALTITUDE_RATE
+        Alpha is calculated to target a specified altitude rate, the default
+        is 0 (Constant Altitude).
+    '''
+    DEFAULT = auto()
+    ROTATION = auto()
+    LOAD_FACTOR = auto()
+    FUSELAGE_PITCH = auto()
+    DECELERATION = auto()
+    REQUIRED_LIFT = auto()
+    ALTITUDE_RATE = auto()
+    CONSTANT_ALTITUDE = auto()

+
+
+
[docs]class AnalysisScheme(Enum):
+    """
+    AnalysisScheme is used to select from Collocation and shooting.
+
+    COLLOCATION uses the collocation method to optimize all points simultaneously
+    and can be run in parallel. However, it requires reasonable initial guesses
+    for the trajectory and is fairly sensitive to those initial guesses.
+
+    SHOOTING is a forward in time integration method that simulates the trajectory.
+    This does not require initial guesses and will always produce physically valid
+    trajectories, even during optimizer failures. The shooting method cannot be run
+    in parallel.
+    """
+    COLLOCATION = auto()
+    SHOOTING = auto()

+
+
+
[docs]class EquationsOfMotion(Enum):
+    """
+    Available equations of motion for use during mission analysis
+    """
+    HEIGHT_ENERGY = 'height_energy'
+    TWO_DEGREES_OF_FREEDOM = '2DOF'
+    # TODO these are a little out of place atm
+    SIMPLE = 'simple'
+    SOLVED = 'solved'

+
+
+
[docs]@unique
+class GASPEngineType(Enum):
+    """
+    Defines the type of engine to use in GASP-based mass calculations.
+    Note that only the value for the first engine model will be used.
+    Currenly only the TURBOJET option is implemented, but other types of engines will be added in the future.
+    """
+    # Reciprocating engine with carburator
+    RECIP_CARB = 1
+
+    # Reciprocating engine with fuel injection
+    RECIP_FUEL_INJECT = 2
+
+    # Reciprocating engine with fuel injection and geared
+    RECIP_FUEL_INJECT_GEARED = 3
+
+    # Rotary-combustion engine
+    ROTARY = 4
+
+    # Turboshaft engine
+    TURBOSHAFT = 5
+
+    # Turboprop engine
+    TURBOPROP = 6
+
+    # Turbojet or turbofan engine
+    TURBOJET = 7
+
+    # Reciprocating engine with carburator; use HOPWSZ (horizontally-opposed piston
+    # weight and size) methodology for geometry and mass
+    RECIP_CARB_HOPWSZ = 11
+
+    # Reciprocating engine with fuel injection; use HOPWSZ (horizontally-opposed piston
+    # weight and size) methodology for geometry and mass
+    RECIP_FUEL_INJECT_HOPWSZ = 12
+
+    # Reciprocating engine with fuel injection and geared; use HOPWSZ (horizontally-
+    # opposed piston weight and size) methodology for geometry and mass
+    RECIP_FUEL_INJECT_GEARED_HOPWSZ = 13
+
+    # Rotary-combustion engine; use RCWSZ (rotary combustion weight and size) methodology
+    # for geometry and mass
+    ROTARY_RCWSZ = 14

+
+
+
[docs]@unique
+class FlapType(Enum):
+    """
+    Defines the type of flap used on the wing. Used in GASP-based aerodynamics and mass calculations.
+    """
+    PLAIN = 1
+    SPLIT = 2
+    SINGLE_SLOTTED = 3
+    DOUBLE_SLOTTED = 4
+    TRIPLE_SLOTTED = 5
+    FOWLER = 6
+    DOUBLE_SLOTTED_FOWLER = 7

+
+
+
[docs]class LegacyCode(Enum):
+    """
+    Flag for legacy codebases
+    """
+    FLOPS = 'FLOPS'
+    GASP = 'GASP'
+
+    def __str__(self):
+        return self.value

+
+
+
[docs]class ProblemType(Enum):
+    """
+    ProblemType is used to switch between different combinations of
+    design variables and constraints.
+
+    SIZING: Varies the design gross weight and actual gross weight to
+    close to design range. This causes the empty weight and the fuel
+    weight to change.
+
+    ALTERNATE: Requires a pre-sized aircraft. It holds the design gross
+    weight and empty weight constant. It then varies the fuel weight
+    and actual gross weight until the range closes to the off-design
+    range.
+
+    FALLOUT: Requires a pre-sized aircraft. It holds the design gross
+    weight and empty weight constant. Using the specified actual
+    gross weight, it will then find the maximum distance the off-design
+    aircraft can fly.
+    """
+    SIZING = 'sizing'
+    ALTERNATE = 'alternate'
+    FALLOUT = 'fallout'

+
+
+
[docs]class SpeedType(Enum):
+    '''
+    SpeedType is used to specify the type of speed being used.
+    EAS is equivalent airspeed.
+    TAS is true airspeed.
+    MACH is mach
+    '''
+    EAS = auto()
+    TAS = auto()
+    MACH = auto()

+
+
+
[docs]class Verbosity(Enum):
+    """
+    Sets how much information Aviary outputs when run
+
+    Verbosity levels are based on ubuntu's standard:
+    https://discourse.ubuntu.com/t/cli-verbosity-levels/26973
+    """
+    QUIET = 0
+    BRIEF = 1
+    VERBOSE = 2
+    DEBUG = 3

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/variable_info/functions.html b/_modules/aviary/variable_info/functions.html new file mode 100644 index 000000000..82214f094 --- /dev/null +++ b/_modules/aviary/variable_info/functions.html @@ -0,0 +1,738 @@ + + + + + + + + + + + aviary.variable_info.functions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.variable_info.functions

+import dymos as dm
+import openmdao.api as om
+from dymos.utils.misc import _unspecified
+from openmdao.core.component import Component
+
+from aviary.utils.aviary_values import AviaryValues
+
+import dymos as dm
+
+from dymos.utils.misc import _unspecified
+
+import openmdao.api as om
+
+from aviary.variable_info.core_promotes import core_mission_inputs
+from aviary.variable_info.variable_meta_data import _MetaData
+
+# ---------------------------
+# Helper functions for setting up inputs/outputs in components
+# ---------------------------
+
+
+
[docs]def add_aviary_input(comp, varname, val=None, units=None, desc=None, shape_by_conn=False, meta_data=_MetaData):
+    '''
+    This function provides a clean way to add variables from the
+    variable hierarchy into components as Aviary inputs. It takes
+    the standard OpenMDAO inputs of the variable's name, initial
+    value, units, and description, as well as the component which
+    the variable is being added to.
+    '''
+    meta = meta_data[varname]
+    if units:
+        input_units = units
+    else:
+        # units of None are overwritten with defaults. Overwriting units with None is
+        # unecessary as it will cause errors down the line if the default is not already
+        # None
+        input_units = meta['units']
+    if desc:
+        input_desc = desc
+    else:
+        input_desc = meta['desc']
+    if val is None:
+        val = meta['default_value']
+    comp.add_input(varname, val=val, units=input_units,
+                   desc=input_desc, shape_by_conn=shape_by_conn)

+
+
+
[docs]def add_aviary_output(comp, varname, val, units=None, desc=None, shape_by_conn=False, meta_data=_MetaData):
+    '''
+    This function provides a clean way to add variables from the
+    variable hierarchy into components as Aviary outputs. It takes
+    the standard OpenMDAO inputs of the variable's name, initial
+    value, units, and description, as well as the component which
+    the variable is being added to.
+    '''
+    meta = meta_data[varname]
+    if units:
+        output_units = units
+    else:
+        # units of None are overwritten with defaults. Overwriting units with None is
+        # unecessary as it will cause errors down the line if the default is not already
+        # None
+        output_units = meta['units']
+    if desc:
+        output_desc = desc
+    else:
+        output_desc = meta['desc']
+    comp.add_output(varname, val=val, units=output_units,
+                    desc=output_desc, shape_by_conn=shape_by_conn)

+
+
+
[docs]def override_aviary_vars(group, aviary_inputs: AviaryValues,
+                         manual_overrides=None, external_overrides=None):
+    '''
+    This function provides the capability to override output variables
+    with variables from the aviary_inputs input. The user can also
+    optionally provide the names of variables that they would like to
+    override manually. (Manual overriding is simply suppressing the
+    promotion of the variable to make way for another output variable
+    of the same name, or to create an unconnected input elsewhere.)
+    '''
+    def name_filter(name):
+        return "aircraft:" in name or "mission:" in name
+
+    if not manual_overrides:
+        manual_overrides = []
+
+    if not external_overrides:
+        external_overrides = []
+
+    # first need to make a list of all the inputs that anyone needs
+    # so that we can keep track of any unclaimed inputs
+    all_inputs = set()  # use a set to avoid duplicates
+    for system in group.system_iter():
+        meta = system.get_io_metadata(iotypes=("input",))
+        in_var_names = meta.keys()
+        for name in in_var_names:
+            all_inputs.add(name)
+
+    overridden_outputs = []
+    external_overridden_outputs = []
+    for comp in group.system_iter(typ=Component):
+        # get a list of the variables to use
+        out_var_names = list(filter(name_filter, comp.get_io_metadata(
+            iotypes=("output",), return_rel_names=False)))
+        # get a list of the metadata associated with each variable
+        out_var_metadata = comp.get_io_metadata(
+            iotypes=("output",), return_rel_names=False)
+        in_var_names = filter(name_filter, comp.get_io_metadata(iotypes=("input", )))
+
+        comp_promoted_outputs = []
+
+        for abs_name in out_var_names:
+            name = out_var_metadata[abs_name]['prom_name']
+
+            if abs_name in manual_overrides:
+                # These are handled outside of this function.
+                continue
+
+            elif name in external_overrides:
+
+                # Overridden variables are given a new name
+                comp_promoted_outputs.append((name, f"EXTERNAL_OVERRIDE:{name}"))
+                external_overridden_outputs.append(name)
+
+                continue  # don't promote it
+
+            elif name in aviary_inputs:
+                if name in all_inputs:
+                    val, units = aviary_inputs.get_item(name)
+                    group.set_input_defaults(name, val=val, units=units)
+
+                    # Overridden variables are given a new name
+                    comp_promoted_outputs.append((name, f"AUTO_OVERRIDE:{name}"))
+                    overridden_outputs.append(name)
+
+                continue  # don't promote it
+
+            # This variable is not overriden, so the output is promoted.
+            comp_promoted_outputs.append(name)
+
+        # note: Always promoting all inputs into the "global" namespace
+        # so its VERY important that we enforce all inputs names exist in the master
+        # variable list
+        rel_path = comp.pathname[len(group.pathname):].lstrip(".")
+        if "." in rel_path:
+            # comp is in a subgroup. We must find it.
+            sub_path = ".".join(rel_path.split(".")[:-1])
+            sub = group._get_subsystem(sub_path)
+            sub.promotes(comp.name, inputs=in_var_names, outputs=comp_promoted_outputs)
+        else:
+            group.promotes(comp.name, inputs=in_var_names, outputs=comp_promoted_outputs)
+
+    if overridden_outputs:
+        print("\nThe following variables have been overridden:")
+        for prom_name in sorted(overridden_outputs):
+            print(f"  '{prom_name}")
+
+    if external_overridden_outputs:
+        print("\nThe following variables have been overridden by an external subsystem:")
+        for prom_name in sorted(external_overridden_outputs):
+            print(f"  '{prom_name}")
+
+    return overridden_outputs

+
+
+
[docs]def setup_trajectory_params(
+    model: om.Group, traj: dm.Trajectory, aviary_variables: AviaryValues, phases=['climb', 'cruise', 'descent'],
+    variables_to_add=None, meta_data=_MetaData, external_parameters={},
+):
+    '''
+    This function smoothly sorts through the aviary variables which
+    are being used in the trajectory, and for the variables which are
+    not options it adds them as a parameter of the trajectory.
+    '''
+    # TODO: make this automated as part of the trajectory subclass
+    if variables_to_add is None:
+        variables_to_add = sorted(core_mission_inputs)
+
+    for key in sorted(variables_to_add):
+        meta = meta_data[key]
+
+        if not meta['option']:
+            val = meta['default_value']
+            if val is None:
+                val = _unspecified
+            units = meta['units']
+
+            if key in aviary_variables:
+                try:
+                    val = aviary_variables.get_val(key, units)
+                except TypeError:
+                    val = aviary_variables.get_val(key)
+
+                    # TODO temp line to ignore dynamic mission variables, will not work
+                    #      if names change to 'dynamic:mission:*'
+            if ':' not in key:
+                continue
+
+            # TODO: make a trajectory subclass that does this
+            traj.add_parameter(
+                key,
+                opt=False,
+                units=units,
+                val=val,
+                static_target=True,
+                targets={phase_name: [key] for phase_name in phases})
+
+            model.promotes('traj', inputs=[(f'parameters:{key}', key)])
+
+    # Step 1: Initialize a dictionary to hold parameters and their associated phases
+    parameters_with_phases = {}
+
+    # Step 2: Loop through external_parameters to populate the dictionary
+    for phase_name, parameter_dict in external_parameters.items():
+        for key in parameter_dict.keys():
+            if key not in parameters_with_phases:
+                parameters_with_phases[key] = []
+            parameters_with_phases[key].append(phase_name)
+
+    # Step 3: Loop through the collected parameters and call traj.add_parameter
+    for key, phases in parameters_with_phases.items():
+        # Assuming the kwargs are the same for shared parameters
+        kwargs = external_parameters[phases[0]][key]
+        targets = {phase: [key] for phase in phases}
+        traj.add_parameter(
+            key,
+            **kwargs,
+            targets=targets
+        )
+        model.promotes('traj', inputs=[(f'parameters:{key}', key)])
+
+    return traj

+
+
+
[docs]def get_units(key, meta_data=None) -> str:
+    """
+    Returns the units for the specified variable as defined in the MetaData.
+
+    Parameters
+    ----------
+    key: str
+        Name of the variable
+    meta_data : dict
+        Dictionary containing metadata for the variable. If None, Aviary's built-in
+        metadata will be used.
+    """
+    if meta_data is None:
+        meta_data = _MetaData
+
+    return meta_data[key]['units']

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/variable_info/options.html b/_modules/aviary/variable_info/options.html new file mode 100644 index 000000000..3286f54d6 --- /dev/null +++ b/_modules/aviary/variable_info/options.html @@ -0,0 +1,542 @@ + + + + + + + + + + + aviary.variable_info.options + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.variable_info.options

+from aviary.utils.aviary_values import AviaryValues
+from aviary.utils.preprocessors import preprocess_propulsion
+from aviary.utils.functions import get_path
+from aviary.variable_info.variable_meta_data import _MetaData
+from aviary.variable_info.variables import Aircraft
+from aviary.subsystems.propulsion.engine_deck import EngineDeck
+
+
+
[docs]def get_option_defaults(engine=True, meta_data=_MetaData) -> AviaryValues:
+    """
+    Returns a deep copy of the collection of all options for which default values exist.
+
+    Parameters
+    ----------
+    engine : bool
+        If true, the collection includes the default engine model
+    meta_data : dict
+        Dictionary containing metadata for the options. If None, Aviary's built-in
+        metadata will be used.
+    """
+
+    option_defaults = AviaryValues()
+
+    # Load all variables marked as options in the MetaData
+    for key in meta_data:
+        var = meta_data[key]
+        if var['option'] and var['default_value'] is not None:
+            option_defaults.set_val(key, var['default_value'], var['units'])
+
+    if engine:
+        engine_options = option_defaults.deepcopy()
+        engine_options.set_val(Aircraft.Engine.DATA_FILE,
+                               get_path('models/engines/turbofan_23k_1.deck'))
+        engine_options.set_val(Aircraft.Engine.SCALE_FACTOR,
+                               meta_data[Aircraft.Engine.SCALE_FACTOR]['default_value'])
+        engine_deck = EngineDeck(options=engine_options)
+        preprocess_propulsion(option_defaults, [engine_deck])
+
+    return option_defaults

+
+
+
[docs]def is_option(key, meta_data=_MetaData) -> bool:
+    """
+    Returns True if the variable is defined as an option in the MetaData.
+
+    Parameters
+    ----------
+    key: str
+        Name of the variable to be checked
+    meta_data : dict
+        Dictionary containing metadata for the variable. If None, Aviary's built-in
+        metadata will be used.
+    """
+
+    return meta_data[key]['option']

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/variable_info/variables.html b/_modules/aviary/variable_info/variables.html new file mode 100644 index 000000000..b28e45263 --- /dev/null +++ b/_modules/aviary/variable_info/variables.html @@ -0,0 +1,1225 @@ + + + + + + + + + + + aviary.variable_info.variables + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.variable_info.variables

+'''
+This is a variable hierarchy that is for a single mission. Each mission
+gets a copy of this hierarchy.
+'''
+
+
+# ---------------------------
+# Aircraft data hierarchy
+# ---------------------------
+
[docs]class Aircraft:
+
+
[docs]    class AirConditioning:
+        MASS = 'aircraft:air_conditioning:mass'
+        MASS_SCALER = 'aircraft:air_conditioning:mass_scaler'

+
+
[docs]    class AntiIcing:
+        MASS = 'aircraft:anti_icing:mass'
+        MASS_SCALER = 'aircraft:anti_icing:mass_scaler'

+
+
[docs]    class APU:
+        MASS = 'aircraft:apu:mass'
+        MASS_SCALER = 'aircraft:apu:mass_scaler'

+
+
[docs]    class Avionics:
+        MASS = 'aircraft:avionics:mass'
+        MASS_SCALER = 'aircraft:avionics:mass_scaler'

+
+
[docs]    class BWB:
+        CABIN_AREA = 'aircraft:blended_wing_body_design:cabin_area'
+        NUM_BAYS = 'aircraft:blended_wing_body_design:num_bays'
+
+        PASSENGER_LEADING_EDGE_SWEEP = \
+            'aircraft:blended_wing_body_design:passenger_leading_edge_sweep'

+
+
[docs]    class Canard:
+        AREA = 'aircraft:canard:area'
+        ASPECT_RATIO = 'aircraft:canard:aspect_ratio'
+        CHARACTERISTIC_LENGTH = 'aircraft:canard:characteristic_length'
+        FINENESS = 'aircraft:canard:fineness'
+        LAMINAR_FLOW_LOWER = 'aircraft:canard:laminar_flow_lower'
+        LAMINAR_FLOW_UPPER = 'aircraft:canard:laminar_flow_upper'
+        MASS = 'aircraft:canard:mass'
+        MASS_SCALER = 'aircraft:canard:mass_scaler'
+        TAPER_RATIO = 'aircraft:canard:taper_ratio'
+        THICKNESS_TO_CHORD = 'aircraft:canard:thickness_to_chord'
+        WETTED_AREA = 'aircraft:canard:wetted_area'
+        WETTED_AREA_SCALER = 'aircraft:canard:wetted_area_scaler'

+
+
[docs]    class Controls:
+        COCKPIT_CONTROL_MASS_SCALER = 'aircraft:controls:cockpit_control_mass_scaler'
+        CONTROL_MASS_INCREMENT = 'aircraft:controls:control_mass_increment'
+        STABILITY_AUGMENTATION_SYSTEM_MASS = 'aircraft:controls:stability_augmentation_system_mass'
+        STABILITY_AUGMENTATION_SYSTEM_MASS_SCALER = 'aircraft:controls:stability_augmentation_system_mass_scaler'
+        TOTAL_MASS = 'aircraft:controls:total_mass'

+
+
[docs]    class CrewPayload:
+        BAGGAGE_MASS = 'aircraft:crew_and_payload:baggage_mass'
+
+        BAGGAGE_MASS_PER_PASSENGER = \
+            'aircraft:crew_and_payload:baggage_mass_per_passenger'
+
+        CARGO_CONTAINER_MASS = \
+            'aircraft:crew_and_payload:cargo_container_mass'
+
+        CARGO_CONTAINER_MASS_SCALER = \
+            'aircraft:crew_and_payload:cargo_container_mass_scaler'
+
+        CARGO_MASS = 'aircraft:crew_and_payload:cargo_mass'
+        FLIGHT_CREW_MASS = 'aircraft:crew_and_payload:flight_crew_mass'
+
+        FLIGHT_CREW_MASS_SCALER = \
+            'aircraft:crew_and_payload:flight_crew_mass_scaler'
+
+        MASS_PER_PASSENGER = 'aircraft:crew_and_payload:mass_per_passenger'
+
+        MISC_CARGO = 'aircraft:crew_and_payload:misc_cargo'
+
+        NON_FLIGHT_CREW_MASS = \
+            'aircraft:crew_and_payload:non_flight_crew_mass'
+
+        NON_FLIGHT_CREW_MASS_SCALER = \
+            'aircraft:crew_and_payload:non_flight_crew_mass_scaler'
+
+        NUM_BUSINESS_CLASS = 'aircraft:crew_and_payload:num_business_class'
+        NUM_FIRST_CLASS = 'aircraft:crew_and_payload:num_first_class'
+
+        NUM_FLIGHT_ATTENDANTS = \
+            'aircraft:crew_and_payload:num_flight_attendants'
+
+        NUM_FLIGHT_CREW = 'aircraft:crew_and_payload:num_flight_crew'
+        NUM_GALLEY_CREW = 'aircraft:crew_and_payload:num_galley_crew'
+
+        NUM_PASSENGERS = 'aircraft:crew_and_payload:num_passengers'
+        NUM_TOURIST_CLASS = 'aircraft:crew_and_payload:num_tourist_class'
+
+        PASSENGER_MASS = \
+            'aircraft:crew_and_payload:passenger_mass'
+        PASSENGER_MASS_WITH_BAGS = \
+            'aircraft:crew_and_payload:passenger_mass_with_bags'
+
+        PASSENGER_PAYLOAD_MASS = 'aircraft:crew_and_payload:passenger_payload_mass'
+
+        PASSENGER_SERVICE_MASS = \
+            'aircraft:crew_and_payload:passenger_service_mass'
+
+        PASSENGER_SERVICE_MASS_SCALER = \
+            'aircraft:crew_and_payload:passenger_service_mass_scaler'
+
+        TOTAL_PAYLOAD_MASS = 'aircraft:crew_and_payload:total_payload_mass'
+        WING_CARGO = 'aircraft:crew_and_payload:wing_cargo'

+
+
[docs]    class Design:
+        # These variables are values that do not fall into a particular aircraft
+        # component.
+        BASE_AREA = 'aircraft:design:base_area'
+        CG_DELTA = 'aircraft:design:cg_delta'
+        CHARACTERISTIC_LENGTHS = 'aircraft:design:characteristic_lengths'
+        COCKPIT_CONTROL_MASS_COEFFICIENT = 'aircraft:design:cockpit_control_mass_coefficient'
+        COMPUTE_HTAIL_VOLUME_COEFF = 'aircraft:design:compute_htail_volume_coeff'
+        COMPUTE_VTAIL_VOLUME_COEFF = 'aircraft:design:compute_vtail_volume_coeff'
+        DRAG_COEFFICIENT_INCREMENT = 'aircraft:design:drag_increment'
+        DRAG_POLAR = 'aircraft:design:drag_polar'
+
+        EMPTY_MASS = 'aircraft:design:empty_mass'
+        EMPTY_MASS_MARGIN = 'aircraft:design:empty_mass_margin'
+
+        EMPTY_MASS_MARGIN_SCALER = \
+            'aircraft:design:empty_mass_margin_scaler'
+
+        EQUIPMENT_MASS_COEFFICIENTS = 'aircraft:design:equipment_mass_coefficients'
+        EXTERNAL_SUBSYSTEMS_MASS = 'aircraft:design:external_subsystems_mass'
+        FINENESS = 'aircraft:design:fineness'
+        FIXED_EQUIPMENT_MASS = 'aircraft:design:fixed_equipment_mass'
+        FIXED_USEFUL_LOAD = 'aircraft:design:fixed_useful_load'
+        IJEFF = 'aircraft:design:ijeff'
+        LAMINAR_FLOW_LOWER = 'aircraft:design:laminar_flow_lower'
+        LAMINAR_FLOW_UPPER = 'aircraft:design:laminar_flow_upper'
+
+        LANDING_TO_TAKEOFF_MASS_RATIO = \
+            'aircraft:design:landing_to_takeoff_mass_ratio'
+
+        LIFT_CURVE_SLOPE = 'aircraft:design:lift_curve_slope'
+        LIFT_DEPENDENT_DRAG_COEFF_FACTOR = \
+            'aircraft:design:lift_dependent_drag_coeff_factor'
+        LIFT_POLAR = 'aircraft:design:lift_polar'
+
+        MAX_FUSELAGE_PITCH_ANGLE = 'aircraft:design:max_fuselage_pitch_angle'
+        MAX_STRUCTURAL_SPEED = 'aircraft:design:max_structural_speed'
+        OPERATING_MASS = 'aircraft:design:operating_mass'
+        PART25_STRUCTURAL_CATEGORY = 'aircraft:design:part25_structural_category'
+        RESERVES = 'aircraft:design:reserves'
+        SMOOTH_MASS_DISCONTINUITIES = 'aircraft:design:smooth_mass_discontinuities'
+        STATIC_MARGIN = 'aircraft:design:static_margin'
+        STRUCTURAL_MASS_INCREMENT = 'aircraft:design:structural_mass_increment'
+        STRUCTURE_MASS = 'aircraft:design:structure_mass'
+
+        SUBSONIC_DRAG_COEFF_FACTOR = \
+            'aircraft:design:subsonic_drag_coeff_factor'
+
+        SUPERCRITICAL_DIVERGENCE_SHIFT = 'aircraft:design:supercritical_drag_shift'
+
+        SUPERSONIC_DRAG_COEFF_FACTOR = \
+            'aircraft:design:supersonic_drag_coeff_factor'
+
+        SYSTEMS_EQUIP_MASS = 'aircraft:design:systems_equip_mass'
+        SYSTEMS_EQUIP_MASS_BASE = 'aircraft:design:systems_equip_mass_base'
+        THRUST_TO_WEIGHT_RATIO = 'aircraft:design:thrust_to_weight_ratio'
+        TOTAL_WETTED_AREA = 'aircraft:design:total_wetted_area'
+        TOUCHDOWN_MASS = 'aircraft:design:touchdown_mass'
+        ULF_CALCULATED_FROM_MANEUVER = 'aircraft:design:ulf_calculated_from_maneuver'
+        USE_ALT_MASS = 'aircraft:design:use_alt_mass'
+        WETTED_AREAS = 'aircraft:design:wetted_areas'
+        ZERO_FUEL_MASS = 'aircraft:design:zero_fuel_mass'
+        ZERO_LIFT_DRAG_COEFF_FACTOR = \
+            'aircraft:design:zero_lift_drag_coeff_factor'

+
+
[docs]    class Electrical:
+        HAS_HYBRID_SYSTEM = 'aircraft:electrical:has_hybrid_system'
+        HYBRID_CABLE_LENGTH = 'aircraft:electrical:hybrid_cable_length'
+        MASS = 'aircraft:electrical:mass'
+        MASS_SCALER = 'aircraft:electrical:mass_scaler'

+
+
[docs]    class Engine:
+        ADDITIONAL_MASS = \
+            'aircraft:engine:additional_mass'
+
+        ADDITIONAL_MASS_FRACTION = \
+            'aircraft:engine:additional_mass_fraction'
+
+        CONSTANT_FUEL_CONSUMPTION = 'aircraft:engine:constant_fuel_consumption'
+        CONTROLS_MASS = 'aircraft:engine:controls_mass'
+
+        DATA_FILE = 'aircraft:engine:data_file'
+        FLIGHT_IDLE_MAX_FRACTION = 'aircraft:engine:flight_idle_max_fraction'
+        FLIGHT_IDLE_MIN_FRACTION = 'aircraft:engine:flight_idle_min_fraction'
+        FLIGHT_IDLE_THRUST_FRACTION = 'aircraft:engine:flight_idle_thrust_fraction'
+        FUEL_FLOW_SCALER_CONSTANT_TERM = 'aircraft:engine:fuel_flow_scaler_constant_term'
+        FUEL_FLOW_SCALER_LINEAR_TERM = 'aircraft:engine:fuel_flow_scaler_linear_term'
+        GENERATE_FLIGHT_IDLE = 'aircraft:engine:generate_flight_idle'
+        # GENERATE_STRUCTURED_DATA = 'aircraft:engine:generate_structured_data'
+        GEOPOTENTIAL_ALT = 'aircraft:engine:geopotential_alt'
+        HAS_PROPELLERS = 'aircraft:engine:has_propellers'
+        IGNORE_NEGATIVE_THRUST = 'aircraft:engine:ignore_negative_thrust'
+        INTERPOLATION_METHOD = 'aircraft:engine:interpolation_method'
+        MASS = 'aircraft:engine:mass'
+        MASS_SCALER = 'aircraft:engine:mass_scaler'
+        MASS_SPECIFIC = 'aircraft:engine:mass_specific'
+        MODEL_SLS_THRUST = 'aircraft:engine:model_sls_thrust'
+        NUM_ENGINES = 'aircraft:engine:num_engines'
+        NUM_FUSELAGE_ENGINES = 'aircraft:engine:num_fuselage_engines'
+        NUM_WING_ENGINES = 'aircraft:engine:num_wing_engines'
+        POD_MASS = 'aircraft:engine:pod_mass'
+        POD_MASS_SCALER = 'aircraft:engine:pod_mass_scaler'
+        POSITION_FACTOR = 'aircraft:engine:position_factor'
+        PYLON_FACTOR = 'aircraft:engine:pylon_factor'
+        REFERENCE_DIAMETER = 'aircraft:engine:reference_diameter'
+        REFERENCE_MASS = 'aircraft:engine:reference_mass'
+        REFERENCE_SLS_THRUST = 'aircraft:engine:reference_sls_thrust'
+        SCALE_FACTOR = 'aircraft:engine:scale_factor'
+        SCALE_MASS = 'aircraft:engine:scale_mass'
+        SCALE_PERFORMANCE = 'aircraft:engine:scale_performance'
+        SCALED_SLS_THRUST = 'aircraft:engine:scaled_sls_thrust'
+        STARTER_MASS = 'aircraft:engine:starter_mass'
+        SUBSONIC_FUEL_FLOW_SCALER = 'aircraft:engine:subsonic_fuel_flow_scaler'
+        SUPERSONIC_FUEL_FLOW_SCALER = 'aircraft:engine:supersonic_fuel_flow_scaler'
+
+        THRUST_REVERSERS_MASS = \
+            'aircraft:engine:thrust_reversers_mass'
+
+        THRUST_REVERSERS_MASS_SCALER = \
+            'aircraft:engine:thrust_reversers_mass_scaler'
+
+        TYPE = 'aircraft:engine:type'
+
+        WING_LOCATIONS = \
+            'aircraft:engine:wing_locations'

+
+
[docs]    class Fins:
+        AREA = 'aircraft:fins:area'
+        MASS = 'aircraft:fins:mass'
+        MASS_SCALER = 'aircraft:fins:mass_scaler'
+        NUM_FINS = 'aircraft:fins:num_fins'
+        TAPER_RATIO = 'aircraft:fins:taper_ratio'

+
+
[docs]    class Fuel:
+        AUXILIARY_FUEL_CAPACITY = 'aircraft:fuel:auxiliary_fuel_capacity'
+        BURN_PER_PASSENGER_MILE = 'aircraft:fuel:burn_per_passenger_mile'
+        CAPACITY_FACTOR = 'aircraft:fuel:capacity_factor'
+        DENSITY = 'aircraft:fuel:density'
+        DENSITY_RATIO = 'aircraft:fuel:density_ratio'
+        FUEL_MARGIN = 'aircraft:fuel:fuel_margin'
+        FUEL_SYSTEM_MASS = 'aircraft:fuel:fuel_system_mass'
+        FUEL_SYSTEM_MASS_COEFFICIENT = 'aircraft:fuel:fuel_system_mass_coefficient'
+        FUEL_SYSTEM_MASS_SCALER = 'aircraft:fuel:fuel_system_mass_scaler'
+        FUSELAGE_FUEL_CAPACITY = 'aircraft:fuel:fuselage_fuel_capacity'
+        NUM_TANKS = 'aircraft:fuel:num_tanks'
+        TOTAL_CAPACITY = 'aircraft:fuel:total_capacity'
+        TOTAL_VOLUME = 'aircraft:fuel:total_volume'
+        UNUSABLE_FUEL_MASS = 'aircraft:fuel:unusable_fuel_mass'
+
+        UNUSABLE_FUEL_MASS_SCALER = \
+            'aircraft:fuel:unusable_fuel_mass_scaler'
+
+        WING_FUEL_CAPACITY = 'aircraft:fuel:wing_fuel_capacity'
+        WING_FUEL_FRACTION = 'aircraft:fuel:wing_fuel_fraction'
+        WING_REF_CAPACITY = 'aircraft:fuel:wing_ref_capacity'
+        WING_REF_CAPACITY_AREA = 'aircraft:fuel:wing_ref_capacity_area'
+        WING_REF_CAPACITY_TERM_A = 'aircraft:fuel:wing_ref_capacity_term_A'
+        WING_REF_CAPACITY_TERM_B = 'aircraft:fuel:wing_ref_capacity_term_B'
+        # WING_VOLUME = 'aircraft:fuel:wing_volume'
+        WING_VOLUME_DESIGN = 'aircraft:fuel:wing_volume_design'
+        WING_VOLUME_GEOMETRIC_MAX = 'aircraft:fuel:wing_volume_geometric_max'
+        WING_VOLUME_STRUCTURAL_MAX = 'aircraft:fuel:wing_volume_structural_max'

+
+
[docs]    class Furnishings:
+        MASS = 'aircraft:furnishings:mass'
+        MASS_BASE = 'aircraft:furnishings:mass_base'
+        MASS_SCALER = 'aircraft:furnishings:mass_scaler'

+
+
[docs]    class Fuselage:
+        AISLE_WIDTH = 'aircraft:fuselage:aisle_width'
+        AVG_DIAMETER = 'aircraft:fuselage:avg_diameter'
+        CHARACTERISTIC_LENGTH = 'aircraft:fuselage:characteristic_length'
+        CROSS_SECTION = 'aircraft:fuselage:cross_section'
+        DELTA_DIAMETER = 'aircraft:fuselage:delta_diameter'
+        DIAMETER_TO_WING_SPAN = 'aircraft:fuselage:diameter_to_wing_span'
+        FINENESS = 'aircraft:fuselage:fineness'
+        FLAT_PLATE_AREA_INCREMENT = 'aircraft:fuselage:flat_plate_area_increment'
+        FORM_FACTOR = 'aircraft:fuselage:form_factor'
+        LAMINAR_FLOW_LOWER = 'aircraft:fuselage:laminar_flow_lower'
+        LAMINAR_FLOW_UPPER = 'aircraft:fuselage:laminar_flow_upper'
+        LENGTH = 'aircraft:fuselage:length'
+        LENGTH_TO_DIAMETER = 'aircraft:fuselage:length_to_diameter'
+        MASS = 'aircraft:fuselage:mass'
+        MASS_COEFFICIENT = 'aircraft:fuselage:mass_coefficient'
+        MASS_SCALER = 'aircraft:fuselage:mass_scaler'
+        MAX_HEIGHT = 'aircraft:fuselage:max_height'
+        MAX_WIDTH = 'aircraft:fuselage:max_width'
+        MILITARY_CARGO_FLOOR = 'aircraft:fuselage:military_cargo_floor'
+        NOSE_FINENESS = 'aircraft:fuselage:nose_fineness'
+        NUM_AISLES = 'aircraft:fuselage:num_aisles'
+        NUM_FUSELAGES = 'aircraft:fuselage:num_fuselages'
+        NUM_SEATS_ABREAST = 'aircraft:fuselage:num_seats_abreast'
+
+        PASSENGER_COMPARTMENT_LENGTH = \
+            'aircraft:fuselage:passenger_compartment_length'
+
+        PILOT_COMPARTMENT_LENGTH = 'aircraft:fuselage:pilot_compartment_length'
+        PLANFORM_AREA = 'aircraft:fuselage:planform_area'
+        PRESSURE_DIFFERENTIAL = 'aircraft:fuselage:pressure_differential'
+        PROVIDE_SURFACE_AREA = 'aircraft:fuselage:provide_surface_area'
+        SEAT_PITCH = 'aircraft:fuselage:seat_pitch'
+        SEAT_WIDTH = 'aircraft:fuselage:seat_width'
+        TAIL_FINENESS = 'aircraft:fuselage:tail_fineness'
+        WETTED_AREA = 'aircraft:fuselage:wetted_area'
+        WETTED_AREA_FACTOR = 'aircraft:fuselage:wetted_area_factor'
+        WETTED_AREA_SCALER = 'aircraft:fuselage:wetted_area_scaler'

+
+
[docs]    class HorizontalTail:
+        AREA = 'aircraft:horizontal_tail:area'
+        ASPECT_RATIO = 'aircraft:horizontal_tail:aspect_ratio'
+        AVERAGE_CHORD = 'aircraft:horizontal_tail:average_chord'
+
+        CHARACTERISTIC_LENGTH = \
+            'aircraft:horizontal_tail:characteristic_length'
+
+        FINENESS = 'aircraft:horizontal_tail:fineness'
+        FORM_FACTOR = 'aircraft:horizontal_tail:form_factor'
+        LAMINAR_FLOW_LOWER = 'aircraft:horizontal_tail:laminar_flow_lower'
+        LAMINAR_FLOW_UPPER = 'aircraft:horizontal_tail:laminar_flow_upper'
+        MASS = 'aircraft:horizontal_tail:mass'
+        MASS_COEFFICIENT = 'aircraft:horizontal_tail:mass_coefficient'
+        MASS_SCALER = 'aircraft:horizontal_tail:mass_scaler'
+        MOMENT_ARM = 'aircraft:horizontal_tail:moment_arm'
+        MOMENT_RATIO = 'aircraft:horizontal_tail:moment_ratio'
+        ROOT_CHORD = 'aircraft:horizontal_tail:root_chord'
+        SPAN = 'aircraft:horizontal_tail:span'
+        SWEEP = 'aircraft:horizontal_tail:sweep'
+        TAPER_RATIO = 'aircraft:horizontal_tail:taper_ratio'
+        THICKNESS_TO_CHORD = 'aircraft:horizontal_tail:thickness_to_chord'
+
+        VERTICAL_TAIL_FRACTION = \
+            'aircraft:horizontal_tail:vertical_tail_fraction'
+
+        VOLUME_COEFFICIENT = 'aircraft:horizontal_tail:volume_coefficient'
+        WETTED_AREA = 'aircraft:horizontal_tail:wetted_area'
+        WETTED_AREA_SCALER = 'aircraft:horizontal_tail:wetted_area_scaler'

+
+
[docs]    class Hydraulics:
+        MASS = 'aircraft:hydraulics:mass'
+        MASS_SCALER = 'aircraft:hydraulics:mass_scaler'
+        SYSTEM_PRESSURE = 'aircraft:hydraulics:system_pressure'

+
+
[docs]    class Instruments:
+        MASS = 'aircraft:instruments:mass'
+        MASS_SCALER = 'aircraft:instruments:mass_scaler'

+
+
[docs]    class LandingGear:
+        CARRIER_BASED = 'aircraft:landing_gear:carrier_based'
+        DRAG_COEFFICIENT = 'aircraft:landing_gear:drag_coefficient'
+        FIXED_GEAR = 'aircraft:landing_gear:fixed_gear'
+        MAIN_GEAR_LOCATION = 'aircraft:landing_gear:main_gear_location'
+        MAIN_GEAR_MASS = 'aircraft:landing_gear:main_gear_mass'
+        MAIN_GEAR_MASS_COEFFICIENT = 'aircraft:landing_gear:main_gear_mass_coefficient'
+        MAIN_GEAR_MASS_SCALER = \
+            'aircraft:landing_gear:main_gear_mass_scaler'
+        MAIN_GEAR_OLEO_LENGTH = 'aircraft:landing_gear:main_gear_oleo_length'
+
+        MASS_COEFFICIENT = 'aircraft:landing_gear:mass_coefficient'
+
+        NOSE_GEAR_MASS = 'aircraft:landing_gear:nose_gear_mass'
+        NOSE_GEAR_MASS_SCALER = \
+            'aircraft:landing_gear:nose_gear_mass_scaler'
+        NOSE_GEAR_OLEO_LENGTH = 'aircraft:landing_gear:nose_gear_oleo_length'
+
+        TAIL_HOOK_MASS_SCALER = 'aircraft:landing_gear:tail_hook_mass_scaler'
+        TOTAL_MASS = 'aircraft:landing_gear:total_mass'
+        TOTAL_MASS_SCALER = 'aircraft:landing_gear:total_mass_scaler'

+
+
[docs]    class Nacelle:
+        AVG_DIAMETER = 'aircraft:nacelle:avg_diameter'
+        AVG_LENGTH = 'aircraft:nacelle:avg_length'
+        CHARACTERISTIC_LENGTH = 'aircraft:nacelle:characteristic_length'
+        CLEARANCE_RATIO = 'aircraft:nacelle:clearance_ratio'
+        CORE_DIAMETER_RATIO = 'aircraft:nacelle:core_diameter_ratio'
+        FINENESS = 'aircraft:nacelle:fineness'
+        FORM_FACTOR = 'aircraft:nacelle:form_factor'
+        LAMINAR_FLOW_LOWER = 'aircraft:nacelle:laminar_flow_lower'
+        LAMINAR_FLOW_UPPER = 'aircraft:nacelle:laminar_flow_upper'
+        MASS = 'aircraft:nacelle:mass'
+        MASS_SCALER = 'aircraft:nacelle:mass_scaler'
+        MASS_SPECIFIC = 'aircraft:nacelle:mass_specific'
+        SURFACE_AREA = 'aircraft:nacelle:surface_area'
+        TOTAL_WETTED_AREA = 'aircraft:nacelle:total_wetted_area'
+        WETTED_AREA = 'aircraft:nacelle:wetted_area'
+        WETTED_AREA_SCALER = 'aircraft:nacelle:wetted_area_scaler'

+
+
[docs]    class Paint:
+        MASS = 'aircraft:paint:mass'
+        MASS_PER_UNIT_AREA = 'aircraft:paint:mass_per_unit_area'

+
+
[docs]    class Propulsion:
+        ENGINE_OIL_MASS_SCALER = \
+            'aircraft:propulsion:engine_oil_mass_scaler'
+
+        MASS = 'aircraft:propulsion:mass'
+        MISC_MASS_SCALER = 'aircraft:propulsion:misc_mass_scaler'
+        TOTAL_ENGINE_CONTROLS_MASS = 'aircraft:propulsion:total_engine_controls_mass'
+        TOTAL_ENGINE_MASS = 'aircraft:propulsion:total_engine_mass'
+        TOTAL_ENGINE_OIL_MASS = 'aircraft:propulsion:total_engine_oil_mass'
+        TOTAL_ENGINE_POD_MASS = 'aircraft:propulsion:total_engine_pod_mass'
+        TOTAL_MISC_MASS = 'aircraft:propulsion:total_misc_mass'
+        TOTAL_NUM_ENGINES = 'aircraft:propulsion:total_num_engines'
+        TOTAL_NUM_FUSELAGE_ENGINES = 'aircraft:propulsion:total_num_fuselage_engines'
+        TOTAL_NUM_WING_ENGINES = 'aircraft:propulsion:total_num_wing_engines'
+        TOTAL_REFERENCE_SLS_THRUST = 'aircraft:propulsion:total_reference_sls_thrust'
+        TOTAL_SCALED_SLS_THRUST = 'aircraft:propulsion:total_scaled_sls_thrust'
+        TOTAL_STARTER_MASS = 'aircraft:propulsion:total_starter_mass'
+
+        TOTAL_THRUST_REVERSERS_MASS = \
+            'aircraft:propulsion:total_thrust_reversers_mass'

+
+
[docs]    class Strut:
+        AREA = 'aircraft:strut:area'
+        AREA_RATIO = 'aircraft:strut:area_ratio'
+        ATTACHMENT_LOCATION = 'aircraft:strut:attachment_location'
+        ATTACHMENT_LOCATION_DIMENSIONLESS = 'aircraft:strut:attachment_location_dimensionless'
+        CHORD = 'aircraft:strut:chord'
+        DIMENSIONAL_LOCATION_SPECIFIED = 'aircraft:strut:dimensional_location_specified'
+        FUSELAGE_INTERFERENCE_FACTOR = 'aircraft:strut:fuselage_interference_factor'
+        LENGTH = 'aircraft:strut:length'
+        MASS = 'aircraft:strut:mass'
+        MASS_COEFFICIENT = 'aircraft:strut:mass_coefficient'
+        THICKNESS_TO_CHORD = 'aircraft:strut:thickness_to_chord'

+
+
[docs]    class TailBoom:
+        LENGTH = 'aircraft:tail_boom:length'

+
+
[docs]    class VerticalTail:
+        AREA = 'aircraft:vertical_tail:area'
+        ASPECT_RATIO = 'aircraft:vertical_tail:aspect_ratio'
+        AVERAGE_CHORD = 'aircraft:vertical_tail:average_chord'
+        CHARACTERISTIC_LENGTH = 'aircraft:vertical_tail:characteristic_length'
+        FINENESS = 'aircraft:vertical_tail:fineness'
+        FORM_FACTOR = 'aircraft:vertical_tail:form_factor'
+        LAMINAR_FLOW_LOWER = 'aircraft:vertical_tail:laminar_flow_lower'
+        LAMINAR_FLOW_UPPER = 'aircraft:vertical_tail:laminar_flow_upper'
+        MASS = 'aircraft:vertical_tail:mass'
+        MASS_COEFFICIENT = 'aircraft:vertical_tail:mass_coefficient'
+        MASS_SCALER = 'aircraft:vertical_tail:mass_scaler'
+        MOMENT_ARM = 'aircraft:vertical_tail:moment_arm'
+        MOMENT_RATIO = 'aircraft:vertical_tail:moment_ratio'
+        NUM_TAILS = 'aircraft:vertical_tail:num_tails'
+        ROOT_CHORD = 'aircraft:vertical_tail:root_chord'
+        SPAN = 'aircraft:vertical_tail:span'
+        SWEEP = 'aircraft:vertical_tail:sweep'
+        TAPER_RATIO = 'aircraft:vertical_tail:taper_ratio'
+        THICKNESS_TO_CHORD = 'aircraft:vertical_tail:thickness_to_chord'
+        VOLUME_COEFFICIENT = 'aircraft:vertical_tail:volume_coefficient'
+        WETTED_AREA = 'aircraft:vertical_tail:wetted_area'
+        WETTED_AREA_SCALER = 'aircraft:vertical_tail:wetted_area_scaler'

+
+
[docs]    class Wing:
+        AEROELASTIC_TAILORING_FACTOR = \
+            'aircraft:wing:aeroelastic_tailoring_factor'
+
+        AIRFOIL_TECHNOLOGY = 'aircraft:wing:airfoil_technology'
+        AREA = 'aircraft:wing:area'
+        ASPECT_RATIO = 'aircraft:wing:aspect_ratio'
+        ASPECT_RATIO_REF = 'aircraft:wing:aspect_ratio_reference'
+        AVERAGE_CHORD = 'aircraft:wing:average_chord'
+        BENDING_FACTOR = 'aircraft:wing:bending_factor'
+        BENDING_MASS = 'aircraft:wing:bending_mass'
+        BENDING_MASS_NO_INERTIA = 'aircraft:wing:bending_mass_no_inertia'
+        BENDING_MASS_SCALER = 'aircraft:wing:bending_mass_scaler'
+        BWB_AFTBODY_MASS = 'aircraft:wing:bwb_aft_body_mass'
+        BWB_AFTBODY_MASS_SCALER = 'aircraft:wing:bwb_aft_body_mass_scaler'
+        CENTER_CHORD = 'aircraft:wing:center_chord'
+        CENTER_DISTANCE = 'aircraft:wing:center_distance'
+        CHARACTERISTIC_LENGTH = 'aircraft:wing:characteristic_length'
+        CHOOSE_FOLD_LOCATION = 'aircraft:wing:choose_fold_location'
+        CHORD_PER_SEMISPAN_DIST = 'aircraft:wing:chord_per_semispan'
+        COMPOSITE_FRACTION = 'aircraft:wing:composite_fraction'
+        CONTROL_SURFACE_AREA = 'aircraft:wing:control_surface_area'
+        CONTROL_SURFACE_AREA_RATIO = 'aircraft:wing:control_surface_area_ratio'
+        DETAILED_WING = 'aircraft:wing:detailed_wing'
+        DIHEDRAL = 'aircraft:wing:dihedral'
+        ENG_POD_INERTIA_FACTOR = 'aircraft:wing:eng_pod_inertia_factor'
+        FINENESS = 'aircraft:wing:fineness'
+        FLAP_CHORD_RATIO = 'aircraft:wing:flap_chord_ratio'
+        FLAP_DEFLECTION_LANDING = 'aircraft:wing:flap_deflection_landing'
+        FLAP_DEFLECTION_TAKEOFF = 'aircraft:wing:flap_deflection_takeoff'
+        FLAP_DRAG_INCREMENT_OPTIMUM = 'aircraft:wing:flap_drag_increment_optimum'
+        FLAP_LIFT_INCREMENT_OPTIMUM = 'aircraft:wing:flap_lift_increment_optimum'
+        FLAP_SPAN_RATIO = 'aircraft:wing:flap_span_ratio'
+        FLAP_TYPE = 'aircraft:wing:flap_type'
+        FOLD_DIMENSIONAL_LOCATION_SPECIFIED = 'aircraft:wing:fold_dimensional_location_specified'
+        FOLD_MASS = 'aircraft:wing:fold_mass'
+        FOLD_MASS_COEFFICIENT = 'aircraft:wing:fold_mass_coefficient'
+        FOLDED_SPAN = 'aircraft:wing:folded_span'
+        FOLDED_SPAN_DIMENSIONLESS = 'aircraft:wing:folded_span_dimensionless'
+        FOLDING_AREA = 'aircraft:wing:folding_area'
+        FORM_FACTOR = 'aircraft:wing:form_factor'
+        FUSELAGE_INTERFERENCE_FACTOR = 'aircraft:wing:fuselage_interference_factor'
+        GLOVE_AND_BAT = 'aircraft:wing:glove_and_bat'
+        HAS_FOLD = 'aircraft:wing:has_fold'
+        HAS_STRUT = 'aircraft:wing:has_strut'
+        HEIGHT = 'aircraft:wing:height'
+        HIGH_LIFT_MASS = 'aircraft:wing:high_lift_mass'
+        HIGH_LIFT_MASS_COEFFICIENT = 'aircraft:wing:high_lift_mass_coefficient'
+        INCIDENCE = 'aircraft:wing:incidence'
+        INPUT_STATION_DIST = 'aircraft:wing:input_station_dist'
+        LAMINAR_FLOW_LOWER = 'aircraft:wing:laminar_flow_lower'
+        LAMINAR_FLOW_UPPER = 'aircraft:wing:laminar_flow_upper'
+        LEADING_EDGE_SWEEP = 'aircraft:wing:leading_edge_sweep'
+        LOAD_DISTRIBUTION_CONTROL = 'aircraft:wing:load_distribution_control'
+        LOAD_FRACTION = 'aircraft:wing:load_fraction'
+        LOAD_PATH_SWEEP_DIST = 'aircraft:wing:load_path_sweep_dist'
+        LOADING = 'aircraft:wing:loading'
+        LOADING_ABOVE_20 = 'aircraft:wing:loading_above_20'
+        MASS = 'aircraft:wing:mass'
+        MASS_COEFFICIENT = 'aircraft:wing:mass_coefficient'
+        MASS_SCALER = 'aircraft:wing:mass_scaler'
+        MATERIAL_FACTOR = 'aircraft:wing:material_factor'
+        MAX_CAMBER_AT_70_SEMISPAN = 'aircraft:wing:max_camber_at_70_semispan'
+        MAX_LIFT_REF = 'aircraft:wing:max_lift_ref'
+        MAX_SLAT_DEFLECTION_LANDING = 'aircraft:wing:max_slat_deflection_landing'
+        MAX_SLAT_DEFLECTION_TAKEOFF = 'aircraft:wing:max_slat_deflection_takeoff'
+        MAX_THICKNESS_LOCATION = 'aircraft:wing:max_thickness_location'
+        MIN_PRESSURE_LOCATION = 'aircraft:wing:min_pressure_location'
+        MISC_MASS = 'aircraft:wing:misc_mass'
+        MISC_MASS_SCALER = 'aircraft:wing:misc_mass_scaler'
+        MOUNTING_TYPE = 'aircraft:wing:mounting_type'
+        NUM_FLAP_SEGMENTS = 'aircraft:wing:num_flap_segments'
+        NUM_INTEGRATION_STATIONS = 'aircraft:wing:num_integration_stations'
+        OPTIMUM_FLAP_DEFLECTION = 'aircraft:wing:optimum_flap_deflection'
+        OPTIMUM_SLAT_DEFLECTION = 'aircraft:wing:optimum_slat_deflection'
+        ROOT_CHORD = 'aircraft:wing:root_chord'
+        SHEAR_CONTROL_MASS = 'aircraft:wing:shear_control_mass'
+
+        SHEAR_CONTROL_MASS_SCALER = \
+            'aircraft:wing:shear_control_mass_scaler'
+
+        SLAT_CHORD_RATIO = 'aircraft:wing:slat_chord_ratio'
+        SLAT_LIFT_INCREMENT_OPTIMUM = 'aircraft:wing:slat_lift_increment_optimum'
+        SLAT_SPAN_RATIO = 'aircraft:wing:slat_span_ratio'
+        SPAN = 'aircraft:wing:span'
+        SPAN_EFFICIENCY_FACTOR = 'aircraft:wing:span_efficiency_factor'
+        SPAN_EFFICIENCY_REDUCTION = 'aircraft:wing:span_efficiency_reduction'
+        STRUT_BRACING_FACTOR = 'aircraft:wing:strut_bracing_factor'
+        SURFACE_CONTROL_MASS = 'aircraft:wing:surface_ctrl_mass'
+        SURFACE_CONTROL_MASS_COEFFICIENT = 'aircraft:wing:surface_ctrl_mass_coefficient'
+
+        SURFACE_CONTROL_MASS_SCALER = \
+            'aircraft:wing:surface_ctrl_mass_scaler'
+
+        SWEEP = 'aircraft:wing:sweep'
+        TAPER_RATIO = 'aircraft:wing:taper_ratio'
+        THICKNESS_TO_CHORD = 'aircraft:wing:thickness_to_chord'
+        THICKNESS_TO_CHORD_DIST = 'aircraft:wing:thickness_to_chord_dist'
+        THICKNESS_TO_CHORD_REF = 'aircraft:wing:thickness_to_chord_reference'
+        THICKNESS_TO_CHORD_ROOT = 'aircraft:wing:thickness_to_chord_root'
+        THICKNESS_TO_CHORD_TIP = 'aircraft:wing:thickness_to_chord_tip'
+        THICKNESS_TO_CHORD_UNWEIGHTED = 'aircraft:wing:thickness_to_chord_unweighted'
+        ULTIMATE_LOAD_FACTOR = 'aircraft:wing:ultimate_load_factor'
+        VAR_SWEEP_MASS_PENALTY = 'aircraft:wing:var_sweep_mass_penalty'
+        WETTED_AREA = 'aircraft:wing:wetted_area'
+        WETTED_AREA_SCALER = 'aircraft:wing:wetted_area_scaler'
+        ZERO_LIFT_ANGLE = 'aircraft:wing:zero_lift_angle'

+
+
+
[docs]class Dynamic:
+
+
[docs]    class Mission:
+        # all time-dependent variables used during mission analysis
+        ALTITUDE = 'altitude'
+        ALTITUDE_RATE = 'altitude_rate'
+        ALTITUDE_RATE_MAX = 'altitude_rate_max'
+        DENSITY = 'density'
+        DISTANCE = 'distance'
+        DISTANCE_RATE = 'distance_rate'
+        DRAG = 'drag'
+        DYNAMIC_PRESSURE = 'dynamic_pressure'
+        ELECTRIC_POWER = 'electric_power'
+        ELECTRIC_POWER_TOTAL = 'electric_power_total'
+        # EXIT_AREA = 'exit_area'
+        FLIGHT_PATH_ANGLE = 'flight_path_angle'
+        FLIGHT_PATH_ANGLE_RATE = 'flight_path_angle_rate'
+        FUEL_FLOW_RATE = 'fuel_flow_rate'
+        FUEL_FLOW_RATE_NEGATIVE = 'fuel_flow_rate_negative'
+        FUEL_FLOW_RATE_NEGATIVE_TOTAL = 'fuel_flow_rate_negative_total'
+        FUEL_FLOW_RATE_TOTAL = 'fuel_flow_rate_total'
+        HYBRID_THROTTLE = 'hybrid_throttle'
+        LIFT = 'lift'
+        MACH = 'mach'
+        MACH_RATE = 'mach_rate'
+        MASS = 'mass'
+        MASS_RATE = 'mass_rate'
+        NOX_RATE = 'nox_rate'
+        NOX_RATE_TOTAL = 'nox_rate_total'
+        RANGE = 'range'
+        RANGE_RATE = 'range_rate'
+        SPECIFIC_ENERGY = 'specific_energy'
+        SPECIFIC_ENERGY_RATE = 'specific_energy_rate'
+        SPECIFIC_ENERGY_RATE_EXCESS = 'specific_energy_rate_excess'
+        SPEED_OF_SOUND = 'speed_of_sound'
+        STATIC_PRESSURE = 'static_pressure'
+        TEMPERATURE = 'temperature'
+        TEMPERATURE_ENGINE_T4 = 't4'
+        THROTTLE = 'throttle'
+        THRUST = 'thrust_net'
+        THRUST_MAX = 'thrust_net_max'
+        THRUST_MAX_TOTAL = 'thrust_net_max_total'
+        THRUST_TOTAL = 'thrust_net_total'
+        VELOCITY = 'velocity'
+        VELOCITY_RATE = 'velocity_rate'

+
+
+
[docs]class Mission:
+
+
[docs]    class Constraints:
+        # these can be residuals (for equality constraints),
+        # upper bounds, or lower bounds
+        MASS_RESIDUAL = 'mission:constraints:mass_residual'
+        MAX_MACH = 'mission:constraints:max_mach'
+        RANGE_RESIDUAL = 'mission:constraints:range_residual'

+
+
[docs]    class Design:
+        # These values MAY change in design mission, but in off-design
+        # they cannot change. In a design mission these are either user inputs
+        # or calculated outputs, in off-design they are strictly inputs
+        # and do not change.
+        CRUISE_ALTITUDE = 'mission:design:cruise_altitude'
+        CRUISE_RANGE = 'mission:design:cruise_range'
+        FUEL_MASS = 'mission:design:fuel_mass'
+        FUEL_MASS_REQUIRED = 'mission:design:fuel_mass_required'
+        GROSS_MASS = 'mission:design:gross_mass'
+        LIFT_COEFFICIENT = 'mission:design:lift_coefficient'
+        LIFT_COEFFICIENT_MAX_FLAPS_UP = 'mission:design:lift_coefficient_max_flaps_up'
+        MACH = 'mission:design:mach'
+        RANGE = 'mission:design:range'
+        RATE_OF_CLIMB_AT_TOP_OF_CLIMB = 'mission:design:rate_of_climb_at_top_of_climb'
+        RESERVE_FUEL = 'mission:design:reserve_fuel'
+        THRUST_TAKEOFF_PER_ENG = 'mission:design:thrust_takeoff_per_eng'

+
+
[docs]    class Landing:
+        # These are values which have to do with landing
+        AIRPORT_ALTITUDE = 'mission:landing:airport_altitude'
+        BRAKING_DELAY = 'mission:landing:braking_delay'
+        BRAKING_FRICTION_COEFFICIENT = 'mission:landing:braking_friction_coefficient'
+        DRAG_COEFFICIENT = 'mission:landing:drag_coefficient'
+
+        DRAG_COEFFICIENT_FLAP_INCREMENT = \
+            'mission:landing:drag_coefficient_flap_increment'
+
+        FIELD_LENGTH = 'mission:landing:field_length'
+        FLARE_RATE = 'mission:landing:flare_rate'
+        GLIDE_TO_STALL_RATIO = 'mission:landing:glide_to_stall_ratio'
+        GROUND_DISTANCE = 'mission:landing:ground_distance'
+        INITIAL_ALTITUDE = 'mission:landing:initial_altitude'
+        INITIAL_MACH = 'mission:landing:initial_mach'
+        INITIAL_VELOCITY = 'mission:landing:initial_velocity'
+
+        LIFT_COEFFICIENT_FLAP_INCREMENT = \
+            'mission:landing:lift_coefficient_flap_increment'
+
+        LIFT_COEFFICIENT_MAX = 'mission:landing:lift_coefficient_max'
+        MAXIMUM_FLARE_LOAD_FACTOR = 'mission:landing:maximum_flare_load_factor'
+        MAXIMUM_SINK_RATE = 'mission:landing:maximum_sink_rate'
+        OBSTACLE_HEIGHT = 'mission:landing:obstacle_height'
+        ROLLING_FRICTION_COEFFICIENT = 'mission:landing:rolling_friction_coefficient'
+        SPOILER_DRAG_COEFFICIENT = 'mission:landing:spoiler_drag_coefficient'
+        SPOILER_LIFT_COEFFICIENT = 'mission:landing:spoiler_lift_coefficient'
+        STALL_VELOCITY = 'mission:landing:stall_velocity'
+        TOUCHDOWN_MASS = 'mission:landing:touchdown_mass'
+        TOUCHDOWN_SINK_RATE = 'mission:landing:touchdown_sink_rate'

+
+
[docs]    class Objectives:
+        # these are values that can be fed to the optimizer as objectives,
+        # they may often be composite and/or regularized
+        FUEL = 'mission:objectives:fuel'
+        RANGE = 'mission:objectives:range'

+
+
[docs]    class Summary:
+        # These values are inputs and outputs to/from dynamic analysis
+        # for the given mission (whether it is design or off-design).
+        # In on-design these may be constrained to design values, but
+        # in off-design they independently represent the final analysis
+        # based on the user-selection.
+        CRUISE_MACH = 'mission:summary:cruise_mach'
+        CRUISE_MASS_FINAL = 'mission:summary:cruise_mass_final'
+        FUEL_FLOW_SCALER = 'mission:summary:fuel_flow_scaler'
+        GROSS_MASS = 'mission:summary:gross_mass'
+        RANGE = 'mission:summary:range'
+        TOTAL_FUEL_MASS = 'mission:summary:total_fuel_mass'

+
+
[docs]    class Takeoff:
+        # These are values which have to do with takeoff
+        AIRPORT_ALTITUDE = 'mission:takeoff:airport_altitude'
+        ANGLE_OF_ATTACK_RUNWAY = 'mission:takeoff:angle_of_attack_runway'
+        ASCENT_DURATION = 'mission:takeoff:ascent_duration'
+        ASCENT_T_INTIIAL = 'mission:takeoff:ascent_t_initial'
+        BRAKING_FRICTION_COEFFICIENT = 'mission:takeoff:braking_friction_coefficient'
+        DECISION_SPEED_INCREMENT = 'mission:takeoff:decision_speed_increment'
+
+        DRAG_COEFFICIENT_FLAP_INCREMENT = \
+            'mission:takeoff:drag_coefficient_flap_increment'
+
+        DRAG_COEFFICIENT_MIN = 'mission:takeoff:drag_coefficient_min'
+        FIELD_LENGTH = 'mission:takeoff:field_length'
+        FINAL_ALTITUDE = 'mission:takeoff:final_altitude'
+        FINAL_MASS = 'mission:takeoff:final_mass'
+        FINAL_VELOCITY = 'mission:takeoff:final_velocity'
+        FUEL_SIMPLE = 'mission:takeoff:fuel_simple'
+        GROUND_DISTANCE = 'mission:takeoff:ground_distance'
+
+        LIFT_COEFFICIENT_FLAP_INCREMENT = \
+            'mission:takeoff:lift_coefficient_flap_increment'
+
+        LIFT_COEFFICIENT_MAX = 'mission:takeoff:lift_coefficient_max'
+        LIFT_OVER_DRAG = 'mission:takeoff:lift_over_drag'
+        OBSTACLE_HEIGHT = 'mission:takeoff:obstacle_height'
+        ROLLING_FRICTION_COEFFICIENT = 'mission:takeoff:rolling_friction_coefficient'
+        ROTATION_SPEED_INCREMENT = 'mission:takeoff:rotation_speed_increment'
+        ROTATION_VELOCITY = 'mission:takeoff:rotation_velocity'
+        SPOILER_DRAG_COEFFICIENT = 'mission:takeoff:spoiler_drag_coefficient'
+        SPOILER_LIFT_COEFFICIENT = 'mission:takeoff:spoiler_lift_coefficient'
+        THRUST_INCIDENCE = 'mission:takeoff:thrust_incidence'

+
+
[docs]    class Taxi:
+        DURATION = 'mission:taxi:duration'
+        MACH = 'mission:taxi:mach'

+
+
+
[docs]class Settings:
+    EQUATIONS_OF_MOTION = 'settings:equations_of_motion'
+    MASS_METHOD = 'settings:mass_method'
+    VERBOSITY = 'settings:verbosity'

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/aviary/variable_info/variables_in.html b/_modules/aviary/variable_info/variables_in.html new file mode 100644 index 000000000..62eca6929 --- /dev/null +++ b/_modules/aviary/variable_info/variables_in.html @@ -0,0 +1,547 @@ + + + + + + + + + + + aviary.variable_info.variables_in + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

Source code for aviary.variable_info.variables_in

+'''
+Dummy explicit component which serves as an input port for all variables in
+the aircraft and mission hierarchy.
+'''
+import openmdao.api as om
+
+from aviary.utils.aviary_values import AviaryValues
+from aviary.variable_info.functions import add_aviary_input
+from aviary.variable_info.variable_meta_data import _MetaData
+from aviary.variable_info.functions import add_aviary_input
+from aviary.variable_info.core_promotes import core_mission_inputs
+
+
+
[docs]class VariablesIn(om.ExplicitComponent):
+    '''
+    Provides a central place to connect input variable information to a component
+    but doesn't actually do anything on its own.
+    '''
+
+
[docs]    def initialize(self):
+        self.options.declare(
+            'aviary_options', types=AviaryValues,
+            desc='collection of Aircraft/Mission specific options')
+        self.options.declare(
+            'meta_data', types=dict, default=_MetaData,
+            desc='variable metadata associated with the variables to be passed through this port'
+        )
+        self.options.declare(
+            'context', default='full', values=['full', 'mission'],
+            desc='Limit to a subset of the aircraft and mission variables.'
+        )

+
+
[docs]    def setup(self):
+        aviary_options: AviaryValues = self.options['aviary_options']
+        meta_data = self.options['meta_data']
+        context = self.options['context']
+
+        if context == 'mission':
+            inputs = core_mission_inputs
+        else:
+            inputs = meta_data
+
+        for key in inputs:
+            # TODO temp line to ignore dynamic mission variables, will not work
+            #      if names change to 'dynamic:mission:*'
+            if ':' not in key:
+                continue
+            info = meta_data[key]
+
+            if not info['option'] and ('aircraft:' in key or 'mission:' in key):
+                # Since all the variable initial values are stored in aviary_options,
+                # we can use the initial values to get the correct shape.
+                val = info['default_value']
+                if val is None:
+                    val = 0.0
+                item = val, info['units']
+                val, units = aviary_options.get_item(key, item)
+                if units == 'unitless' and info['units'] != 'unitless':
+                    units = info['units']
+                add_aviary_input(self, key, val=val, units=units, meta_data=meta_data)

+
+ +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_modules/index.html b/_modules/index.html new file mode 100644 index 000000000..f5d6f869b --- /dev/null +++ b/_modules/index.html @@ -0,0 +1,515 @@ + + + + + + + + + + + Overview: module code + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

+ +
+
+ +
+
+
+ + + + +
+ +

All modules for which code is available

+ + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+ + + +
+
+
+ + + + + + + + \ No newline at end of file diff --git a/_sources/_srcdocs/index.md b/_sources/_srcdocs/index.md new file mode 100644 index 000000000..ffdfe9580 --- /dev/null +++ b/_sources/_srcdocs/index.md @@ -0,0 +1,6 @@ + +# Source Docs + +- [interface](packages/interface.md) +- [utils](packages/utils.md) +- [variable_info](packages/variable_info.md) diff --git a/_sources/_srcdocs/packages/interface.md b/_sources/_srcdocs/packages/interface.md new file mode 100644 index 000000000..835eb702c --- /dev/null +++ b/_sources/_srcdocs/packages/interface.md @@ -0,0 +1,11 @@ +--- +orphan: true +--- + +# aviary.interface + +- [cmd_entry_points](interface/cmd_entry_points.md) +- [graphical_input](interface/graphical_input.md) +- [methods_for_level1](interface/methods_for_level1.md) +- [methods_for_level2](interface/methods_for_level2.md) +- [reports](interface/reports.md) diff --git a/_sources/_srcdocs/packages/interface/cmd_entry_points.md b/_sources/_srcdocs/packages/interface/cmd_entry_points.md new file mode 100644 index 000000000..a61645d2d --- /dev/null +++ b/_sources/_srcdocs/packages/interface/cmd_entry_points.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# cmd_entry_points.py + +```{eval-rst} + .. automodule:: aviary.interface.cmd_entry_points + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/interface/graphical_input.md b/_sources/_srcdocs/packages/interface/graphical_input.md new file mode 100644 index 000000000..e41c87e10 --- /dev/null +++ b/_sources/_srcdocs/packages/interface/graphical_input.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# graphical_input.py + +```{eval-rst} + .. automodule:: aviary.interface.graphical_input + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/interface/methods_for_level1.md b/_sources/_srcdocs/packages/interface/methods_for_level1.md new file mode 100644 index 000000000..d6b8128d1 --- /dev/null +++ b/_sources/_srcdocs/packages/interface/methods_for_level1.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# methods_for_level1.py + +```{eval-rst} + .. automodule:: aviary.interface.methods_for_level1 + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/interface/methods_for_level2.md b/_sources/_srcdocs/packages/interface/methods_for_level2.md new file mode 100644 index 000000000..e0cec56e3 --- /dev/null +++ b/_sources/_srcdocs/packages/interface/methods_for_level2.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# methods_for_level2.py + +```{eval-rst} + .. automodule:: aviary.interface.methods_for_level2 + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/interface/reports.md b/_sources/_srcdocs/packages/interface/reports.md new file mode 100644 index 000000000..5f93409ab --- /dev/null +++ b/_sources/_srcdocs/packages/interface/reports.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# reports.py + +```{eval-rst} + .. automodule:: aviary.interface.reports + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils.md b/_sources/_srcdocs/packages/utils.md new file mode 100644 index 000000000..934a1f1e0 --- /dev/null +++ b/_sources/_srcdocs/packages/utils.md @@ -0,0 +1,24 @@ +--- +orphan: true +--- + +# aviary.utils + +- [Fortran_to_Aviary](utils/Fortran_to_Aviary.md) +- [aero_table_conversion](utils/aero_table_conversion.md) +- [aviary_values](utils/aviary_values.md) +- [compare_hierarchies](utils/compare_hierarchies.md) +- [conflict_checks](utils/conflict_checks.md) +- [csv_data_file](utils/csv_data_file.md) +- [data_interpolator_builder](utils/data_interpolator_builder.md) +- [develop_metadata](utils/develop_metadata.md) +- [engine_deck_conversion](utils/engine_deck_conversion.md) +- [functions](utils/functions.md) +- [merge_hierarchies](utils/merge_hierarchies.md) +- [merge_variable_metadata](utils/merge_variable_metadata.md) +- [named_values](utils/named_values.md) +- [options](utils/options.md) +- [preprocessors](utils/preprocessors.md) +- [process_input_decks](utils/process_input_decks.md) +- [report](utils/report.md) +- [set_mass_defaults](utils/set_mass_defaults.md) diff --git a/_sources/_srcdocs/packages/utils/Fortran_to_Aviary.md b/_sources/_srcdocs/packages/utils/Fortran_to_Aviary.md new file mode 100644 index 000000000..9c467e316 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/Fortran_to_Aviary.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# Fortran_to_Aviary.py + +```{eval-rst} + .. automodule:: aviary.utils.Fortran_to_Aviary + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/aero_table_conversion.md b/_sources/_srcdocs/packages/utils/aero_table_conversion.md new file mode 100644 index 000000000..9cdd9d2e4 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/aero_table_conversion.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# aero_table_conversion.py + +```{eval-rst} + .. automodule:: aviary.utils.aero_table_conversion + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/aviary_values.md b/_sources/_srcdocs/packages/utils/aviary_values.md new file mode 100644 index 000000000..7ad928897 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/aviary_values.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# aviary_values.py + +```{eval-rst} + .. automodule:: aviary.utils.aviary_values + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/compare_hierarchies.md b/_sources/_srcdocs/packages/utils/compare_hierarchies.md new file mode 100644 index 000000000..3285067b8 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/compare_hierarchies.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# compare_hierarchies.py + +```{eval-rst} + .. automodule:: aviary.utils.compare_hierarchies + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/conflict_checks.md b/_sources/_srcdocs/packages/utils/conflict_checks.md new file mode 100644 index 000000000..971f0b7e3 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/conflict_checks.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# conflict_checks.py + +```{eval-rst} + .. automodule:: aviary.utils.conflict_checks + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/csv_data_file.md b/_sources/_srcdocs/packages/utils/csv_data_file.md new file mode 100644 index 000000000..d996467ec --- /dev/null +++ b/_sources/_srcdocs/packages/utils/csv_data_file.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# csv_data_file.py + +```{eval-rst} + .. automodule:: aviary.utils.csv_data_file + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/data_interpolator_builder.md b/_sources/_srcdocs/packages/utils/data_interpolator_builder.md new file mode 100644 index 000000000..3de1773a5 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/data_interpolator_builder.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# data_interpolator_builder.py + +```{eval-rst} + .. automodule:: aviary.utils.data_interpolator_builder + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/develop_metadata.md b/_sources/_srcdocs/packages/utils/develop_metadata.md new file mode 100644 index 000000000..b046e6686 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/develop_metadata.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# develop_metadata.py + +```{eval-rst} + .. automodule:: aviary.utils.develop_metadata + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/engine_deck_conversion.md b/_sources/_srcdocs/packages/utils/engine_deck_conversion.md new file mode 100644 index 000000000..345567494 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/engine_deck_conversion.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# engine_deck_conversion.py + +```{eval-rst} + .. automodule:: aviary.utils.engine_deck_conversion + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/functions.md b/_sources/_srcdocs/packages/utils/functions.md new file mode 100644 index 000000000..7e34ad4e1 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/functions.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# functions.py + +```{eval-rst} + .. automodule:: aviary.utils.functions + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/merge_hierarchies.md b/_sources/_srcdocs/packages/utils/merge_hierarchies.md new file mode 100644 index 000000000..f264607d4 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/merge_hierarchies.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# merge_hierarchies.py + +```{eval-rst} + .. automodule:: aviary.utils.merge_hierarchies + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/merge_variable_metadata.md b/_sources/_srcdocs/packages/utils/merge_variable_metadata.md new file mode 100644 index 000000000..302b505e3 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/merge_variable_metadata.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# merge_variable_metadata.py + +```{eval-rst} + .. automodule:: aviary.utils.merge_variable_metadata + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/named_values.md b/_sources/_srcdocs/packages/utils/named_values.md new file mode 100644 index 000000000..614b9cbd5 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/named_values.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# named_values.py + +```{eval-rst} + .. automodule:: aviary.utils.named_values + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/options.md b/_sources/_srcdocs/packages/utils/options.md new file mode 100644 index 000000000..6d651c700 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/options.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# options.py + +```{eval-rst} + .. automodule:: aviary.utils.options + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/preprocessors.md b/_sources/_srcdocs/packages/utils/preprocessors.md new file mode 100644 index 000000000..33020a9a0 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/preprocessors.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# preprocessors.py + +```{eval-rst} + .. automodule:: aviary.utils.preprocessors + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/process_input_decks.md b/_sources/_srcdocs/packages/utils/process_input_decks.md new file mode 100644 index 000000000..80934536a --- /dev/null +++ b/_sources/_srcdocs/packages/utils/process_input_decks.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# process_input_decks.py + +```{eval-rst} + .. automodule:: aviary.utils.process_input_decks + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/report.md b/_sources/_srcdocs/packages/utils/report.md new file mode 100644 index 000000000..726db7697 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/report.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# report.py + +```{eval-rst} + .. automodule:: aviary.utils.report + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/utils/set_mass_defaults.md b/_sources/_srcdocs/packages/utils/set_mass_defaults.md new file mode 100644 index 000000000..88a258c79 --- /dev/null +++ b/_sources/_srcdocs/packages/utils/set_mass_defaults.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# set_mass_defaults.py + +```{eval-rst} + .. automodule:: aviary.utils.set_mass_defaults + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/variable_info.md b/_sources/_srcdocs/packages/variable_info.md new file mode 100644 index 000000000..20b46730f --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info.md @@ -0,0 +1,13 @@ +--- +orphan: true +--- + +# aviary.variable_info + +- [core_promotes](variable_info/core_promotes.md) +- [enums](variable_info/enums.md) +- [functions](variable_info/functions.md) +- [options](variable_info/options.md) +- [variable_meta_data](variable_info/variable_meta_data.md) +- [variables](variable_info/variables.md) +- [variables_in](variable_info/variables_in.md) diff --git a/_sources/_srcdocs/packages/variable_info/core_promotes.md b/_sources/_srcdocs/packages/variable_info/core_promotes.md new file mode 100644 index 000000000..b249b9d32 --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info/core_promotes.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# core_promotes.py + +```{eval-rst} + .. automodule:: aviary.variable_info.core_promotes + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/variable_info/enums.md b/_sources/_srcdocs/packages/variable_info/enums.md new file mode 100644 index 000000000..6714a8c8d --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info/enums.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# enums.py + +```{eval-rst} + .. automodule:: aviary.variable_info.enums + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/variable_info/functions.md b/_sources/_srcdocs/packages/variable_info/functions.md new file mode 100644 index 000000000..cd794f2da --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info/functions.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# functions.py + +```{eval-rst} + .. automodule:: aviary.variable_info.functions + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/variable_info/options.md b/_sources/_srcdocs/packages/variable_info/options.md new file mode 100644 index 000000000..0f6f7c840 --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info/options.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# options.py + +```{eval-rst} + .. automodule:: aviary.variable_info.options + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/variable_info/variable_meta_data.md b/_sources/_srcdocs/packages/variable_info/variable_meta_data.md new file mode 100644 index 000000000..6787a951e --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info/variable_meta_data.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# variable_meta_data.py + +```{eval-rst} + .. automodule:: aviary.variable_info.variable_meta_data + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/variable_info/variables.md b/_sources/_srcdocs/packages/variable_info/variables.md new file mode 100644 index 000000000..e8c9be50a --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info/variables.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# variables.py + +```{eval-rst} + .. automodule:: aviary.variable_info.variables + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/_srcdocs/packages/variable_info/variables_in.md b/_sources/_srcdocs/packages/variable_info/variables_in.md new file mode 100644 index 000000000..440f679d6 --- /dev/null +++ b/_sources/_srcdocs/packages/variable_info/variables_in.md @@ -0,0 +1,14 @@ +--- +orphan: true +--- + +# variables_in.py + +```{eval-rst} + .. automodule:: aviary.variable_info.variables_in + :members: + :undoc-members: + :special-members: __init__, __contains__, __iter__, __setitem__, __getitem__ + :show-inheritance: + :noindex: +``` diff --git a/_sources/developer_guide/codebase_overview.md b/_sources/developer_guide/codebase_overview.md new file mode 100644 index 000000000..b24cb859d --- /dev/null +++ b/_sources/developer_guide/codebase_overview.md @@ -0,0 +1,16 @@ +# Codebase Overview + +## Repository structure + +Within the Aviary repository and package, the codebase is structured as follows: + +- `docs` contains the doc files for Aviary +- `examples` contains example code for using Aviary, including external subsystem examples +- `interface` is where most code that users interact with is located +- `mission` contains OpenMDAO components and groups for modeling the aircraft mission +- `models` contains aircraft and propulsion models for use in Aviary examples and tests +- `subsystems` is where the aerodynamic, propulsion, mass, and geometry core subsystems are located +- `utils` contains utility functions for use in Aviary code, examples, and tests +- `validation_cases` contains validation cases for testing and benchmarking Aviary +- `visualization` is where the Aviary dashboard is located +- `xdsm` contains diagrams to help developers and users of Aviary understand how systems are connected together diff --git a/_sources/developer_guide/coding_standards.md b/_sources/developer_guide/coding_standards.md new file mode 100644 index 000000000..024638747 --- /dev/null +++ b/_sources/developer_guide/coding_standards.md @@ -0,0 +1,39 @@ +# Coding Standards + +Aviary uses a combination of formal standards and general best practices. To contribute code to the Aviary codebase, we request you follow these guidelines. + +In general, always follow the excellent advice given in the [PEP 8 Python style guide](https://peps.python.org/pep-0008/). Consistency is also key - pick a convention and stick with it for an entire file. + +## Style and Formatting +The Aviary development team uses the [autopep8 formatter](https://pypi.org/project/autopep8/) to handle formatting in a consistent way across the codebase. Autopep8 is a tool that formats Python code (through alteration of whitespace and line breaks) to follow a consistent style and attempt to keep lines within the character limit whenever possible. Aviary uses autopep8 as part of its [pre-commit](https://pre-commit.com/) scripts. The only required setting (which Aviary automatically enforces) is `max_line_length = 89`. Use of the `aggressive` or `experimental` flag is optional and up to the user, but take care that these settings do not alter code function or significantly hamper readability. The utility [isort](https://pycqa.github.io/isort/) is also recommended for formatting of import statements (something not specifically handled by autopep8), but it is currently not required. + +### Pre-Commit Setup +To set up pre-commit in your development python environment, there are a few one-time steps that must be done. The following commands need to be run to install pre-commit. + +`pip install pre-commit` + +`pre-commit install` + +The Aviary repository contains a configuration file that defines what is run when commits are made and with what options enabled. Currently this is limited to autopep8 with a max line length restriction. + +## Naming Conventions +### Variables +When it comes to variable naming, always be verbose! The Aviary team considers long but clear and descriptive names superior to shortened or vague names. Typing out a long name is only difficult once, as most IDEs will help you auto-complete long variable names, but the readability they add lasts a lifetime! +The Aviary variable hierarchy is an excellent example of good variable naming. When adding variables to the hierarchy, adhering to the following naming conventions is requested. Inside the codebase itself, such as inside openMDAO components, it is not required but still highly recommended to follow these guidelines. + +**A good variable name should:** +1. Not be ambiguous (avoid names that cannot be understood without context, like *x* or *calc*) +2. Avoid abbreviation (*thrust_to_weight_ratio* preferred to *T_W_ratio*). Note that Aviary will sometimes still shorten extremely long words such as "miscellaneous" to "misc" - use your best judgement! +3. Use physical descriptions rather than jargon or mathematical symbols (*density* preferred to *rho* - even better, include what flight condition this density is at, such as *current*, *sea_level*, etc.) +4. Place adjectives or modifiers after the "main" variable name rather than before (such as *thrust_max*, *thrust_sea_level_static*). This makes it is easier to autocomplete using an IDE - simply typing "thrust" will provide you with a handy list of all of the different kinds of thrust you can use. +5. Be formatted in "[snake case](https://en.wikipedia.org/wiki/Snake_case)", or all lowercase with underscore-delineated words (such as *example_variable*) + +### Classes +Class names should be written in "[CamelCase](https://en.wikipedia.org/wiki/Camel_case_)", or naming with no delimiters such as dashes or underscores between words and each word beginning with a capital letter. + +### Functions and Methods +Function and method names, similar to variables, should be formatted in "snake case". Class methods that are not intended to be accessed outside of the class definition can append an underscore at the beginning of the method name to mark it as "private", to help other users avoid using those methods incorrectly. An example of this is: +*def _private_method(self):* + +## Code Re-Use and Utility Functions +If an identical block of code appears multiple times inside a file, consider moving it to a function to make your code cleaner. Repeated code bloats files and makes them less readable. If that function ends up being useful outside that individual file, move it to a "utils.py" file in the lowest-level directory shared by all files that need that function. If the utility function is useful across all of Aviary and is integral to the tool's operation, the aviary/utils folder is the appropriate place for it. \ No newline at end of file diff --git a/_sources/developer_guide/contributing_guidelines.md b/_sources/developer_guide/contributing_guidelines.md new file mode 100644 index 000000000..11ad8b384 --- /dev/null +++ b/_sources/developer_guide/contributing_guidelines.md @@ -0,0 +1,21 @@ +# Guidelines for Contributing Code + +Welcome to our guide for contributing to the Aviary codebase. We are so glad you are interested in contributing to our software! There are a few guidelines that our developers follow in order to ensure that Aviary is well organized and uniform. If you would like to contribute to Aviary, please take a minute to read these guidelines: + +## Coding Standards +In order to ensure that our code is readable for our contributors, we ask that you follow our coding standards located [here](coding_standards). + +## Unit Testing +We require all code entering our codebase to be validated and regression tested. As part of this requirement, any new code that you contribute to our codebase must have an associated unit test. Our pull request approvers will check for this and will ask you to add a test if one is missing. For details on our unit testing structure see [Unit Tests](unit_tests). + +## Thorough Documentation +Documentation is the backbone of the Aviary team's support for our user community. The goal of Aviary's documentation is to provide a way for Aviary users to learn the codebase and have their questions answered in an efficient manner. Thus, we monitor the documentation to ensure that changes in the code are reflected in the docs, and that new code features are documented as well. As a result of this, any pull request which alters a feature's behavior must also update the documentation for that feature, and any pull request which creates a new feature for use by a user must also document that feature. For a guide on writing documentation in Aviary visit [How to Contribute Docs](how_to_contribute_docs). + +## Docstrings +The Aviary codebase is currently under active development and cleanup, including the addition of docstrings. Thus, not every function and class currently includes a docstring, however, we are slowly adding them. In order to move forwards instead of backwards we require that all added functions and classes include a docstring in the numpy format. + +## Benchmark Tests +The Aviary codebase has several benchmark tests which test some of the baseline models included in Aviary. These tests supplement the unit test capability, and are tested frequently by the Aviary team. We encourage you to run these tests using our test runner located [here](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/run_all_benchmarks.py). + +## Use of Issue Backlog +The Aviary team would like a chance to interact with and get community engagement in feature changes to the codebase. The primary place that this engagement happens is in the [issue backlog](https://github.com/OpenMDAO/om-Aviary/issues/new/choose) using the "feature or change request" section. In addition, we would like to be able to track bug fixes that come through the code. To support these goals we encourage users to create issues, and we encourage code contributors to link issues to their pull requests. \ No newline at end of file diff --git a/_sources/developer_guide/debugging_env_from_github.md b/_sources/developer_guide/debugging_env_from_github.md new file mode 100644 index 000000000..20eb324b8 --- /dev/null +++ b/_sources/developer_guide/debugging_env_from_github.md @@ -0,0 +1,73 @@ +# Using Dev Environments from GitHub Actions + +## Introduction + +If you've encountered a GitHub Actions failure case and wish to debug it locally, this guide will help you set up an identical development environment to the one used. + +## Prerequisites + +- You should have `conda` installed. Optionally, you can also install `mamba` for faster package installations. +- You should have Git and Bash installed. + +## Steps + +### 1. Download the environment YAML file + +- Navigate to the failing pull request (PR) in your repository. See the first screenshot below for what an example of a failing PR looks like. +- Locate the failed GitHub Actions workflow and go to the relevant "Artifacts" section to download the environment YAML file as shown in the screenshot. +- The downloaded YAML file will be in a zipped format. + +![failing PR](failing_pr.png) + +![GitHub Actions](gh_actions.png) + +### 2. Unzip the YAML file + +- Unzip the downloaded file to obtain the YAML file. +- Place this YAML file in your local `Aviary/.github` folder. The reason we recommend this location is that we have a helper script in this folder that you will use in the next steps. + +### 3. Optional: install mamba + +- While `conda` works well for package management, we recommend using `mamba` as it is generally faster. +- You can read more about mamba in its [user guide](https://mamba.readthedocs.io/en/latest/user_guide/mamba.html). +- To install mamba, follow the installers on [this link](https://github.com/conda-forge/miniforge#mambaforge). + +### 4. Run the helper script + +- Open your terminal and navigate to the `Aviary/.github` folder where you placed the YAML file and the script. +- Run the following command: + + ```bash + ./install_env_from_github.sh [optional env_name] + ``` + +- Note: The script may prompt you if an environment with the same name already exists. Type 'y' if you're fine with overwriting that environment. +- Note: You may need to add execute privileges to install_env_from_github.sh. This can be accomplished using: ```chmod +x install_env_from_github.sh``` + +## What the script does + +The `install_env_from_github.sh` script does the following: + +1. Checks for prerequisites and initiates package management via either `conda` or `mamba`. +2. Reads the given YAML file and creates an intermediate version without specific packages like Aviary, pyOptSparse, and Simupy. +3. Checks if `openmdao` and `dymos` are set to development versions, and if so, prepares to install them from GitHub. +4. Creates a new conda environment with the remaining packages. +5. Activates the new environment. +6. Installs development versions of `openmdao` and `dymos` from GitHub, if flagged. + +## Post-installation steps + +- Once your new environment is set up, make sure to activate it if it is not already active from the helper script: + + ```bash + conda activate debug_env + ``` + +- After activation, run `testflo .` inside the Aviary directory and you should see the same expected failures as GitHub Actions showed. + + ```bash + testflo . + ``` + +- Compare your local test results with the GitHub Actions results to identify discrepancies or issues. +- Debug! Good luck and have fun. diff --git a/_sources/developer_guide/how_to_contribute_docs.md b/_sources/developer_guide/how_to_contribute_docs.md new file mode 100644 index 000000000..c130f57da --- /dev/null +++ b/_sources/developer_guide/how_to_contribute_docs.md @@ -0,0 +1,59 @@ +# How to Contribute Docs + +Doc pages can be added as `.ipynb` or `.md` files within the `aviary/docs` folder. +We're using [jupyter-book](https://jupyterbook.org/) for the docs, which is a well-documented and full-featured platform. +To build the docs, you'll need to install jupyter-book following [these instructions](https://jupyterbook.org/en/stable/start/overview.html). +Jupyter-book allows for arbitrary Jupyter notebook usage to intersperse code and documentation and it uses [MyST markdown](https://jupyterbook.org/en/stable/content/myst.html). + +To modify the docs, simply add a file to the repo within the docs folder. +You can then add it to the `docs/_toc.yml` file following the structure for the skeletal outline. + +You can then run the `build_book.sh` bash script using the `sh build_book.sh` command to build the docs. +Currently, they are not hosted publicly online. +To view the docs you must build them locally. +The built docs live at `..Aviary/aviary/docs/_build/html/intro.html`. +Navigate to this file in your file manager once you have built the docs, and you can open it from there to your favorite internet browser. + +One of the powerful features that we use to write docs is automatic formatting of docstrings into documentation. +[This file](../theory_guide/merging_syntax.ipynb) contains an example of turning docstrings into documentation. +It is important to note when writing docstrings that the docstrings must be in numpy format. +[Here](https://numpydoc.readthedocs.io/en/latest/format.html) is a link to instructions on how to write numpy format docstrings. + +## Adding doc pages without putting them in the Table of Contents + +Sometimes when building the docs, you may see a warning like this: + +>```checking consistency... /home/user/Work/OpenMDAO/plugins/aviary/aviary/docs/user_guide/external_aero.ipynb: WARNING: document isn't included in any toctree``` + +This is because the notebook is not in a table of contents. +It isn't always ideal to put everything in the toc, so you can choose to omit a notebook by adding the `"orphan": true` to the metadata at the bottom of the file. + +```json + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 5 +} +``` + +Note, this will require manual editing of the ipynb file. +Don't forget to add the comma at the end of the previous brace. + +## Doc formatting and style + +````{margin} +```{note} +[The active voice](https://www.grammarly.com/blog/active-vs-passive-voice/) is when the subject of the sentence is doing the action. +For example, "The dog ate the bone" is active, whereas "The bone was eaten by the dog" is passive. +``` +```` + +When writing docs, please + +- use simple, clear, and concise language +- write each sentence on a new line (this helps make diffs more clear) +- use the active voice +- consider the audience of the particular section you're writing diff --git a/_sources/developer_guide/unit_tests.md b/_sources/developer_guide/unit_tests.md new file mode 100644 index 000000000..4a4dcb5fa --- /dev/null +++ b/_sources/developer_guide/unit_tests.md @@ -0,0 +1,44 @@ +# Unit Tests + +Tests help us know that Aviary is working properly as we update the code. +If you are adding to or modifying Aviary, you should add unit tests to ensure that your code is working as expected. + +The goal of unit tests is to provide fine-grained details about how the functionality of the code is modified by your changes and to pinpoint any bugs that may have been introduced. +This page describes how to run the unit tests and how to add new tests. + +## Running Unit Tests + +Aviary ships with a suite of unit tests that can be run using the `testflo` command. +To run all unit tests, simply run `testflo` from the root directory of the Aviary repository. +To run a specific test, use the command `testflo `. +We use the [testflo](https://github.com/naylor-b/testflo) package to run our unit tests as it allows us to run tests in parallel, which can significantly speed up the testing process. + +Running `testflo .` at the base of the Aviary repository will run all unit tests and should produce output that looks like this (though the number of tests and skips may be different): + +```bash +OK + +Passed: 885 +Failed: 0 +Skipped: 3 + + +Ran 888 tests using 16 processes +Wall clock time: 00:00:54.15 +``` + +## Adding Unit Tests + +Whenever you add to Aviary, you should add a unit test to check its functionality. +Ideally, this test would check all logical paths in the code that you've added. +For example, if you add a new component, you should add a test that checks the component's output for a variety of inputs, as well as the partial derivative calculations. +If you add to an existing component, you should add a test that checks the new functionality you've added. + +The logistical process of adding tests is relatively simple. +It's generally easier to look at existing tests to see how they're structured, but here's a quick overview. + +Within the directory where you're adding or modifying code, there should be a `test` directory. +If there's not, you can create one. +Add a new file to this directory with the name `test_.py` where `` is the name of the file you're adding or modifying. +Within this file, add a class called `Test` that inherits from `unittest.TestCase`. +Within this class, add a method called `test_` where `` is the name of the test you're adding. diff --git a/_sources/examples/OAS_subsystem.ipynb b/_sources/examples/OAS_subsystem.ipynb new file mode 100644 index 000000000..3e7db68f6 --- /dev/null +++ b/_sources/examples/OAS_subsystem.ipynb @@ -0,0 +1,407 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Using Aviary and OpenAeroStruct Together\n", + "\n", + "This is an example of an external subsystem using the [OpenAeroStruct (OAS)](https://github.com/mdolab/OpenAeroStruct) structural analysis system to perform aerostructural optimization of a typical large single aisle transport aircraft wing.\n", + "The subsystem is based on the [OpenAeroStruct aerostructural optimization with wingbox](https://mdolab-openaerostruct.readthedocs-hosted.com/en/latest/aerostructural_wingbox_walkthrough.html) example problem.\n", + "\n", + "This example performs a sub-optimization for minimum wing weight that is then used by Aviary.\n", + "Another use case would be to perform a structural analysis only.\n", + "Structural design variables would be passed to the subsystem from Aviary and wing weight and a constraint or constraints representing the structural analysis would be passed back to Aviary for use by the top level optimization.\n", + "\n", + "## Motivation\n", + "\n", + "There may be a need for a higher fidelity tool to compute wing weight instead of relying on the empirical methods in core Aviary.\n", + "A structural analysis external tool is usually used because of an unusual aircraft configuration that may not be predicted my Aviary empirical weight estimation methods, but in this example case it is simply a demonstration of an external capability to compute wing weight.\n", + "\n", + "## External Dependencies\n", + "\n", + "The user must install [OpenAeroStruct](https://github.com/mdolab/OpenAeroStruct) into their Python environment using the command 'pip install openaerostruct'.\n", + "The user must also install the [ambiance](https://ambiance.readthedocs.io/en/latest/) package using the command 'pip install ambiance'.\n", + "\n", + "## Subsystem Details\n", + "\n", + "There are two parts to building an external subsystem -- the analysis tool and the Aviary external subsystem builder for that tool.\n", + "The analysis tool takes inputs and parameters from Aviary and return outputs that Aviary can use to override existing variables.\n", + "The subsystem builder uses the Aviary external subsystem builder template to connect the analysis tool to Aviary as either a pre-mission, mission or post-mission subsystem.\n", + "\n", + "For this case, the analysis tool will compute a wing weight in the pre-mission portion of the Aviary analysis and return its value to Aviary to override the empirical wing weight value.\n", + "Fuel weight is passed in from Aviary as the only input currently, but other inputs may also be passed in through the subsystem builder, [OAS_wing_weight_builder](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS_weight/OAS_wing_weight_builder.py), by the `promotes_inputs` parameter.\n", + "Other Aviary variables can also be added as additional inputs based on user needs.\n", + "\n", + "```{note}\n", + "Some modifications of the [OAS_wing_weight_analysis](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS_weight/OAS_wing_weight_analysis.py) code will be necessary to add new inputs not already defined.\n", + "```\n", + "\n", + "Here is the builder object for the OAS wing weight analysis example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# %load ../../examples/external_subsystems/OAS_weight/OAS_wing_weight_builder.py\n", + "\"\"\"\n", + "Builder for an OpenAeroStruct component that computes a new wing mass.\n", + "\n", + "\"\"\"\n", + "import openmdao.api as om\n", + "import aviary.api as av\n", + "from aviary.examples.external_subsystems.OAS_weight.OAS_wing_weight_analysis import OAStructures\n", + "\n", + "\n", + "class OASWingWeightBuilder(av.SubsystemBuilderBase):\n", + " def __init__(self, name='wing_weight'):\n", + " super().__init__(name)\n", + "\n", + " def build_pre_mission(self, aviary_inputs):\n", + " '''\n", + " Build an OpenMDAO system for the pre-mission computations of the subsystem.\n", + "\n", + " Returns\n", + " -------\n", + " pre_mission_sys : openmdao.core.System\n", + " An OpenMDAO system containing all computations that need to happen in\n", + " the pre-mission (formerly statics) part of the Aviary problem. This\n", + " includes sizing, design, and other non-mission parameters.\n", + " '''\n", + "\n", + " wing_group = om.Group()\n", + " wing_group.add_subsystem(\"aerostructures\",\n", + " OAStructures(\n", + " symmetry=True,\n", + " wing_weight_ratio=1.0,\n", + " S_ref_type='projected',\n", + " n_point_masses=1,\n", + " num_twist_cp=4,\n", + " num_box_cp=51),\n", + " promotes_inputs=[\n", + " ('fuel', av.Mission.Design.FUEL_MASS),\n", + " ],\n", + " promotes_outputs=[('wing_weight', av.Aircraft.Wing.MASS)])\n", + "\n", + " return wing_group\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis Model Details\n", + "\n", + "This analysis is based on the Aviary benchmark [aircraft_for_bench_FwFm](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/models/test_aircraft/aircraft_for_bench_FwFm.csv) input data representing a typical large single aisle class transport aircraft.\n", + "The analysis code [OAS_wing_weight_analysis](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS_weight/OAS_wing_weight_analysis.py) contains the `OAStructures` class which performs a structural analysis of the wing.\n", + "\n", + "We'll now discuss this code in more detail.\n", + "\n", + "First, we create a mesh that defines the shape of the wing based on the span, the location of the wing break typical of a transport aircraft, the dihedral and the wing root, wing break, and wing tip chord lengths.\n", + "The twist of the wing is defined along the span at a set of control points and must be present as it is used in the optimization problem.\n", + "\n", + "We then use this mesh to define a simplified finite element model of the wing structural box.\n", + "We also define the airfoil shapes as an input to OpenAeroStruct for a given wing thickness to chord ratio (t/c) to represent the wing box thickness.\n", + "We then set initial values for the wing skin thickness and spar thickness are set, along with material properties and stress allowables for a metal material, typically aluminum.\n", + "OpenAeroStruct will then calculate aeroelastic loads for a 2.5g maneuver condition and apply those loads to the finite element model of the wing structure.\n", + "\n", + "Results of the structural optimization determine the optimum wing skin thickness, spar cap thickness, wing twist, wing t/c and maneuver angle of attack that satisfies strength constraints while minimizing wing weight.\n", + "The 'OAStructures' class returns the optimized wing mass and the fuel mass burned but currently only the wing mass is used to override the Aviary variable 'Aircraft.Wing.MASS'.\n", + "\n", + "The [OAS_wing_weight_analysis](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS_weight/OAS_wing_weight_analysis.py) code may be executed in Python to test the OpenAeroStruct analysis outside of the Aviary subsystem interface.\n", + "Default values for each of the inputs and options are included at the bottom of the analysis code file.\n", + "This can be a useful test to demonstrate that the OpenAeroStruct analysis model has been properly defined and the model returns reasonable results.\n", + "\n", + "Once the user is satisfied that the results are acceptable, the analysis tool can then be added as an external subsystem and tested in a mission.\n", + "\n", + "## Subsystem variables\n", + "\n", + "A variety of parameters may be defined for an OpenAeroStruct model.\n", + "These allow the user to control how the aerodynamic and finite element meshes are subdivided, give details about the aerodynamic solution and provide structural material properties and structural scaling factors.\n", + "The input variables passed in from Aviary may include the fuel mass, reserve fuel mass, airfoil description, engine mass and its location, lift and drag coefficients and the cruise conditions of Mach, altitude, SFC and range.\n", + "\n", + "This is a list of the available options defined for the structural analysis:\n", + "\n", + "- symmetry\n", + "- chord_cos_spacing\n", + "- span_cos_spacing\n", + "- num_box_cp\n", + "- num_twist_cp\n", + "- S_ref_type\n", + "- fem_model_type\n", + "- with_viscous\n", + "- with_wave\n", + "- k_lam\n", + "- c_max_t\n", + "- E\n", + "- G\n", + "- yield\n", + "- mrho\n", + "- strength_factor_for_upper_skin\n", + "- wing_weight_ratio\n", + "- exact_failure_constraint\n", + "- struct_weight_relief\n", + "- distributed_fuel_weight\n", + "- n_point_masses\n", + "- fuel_density\n", + "\n", + "This is a list of the inputs defined for the structural analysis:\n", + "\n", + "- box_upper_x\n", + "- box_lower_x\n", + "- box_upper_y\n", + "- box_lower_y\n", + "- twist_cp\n", + "- spar_thickness_cp\n", + "- skin_thickness_cp\n", + "- t_over_c_cp\n", + "- airfoil_t_over_c\n", + "- fuel\n", + "- fuel_reserve\n", + "- CL0\n", + "- CD0\n", + "- cruise_Mach\n", + "- cruise_altitude\n", + "- cruise_range\n", + "- cruise_SFC\n", + "- engine_mass\n", + "- engine_location\n", + "\n", + "The 2 outputs from the analysis tool are:\n", + "\n", + "- wing_weight\n", + "- fuel_burn\n", + "\n", + "See [OAS_wing_weight_analysis](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS_weight/OAS_wing_weight_analysis.py) and the [OpenAeroStruct aerostructural optimization with wingbox](https://mdolab-openaerostruct.readthedocs-hosted.com/en/latest/aerostructural_wingbox_walkthrough.html) documentation for descriptions of these variables.\n", + "\n", + "## Test Case\n", + "\n", + "A simple Aviary mission is defined to test the inclusion of the OpenAeroStruct wing weight subsystem during the pre-mission phase.\n", + "The test mission is defined in [run_simple_OAS_mission](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS/run_simple_OAS_mission.py) and is a mission based on input data read from the benchmark data file [aircraft_for_bench_FwFm](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/models/test_aircraft/aircraft_for_bench_FwFm.csv).\n", + "\n", + "The OpenAeroStruct subsystem is used to compute an optimum wing mass which will override the Aviary computed wing mass value.\n", + "The value of the Aviary variable `Aircraft.Wing.MASS` is printed at the conclusion of the mission to verify that the wing weight from the subsystem is overriding the Aviary computed wing weight.\n", + "\n", + "A variable in the [run_simple_OAS_mission](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS/run_simple_OAS_mission.py) file named `use_OAS` may be set by the user to `True` or `False` to run the simple mission with or without the OpenAeroStruct subsystem included.\n", + "This will allow the mission to be flown either using the Aviary empirical wing weight estimation (`use_OAS=False`) or with the OpenAeroStruct subsystem (`use_OAS=True`).\n", + "\n", + "Wing weight optimization of this type usually does not have knowledge of non-optimum wing mass values such as leading and training edge structure, actuators, stiffeners, etc.\n", + "The optimum wing mass computed by the `OAStructures` class can be scaled using the option `wing_weight_ratio` to better match either the Aviary empirical wing weight value or a known fly-away weight estimate for your wing model.\n", + "One method to determine the wing_weight_ratio would be to run the mission to calculate the Aviary empirical wing weight and then run [OAS_wing_weight_analysis](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS_weight/OAS_wing_weight_analysis.py) by itself using its default input values and compare wing weights. The `wing_weight_ratio` value may then be set to calibrate the OpenAeroStruct wing weight to the expected fly-away weight.\n", + "\n", + "This calibration step has already been performed for this model, so the user may run the simple mission with or without the OpenAeroStruct subsystem active and compare the results.\n", + "\n", + "## Example Run Script\n", + "\n", + "Here is the full run script used to run the simple mission with the OpenAeroStruct subsystem active.\n", + "This run script is also available in the [run_simple_OAS_mission file.](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/OAS/run_simple_OAS_mission.py)\n", + "\n", + "\n", + "```{note}\n", + "We do not actually perform the optimization below.\n", + "Instead, we define and set up the model and the call to run the optimization is commented you.\n", + "You can uncomment this and run the code block to perform a full optimization.\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# %load ../../examples/external_subsystems/OAS_weight/run_simple_OAS_mission.py\n", + "'''\n", + "This is a simple test mission to demonstrate the inclusion of a\n", + "pre-mission user defined external subsystem. The simple mission\n", + "is based on input data read from the benchmark data file bench_4.csv,\n", + "which represents a single-aisle commercial transport aircraft. The\n", + "OpenAeroStruct (OAS) subsystem is used to compute an optimum wing\n", + "mass which will override the Aviary computed wing mass value.\n", + "\n", + "The flag 'use_OAS' is set to 'True' to include the OAS subsystem in\n", + "the mission, or set to 'False' to run the mission without the\n", + "subsystem so that wing mass values between the 2 methods may be\n", + "compared.\n", + "\n", + "'''\n", + "\n", + "import numpy as np\n", + "import openmdao.api as om\n", + "import aviary.api as av\n", + "from aviary.examples.external_subsystems.OAS_weight.OAS_wing_weight_builder import OASWingWeightBuilder\n", + "\n", + "# flag to turn on/off OpenAeroStruct subsystem for comparison testing\n", + "use_OAS = True\n", + "\n", + "wing_weight_builder = OASWingWeightBuilder()\n", + "\n", + "# Load the phase_info and other common setup tasks\n", + "phase_info = {\n", + " 'climb_1': {\n", + " 'subsystem_options': {'core_aerodynamics': {'method': 'computed'}},\n", + " 'user_options': {\n", + " 'optimize_mach': False,\n", + " 'optimize_altitude': False,\n", + " 'polynomial_control_order': 1,\n", + " 'num_segments': 5,\n", + " 'order': 3,\n", + " 'solve_for_range': False,\n", + " 'initial_mach': (0.2, 'unitless'),\n", + " 'final_mach': (0.72, 'unitless'),\n", + " 'mach_bounds': ((0.18, 0.74), 'unitless'),\n", + " 'initial_altitude': (0.0, 'ft'),\n", + " 'final_altitude': (32000.0, 'ft'),\n", + " 'altitude_bounds': ((0.0, 34000.0), 'ft'),\n", + " 'throttle_enforcement': 'path_constraint',\n", + " 'fix_initial': True,\n", + " 'constrain_final': False,\n", + " 'fix_duration': False,\n", + " 'initial_bounds': ((0.0, 0.0), 'min'),\n", + " 'duration_bounds': ((64.0, 192.0), 'min'),\n", + " },\n", + " 'initial_guesses': {'times': ([0, 128], 'min')},\n", + " },\n", + " 'climb_2': {\n", + " 'subsystem_options': {'core_aerodynamics': {'method': 'computed'}},\n", + " 'user_options': {\n", + " 'optimize_mach': False,\n", + " 'optimize_altitude': False,\n", + " 'polynomial_control_order': 1,\n", + " 'num_segments': 5,\n", + " 'order': 3,\n", + " 'solve_for_range': False,\n", + " 'initial_mach': (0.72, 'unitless'),\n", + " 'final_mach': (0.72, 'unitless'),\n", + " 'mach_bounds': ((0.7, 0.74), 'unitless'),\n", + " 'initial_altitude': (32000.0, 'ft'),\n", + " 'final_altitude': (34000.0, 'ft'),\n", + " 'altitude_bounds': ((23000.0, 38000.0), 'ft'),\n", + " 'throttle_enforcement': 'boundary_constraint',\n", + " 'fix_initial': False,\n", + " 'constrain_final': False,\n", + " 'fix_duration': False,\n", + " 'initial_bounds': ((64.0, 192.0), 'min'),\n", + " 'duration_bounds': ((56.5, 169.5), 'min'),\n", + " },\n", + " 'initial_guesses': {'times': ([128, 113], 'min')},\n", + " },\n", + " 'descent_1': {\n", + " 'subsystem_options': {'core_aerodynamics': {'method': 'computed'}},\n", + " 'user_options': {\n", + " 'optimize_mach': False,\n", + " 'optimize_altitude': False,\n", + " 'polynomial_control_order': 1,\n", + " 'num_segments': 5,\n", + " 'order': 3,\n", + " 'solve_for_range': False,\n", + " 'initial_mach': (0.72, 'unitless'),\n", + " 'final_mach': (0.36, 'unitless'),\n", + " 'mach_bounds': ((0.34, 0.74), 'unitless'),\n", + " 'initial_altitude': (34000.0, 'ft'),\n", + " 'final_altitude': (500.0, 'ft'),\n", + " 'altitude_bounds': ((0.0, 38000.0), 'ft'),\n", + " 'throttle_enforcement': 'path_constraint',\n", + " 'fix_initial': False,\n", + " 'constrain_final': True,\n", + " 'fix_duration': False,\n", + " 'initial_bounds': ((120.5, 361.5), 'min'),\n", + " 'duration_bounds': ((29.0, 87.0), 'min'),\n", + " },\n", + " 'initial_guesses': {'times': ([241, 58], 'min')},\n", + " },\n", + " 'post_mission': {\n", + " 'include_landing': False,\n", + " 'constrain_range': True,\n", + " 'target_range': (1800., 'nmi'),\n", + " },\n", + "}\n", + "\n", + "phase_info['pre_mission'] = {'include_takeoff': False, 'optimize_mass': True}\n", + "if use_OAS:\n", + " phase_info['pre_mission']['external_subsystems'] = [wing_weight_builder]\n", + "\n", + "aircraft_definition_file = 'models/test_aircraft/aircraft_for_bench_FwFm_simple.csv'\n", + "mission_method = 'simple'\n", + "mass_method = 'FLOPS'\n", + "make_plots = False\n", + "max_iter = 100\n", + "optimizer = 'IPOPT'\n", + "\n", + "prob = av.AviaryProblem()\n", + "\n", + "prob.load_inputs(aircraft_definition_file, phase_info)\n", + "prob.check_and_preprocess_inputs()\n", + "prob.add_pre_mission_systems()\n", + "prob.add_phases()\n", + "prob.add_post_mission_systems()\n", + "prob.link_phases()\n", + "prob.add_driver(optimizer=optimizer, max_iter=max_iter)\n", + "prob.add_design_variables()\n", + "prob.add_objective()\n", + "prob.setup()\n", + "\n", + "if use_OAS:\n", + " OAS_sys = 'pre_mission.wing_weight.aerostructures.'\n", + " prob.set_val(OAS_sys + 'box_upper_x', np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32,\n", + " 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6]), units='unitless')\n", + " prob.set_val(OAS_sys + 'box_lower_x', np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32,\n", + " 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6]), units='unitless')\n", + " prob.set_val(OAS_sys + 'box_upper_y', np.array([0.0447, 0.046, 0.0472, 0.0484, 0.0495, 0.0505, 0.0514, 0.0523, 0.0531, 0.0538, 0.0545, 0.0551, 0.0557, 0.0563, 0.0568, 0.0573, 0.0577, 0.0581, 0.0585, 0.0588, 0.0591, 0.0593, 0.0595, 0.0597,\n", + " 0.0599, 0.06, 0.0601, 0.0602, 0.0602, 0.0602, 0.0602, 0.0602, 0.0601, 0.06, 0.0599, 0.0598, 0.0596, 0.0594, 0.0592, 0.0589, 0.0586, 0.0583, 0.058, 0.0576, 0.0572, 0.0568, 0.0563, 0.0558, 0.0553, 0.0547, 0.0541]), units='unitless')\n", + " prob.set_val(OAS_sys + 'box_lower_y', np.array([-0.0447, -0.046, -0.0473, -0.0485, -0.0496, -0.0506, -0.0515, -0.0524, -0.0532, -0.054, -0.0547, -0.0554, -0.056, -0.0565, -0.057, -0.0575, -0.0579, -0.0583, -0.0586, -0.0589, -0.0592, -0.0594, -0.0595, -0.0596, -\n", + " 0.0597, -0.0598, -0.0598, -0.0598, -0.0598, -0.0597, -0.0596, -0.0594, -0.0592, -0.0589, -0.0586, -0.0582, -0.0578, -0.0573, -0.0567, -0.0561, -0.0554, -0.0546, -0.0538, -0.0529, -0.0519, -0.0509, -0.0497, -0.0485, -0.0472, -0.0458, -0.0444]), units='unitless')\n", + " prob.set_val(OAS_sys + 'twist_cp', np.array([-6., -6., -4., 0.]), units='deg')\n", + " prob.set_val(OAS_sys + 'spar_thickness_cp',\n", + " np.array([0.004, 0.005, 0.008, 0.01]), units='m')\n", + " prob.set_val(OAS_sys + 'skin_thickness_cp',\n", + " np.array([0.005, 0.01, 0.015, 0.025]), units='m')\n", + " prob.set_val(OAS_sys + 't_over_c_cp',\n", + " np.array([0.08, 0.08, 0.10, 0.08]), units='unitless')\n", + " prob.set_val(OAS_sys + 'airfoil_t_over_c', 0.12, units='unitless')\n", + " prob.set_val(OAS_sys + 'fuel', 40044.0, units='lbm')\n", + " prob.set_val(OAS_sys + 'fuel_reserve', 3000.0, units='lbm')\n", + " prob.set_val(OAS_sys + 'CD0', 0.0078, units='unitless')\n", + " prob.set_val(OAS_sys + 'cruise_Mach', 0.785, units='unitless')\n", + " prob.set_val(OAS_sys + 'cruise_altitude', 11303.682962301647, units='m')\n", + " prob.set_val(OAS_sys + 'cruise_range', 3500, units='nmi')\n", + " prob.set_val(OAS_sys + 'cruise_SFC', 0.53 / 3600, units='1/s')\n", + " prob.set_val(OAS_sys + 'engine_mass', 7400, units='lbm')\n", + " prob.set_val(OAS_sys + 'engine_location', np.array([25, -10.0, 0.0]), units='m')\n", + "\n", + "prob.set_initial_guesses()\n", + "# prob.run_aviary_problem('dymos_solution.db', make_plots=False)\n", + "# print('wing mass = ', prob.model.get_val(av.Aircraft.Wing.MASS, units='lbm'))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/examples/additional_flight_phases.ipynb b/_sources/examples/additional_flight_phases.ipynb new file mode 100644 index 000000000..a28066d63 --- /dev/null +++ b/_sources/examples/additional_flight_phases.ipynb @@ -0,0 +1,284 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mission Optimization with Many Phases for a Commercial Aircraft\n", + "\n", + "So far within these example docs we have been building up the complexity of our coupled aircraft-mission design problem.\n", + "In [the simple mission example](simple_mission_example), we flew the aircraft in straight line phases.\n", + "In [the more advanced mission example](more_advanced_example), we allowed the optimizer to find the optimal Mach profiles for phases.\n", + "\n", + "In this example, we will build on the prior examples by adding more phases to the mission.\n", + "This will allow us to model more complex missions, such as a commercial aircraft flying a long-haul route with multiple cruise segments, intermediary climb segments, and a cruise-climb segment.\n", + "\n", + "## Problem Formulation\n", + "\n", + "We use the `aviary draw_mission` GUI as shown below:\n", + "\n", + "![multiple_phases_gui](images/multiple_phases_gui.png)\n", + "\n", + "This results in the following `phase_info` dictionary:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_info = {\n", + " \"pre_mission\": {\"include_takeoff\": False, \"optimize_mass\": True},\n", + " \"climb_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.2, \"unitless\"),\n", + " \"final_mach\": (0.72, \"unitless\"),\n", + " \"mach_bounds\": ((0.18, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (0.0, \"ft\"),\n", + " \"final_altitude\": (31000.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 31500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": True,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((0.0, 0.0), \"min\"),\n", + " \"duration_bounds\": ((25.5, 76.5), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([0, 51], \"min\")},\n", + " },\n", + " \"cruise_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.72, \"unitless\"),\n", + " \"mach_bounds\": ((0.7, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (31000.0, \"ft\"),\n", + " \"final_altitude\": (31000.0, \"ft\"),\n", + " \"altitude_bounds\": ((30500.0, 31500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((25.5, 76.5), \"min\"),\n", + " \"duration_bounds\": ((23.5, 70.5), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([51, 47], \"min\")},\n", + " },\n", + " \"climb_2\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.74, \"unitless\"),\n", + " \"mach_bounds\": ((0.7, 0.76), \"unitless\"),\n", + " \"initial_altitude\": (31000.0, \"ft\"),\n", + " \"final_altitude\": (33000.0, \"ft\"),\n", + " \"altitude_bounds\": ((30500.0, 33500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((49.0, 147.0), \"min\"),\n", + " \"duration_bounds\": ((5.0, 15.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([98, 10], \"min\")},\n", + " },\n", + " \"cruise_2\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.74, \"unitless\"),\n", + " \"final_mach\": (0.74, \"unitless\"),\n", + " \"mach_bounds\": ((0.72, 0.76), \"unitless\"),\n", + " \"initial_altitude\": (33000.0, \"ft\"),\n", + " \"final_altitude\": (33000.0, \"ft\"),\n", + " \"altitude_bounds\": ((32500.0, 33500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((54.0, 162.0), \"min\"),\n", + " \"duration_bounds\": ((24.0, 72.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([108, 48], \"min\")},\n", + " },\n", + " \"climb_3\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.74, \"unitless\"),\n", + " \"final_mach\": (0.76, \"unitless\"),\n", + " \"mach_bounds\": ((0.72, 0.78), \"unitless\"),\n", + " \"initial_altitude\": (33000.0, \"ft\"),\n", + " \"final_altitude\": (34500.0, \"ft\"),\n", + " \"altitude_bounds\": ((32500.0, 35000.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((78.0, 234.0), \"min\"),\n", + " \"duration_bounds\": ((7.0, 21.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([156, 14], \"min\")},\n", + " },\n", + " \"climb_4\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.76, \"unitless\"),\n", + " \"final_mach\": (0.76, \"unitless\"),\n", + " \"mach_bounds\": ((0.74, 0.78), \"unitless\"),\n", + " \"initial_altitude\": (34500.0, \"ft\"),\n", + " \"final_altitude\": (36000.0, \"ft\"),\n", + " \"altitude_bounds\": ((34000.0, 36500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((85.0, 255.0), \"min\"),\n", + " \"duration_bounds\": ((43.0, 129.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([170, 86], \"min\")},\n", + " },\n", + " \"descent_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.76, \"unitless\"),\n", + " \"final_mach\": (0.2, \"unitless\"),\n", + " \"mach_bounds\": ((0.18, 0.78), \"unitless\"),\n", + " \"initial_altitude\": (36000.0, \"ft\"),\n", + " \"final_altitude\": (500.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 36500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": True,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((128.0, 384.0), \"min\"),\n", + " \"duration_bounds\": ((41.0, 123.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([256, 82], \"min\")},\n", + " },\n", + " \"post_mission\": {\n", + " \"include_landing\": False,\n", + " \"constrain_range\": True,\n", + " \"target_range\": (2393, \"nmi\"),\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running Aviary with Updated Parameters\n", + "\n", + "Let's now run Aviary with this multiphase mission and view the results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "prob = av.run_aviary('models/test_aircraft/aircraft_for_bench_FwFm_simple.csv',\n", + " phase_info, optimizer=\"SLSQP\", make_plots=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've run Aviary, we can look at the results.\n", + "Open up the automatically generated `traj_results_report.html` and scroll through it to visualize the results.\n", + "\n", + "Here are the altitude and Mach profiles:\n", + "\n", + "![Altitude and Mach Profiles](images/multiphase_flight_profile.png)\n", + "\n", + "\n", + "```{note}\n", + "Remember, we did not allow the optimizer to control either the Mach _or_ the altitude profiles. The optimizer varied the phase durations until the optimal mission profile was found.\n", + "```\n", + "\n", + "## What Next?\n", + "\n", + "The point of this doc page is to show that missions can be arbitrarily complex in terms of the number of phases and how they're classified.\n", + "If you want multiple climb, cruise, descent phases, that's absolutely something Aviary can handle.\n", + "\n", + "There are a lot of options for how you could modify this example.\n", + "You could:\n", + "\n", + "- enable the `optimize_mach` or `optimize_altitude` flags\n", + "- increase the `polynomial_control_order` so there's more flexibility in the optimized mission\n", + "- try different `target_range` values for the full mission range\n", + "- add an external subsystem to the phases\n", + "\n", + "Playing around with a model and seeing how different settings affect the optimization and resulting aircraft design is always an enlightening experience." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/examples/coupled_aircraft_mission_optimization.ipynb b/_sources/examples/coupled_aircraft_mission_optimization.ipynb new file mode 100644 index 000000000..850f8a627 --- /dev/null +++ b/_sources/examples/coupled_aircraft_mission_optimization.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Coupled Aircraft-Mission Optimization\n", + "\n", + "One of the most exciting features of Aviary is the ability to formulate and solve coupled aircraft-mission design optimization problems.\n", + "Here, we mean that we are finding the optimal aircraft design parameters while simultaneously finding the optimal mission trajectory.\n", + "The reason why this is so valuable is that it enables exploration of a larger design space much more efficiently.\n", + "\n", + "Solving coupled design-mission problems leads to optimal designs that would not be findable without simultaneously designing the aircraft and the trajectory.\n", + "This is especially useful for unconventional aircraft designs, operations with complex missions, and many more future-focused studies than what is commonly flying today.\n", + "\n", + "This doc page builds up a coupled design problem and explains what we're doing along the way.\n", + "This process is relatively straightforward in Aviary.\n", + "We will briefly discuss the optimal results, but that is not necessarily the focus here.\n", + "Instead, we want to showcase how to do a simple coupled design study in Aviary.\n", + "\n", + "You can use this as a starting point for your own exciting aircraft and mission design studies.\n", + "\n", + "## Problem Definition and Explanation\n", + "\n", + "We will use a conventional single-aisle commercial aircraft design as our starting point.\n", + "For all of these examples we allow the aircraft to be sized by the optimizer.\n", + "This means the gross takeoff weight is controlled to meet a mass balance.\n", + "\n", + "We will perform four different optimization cases as part of this study:\n", + "\n", + "- fixed mission profile, fixed aircraft wing aspect ratio\n", + "- fixed mission profile, optimized aircraft wing aspect ratio\n", + "- optimized mission profile, fixed aircraft wing aspect ratio\n", + "- optimized mission profile, optimized aircraft wing aspect ratio\n", + "\n", + "We'll provide more detail individually for each case.\n", + "\n", + "When we call Aviary, we will use a common `phase_info` object that we modify for each optimization case shown here:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_info = {\n", + " \"pre_mission\": {\"include_takeoff\": False, \"optimize_mass\": True},\n", + " \"climb_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 5,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.2, \"unitless\"),\n", + " \"final_mach\": (0.72, \"unitless\"),\n", + " \"mach_bounds\": ((0.18, 0.84), \"unitless\"),\n", + " \"initial_altitude\": (0.0, \"ft\"),\n", + " \"final_altitude\": (32500.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 33000.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": True,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((0.0, 0.0), \"min\"),\n", + " \"duration_bounds\": ((35.0, 105.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([0, 70], \"min\")},\n", + " },\n", + " \"cruise\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 5,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.80, \"unitless\"),\n", + " \"mach_bounds\": ((0.7, 0.84), \"unitless\"),\n", + " \"initial_altitude\": (32500.0, \"ft\"),\n", + " \"final_altitude\": (36000.0, \"ft\"),\n", + " \"altitude_bounds\": ((32000.0, 36500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((35.0, 105.0), \"min\"),\n", + " \"duration_bounds\": ((91.5, 274.5), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([70, 183], \"min\")},\n", + " },\n", + " \"descent_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 5,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.21, \"unitless\"),\n", + " \"mach_bounds\": ((0.19, 0.84), \"unitless\"),\n", + " \"initial_altitude\": (36000.0, \"ft\"),\n", + " \"final_altitude\": (0.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 36500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": True,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((126.5, 379.5), \"min\"),\n", + " \"duration_bounds\": ((25.0, 75.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([253, 50], \"min\")},\n", + " },\n", + " \"post_mission\": {\n", + " \"include_landing\": False,\n", + " \"constrain_range\": True,\n", + " \"target_range\": (2080, \"nmi\"),\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let us explain each case, formulate the Aviary problem, and optimize.\n", + "We'll discuss the results from each case and explain why they vary.\n", + "\n", + "## Fixed Mission Profile, Fixed Aircraft Wing Aspect Ratio\n", + "\n", + "First, let us run Aviary with a simple setup: fly a prescribed mission profile with an unchanged wing design.\n", + "Here we are varying the durations of each of the phases (climb, cruise, and descent) to minimize fuel burn across the mission.\n", + "The altitude and Mach profiles of the mission are fixed because `optimize_altitude = False` and `optimize_mach = False` for each of the phases in the `phase_info` object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "aircraft_filename = 'models/test_aircraft/aircraft_for_bench_FwFm_simple.csv'\n", + "optimizer = \"IPOPT\"\n", + "make_plots = True\n", + "max_iter = 200\n", + "\n", + "prob = av.run_aviary(aircraft_filename, phase_info, optimizer=optimizer,\n", + " make_plots=make_plots, max_iter=max_iter)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've run the case successfully, let's save and print out the fuel burn value:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fixed_mission_fixed_wing_fuel_burn = prob.get_val('fuel_burned', units='kg')[0]\n", + "fixed_mission_fixed_wing_aspect_ratio = prob.get_val(av.Aircraft.Wing.ASPECT_RATIO)[0]\n", + "print('Mission fuel burn, kg:', fixed_mission_fixed_wing_fuel_burn)\n", + "print('Aspect ratio:', fixed_mission_fixed_wing_aspect_ratio)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fixed Mission Profile, Optimized Aircraft Wing Aspect Ratio\n", + "\n", + "Now we will use the exact same `phase_info` object but set up our Aviary problem such that the aspect ratio of the wing is a design variable.\n", + "This means that Aviary is optimizing the wing aspect ratio while flying the same mission profile as above.\n", + "We would expect that by varying the wing aspect ratio, Aviary could find a lower fuel burn value.\n", + "\n", + "```{note}\n", + "All of the realistic design tradeoffs associated with varying the wing aspect ratio are not necessarily captured in this problem, e.g. the wing structure would need to change. We are simply using this as an example of an aircraft design variable available in Aviary.\n", + "```\n", + "\n", + "When we want to add an aircraft design variable to the Aviary problem, we need to use the Level 2 interface for Aviary.\n", + "This means we can no longer use the all-inclusive `run_aviary` function and instead need to call its constituent methods individually.\n", + "This allows us to insert a line adding the wing aspect ratio as a design variable as shown below.\n", + "This line is highlighted with an in-line comment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prob = av.AviaryProblem(av.AnalysisScheme.COLLOCATION)\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs(aircraft_filename, phase_info)\n", + "\n", + "prob.check_and_preprocess_inputs()\n", + "\n", + "prob.add_pre_mission_systems()\n", + "\n", + "prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "prob.add_driver(optimizer, max_iter=max_iter)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "# The following line is an example of how to add a design variable for the aspect ratio of the wing\n", + "prob.model.add_design_var(av.Aircraft.Wing.ASPECT_RATIO, lower=10., upper=14., ref=12.)\n", + "\n", + "# Load optimization problem formulation\n", + "# Detail which variables the optimizer can control\n", + "prob.add_objective()\n", + "\n", + "prob.setup()\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem(make_plots=make_plots)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fixed_mission_optimized_wing_fuel_burn = prob.get_val('fuel_burned', units='kg')[0]\n", + "fixed_mission_optimized_wing_aspect_ratio = prob.get_val(av.Aircraft.Wing.ASPECT_RATIO)[0]\n", + "print('Mission fuel burn, kg:', fixed_mission_optimized_wing_fuel_burn)\n", + "print('Aspect ratio:', fixed_mission_optimized_wing_aspect_ratio)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, the optimal fuel burn value is lower for this case.\n", + "We'll discuss this in more detail after running two more cases.\n", + "\n", + "## Optimized Mission Profile, Fixed Aircraft Wing Aspect Ratio\n", + "\n", + "We just investigated giving the optimizer flexibility with the aircraft design while not varying the mission.\n", + "Let's now look at the results when we optimize the mission but keep the wing aspect ratio unchanged.\n", + "\n", + "To do this, we will allow the optimizer to control the Mach and altitude profiles by modifying the `phase_info` object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_info['climb_1']['user_options']['optimize_mach'] = True\n", + "phase_info['climb_1']['user_options']['optimize_altitude'] = True\n", + "phase_info['cruise']['user_options']['optimize_mach'] = True\n", + "phase_info['cruise']['user_options']['optimize_altitude'] = True\n", + "phase_info['descent_1']['user_options']['optimize_mach'] = True\n", + "phase_info['descent_1']['user_options']['optimize_altitude'] = True\n", + "\n", + "prob = av.run_aviary(aircraft_filename, phase_info, optimizer=optimizer,\n", + " make_plots=make_plots, max_iter=max_iter)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's see the fuel burn:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "optimized_mission_fixed_wing_fuel_burn = prob.get_val('fuel_burned', units='kg')[0]\n", + "optimized_mission_fixed_wing_aspect_ratio = prob.get_val(av.Aircraft.Wing.ASPECT_RATIO)[0]\n", + "print('Mission fuel burn, kg:', optimized_mission_fixed_wing_fuel_burn)\n", + "print('Aspect ratio:', optimized_mission_fixed_wing_aspect_ratio)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Optimizing the mission did not have nearly as large of an impact on the fuel burn as optimizing the aspect ratio did.\n", + "However, the fuel burn still decreased.\n", + "Let us now look at the fully coupled case.\n", + "\n", + "## Optimized Mission Profile, Optimized Aircraft Wing Aspect Ratio\n", + "\n", + "Remember we have already modified the `phase_info` object so that the Mach and altitude profiles are optimized.\n", + "Now we return to the Level 2 way of running the problem with the wing aspect ratio as a design variable." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prob = av.AviaryProblem(av.AnalysisScheme.COLLOCATION)\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs(aircraft_filename, phase_info)\n", + "\n", + "prob.check_and_preprocess_inputs()\n", + "# Preprocess inputs\n", + "prob.add_pre_mission_systems()\n", + "\n", + "prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "prob.add_driver(optimizer, max_iter=max_iter)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "# prob.model.add_design_var(av.Aircraft.Engine.SCALED_SLS_THRUST, lower=25.e3, upper=30.e3, units='lbf', ref=28.e3)\n", + "prob.model.add_design_var(av.Aircraft.Wing.ASPECT_RATIO, lower=10., upper=14., ref=12.)\n", + "\n", + "# Load optimization problem formulation\n", + "# Detail which variables the optimizer can control\n", + "prob.add_objective()\n", + "\n", + "prob.setup()\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem(make_plots=make_plots)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All right, let's check out this final case's fuel burn value:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "optimized_mission_optimized_wing_fuel_burn = prob.get_val('fuel_burned', units='kg')[0]\n", + "optimized_mission_optimized_wing_aspect_ratio = prob.get_val(av.Aircraft.Wing.ASPECT_RATIO)[0]\n", + "print('Mission fuel burn, kg:', optimized_mission_optimized_wing_fuel_burn)\n", + "print('Aspect ratio:', optimized_mission_optimized_wing_aspect_ratio)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cool, it's the lowest yet!\n", + "Let's discuss these results in more detail now.\n", + "\n", + "## Summary and Takeaways\n", + "\n", + "We have showcased one of Aviary's most powerful capabilities here -- the ability to simultaneously design an aircraft and optimal trajectory.\n", + "By building up problem complexity, we can see how optimizing different parts of the problem lead to optimization objective improvements.\n", + "\n", + "Here is a summary table of the results:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "# Create a dictionary with the data\n", + "data = {\n", + " 'Case': ['Fixed Mission, Fixed Wing', 'Fixed Mission, Optimized Wing', 'Optimized Mission, Fixed Wing', 'Optimized Mission, Optimized Wing'],\n", + " 'Optimize Mission': ['-', '-', '✓', '✓'],\n", + " 'Optimize Wing': ['-', '✓', '-', '✓'],\n", + " 'Aspect Ratio': [fixed_mission_fixed_wing_aspect_ratio, fixed_mission_optimized_wing_aspect_ratio, optimized_mission_fixed_wing_aspect_ratio, optimized_mission_optimized_wing_aspect_ratio],\n", + " 'Fuel Burn Value': [fixed_mission_fixed_wing_fuel_burn, fixed_mission_optimized_wing_fuel_burn, optimized_mission_fixed_wing_fuel_burn, optimized_mission_optimized_wing_fuel_burn]\n", + "}\n", + "\n", + "# Create a DataFrame from the dictionary\n", + "df = pd.DataFrame(data).round(2)\n", + "\n", + "# Display the DataFrame\n", + "df\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the fully coupled case finds the lowest fuel burn value, as expected.\n", + "In both cases where the wing aspect ratio is optimized, it moves to the higher bound.\n", + "\n", + "If we didn't simultaneously design the aircraft and the mission, you would have to manually iterate by first optimizing the aircraft, then the mission, then the aircraft again, etc.\n", + "This cumbersome process is known as sequential optimization and can lead to non-optimal results for coupled systems, as detailed in Section 13.1 of the [Engineering Design Optimization textbook](https://flowlab.groups.et.byu.net/mdobook.pdf) (available for free).\n", + "\n", + "Aviary is unique in its ability to solve these coupled systems using efficient gradient-based optimization.\n", + "\n", + "This doc page contains a simple example, but the true power of coupled multidisciplinary optimization lies in solving more complex design problems.\n", + "We hope that you can effectively use Aviary to optimally design the next generation of exciting aircraft!\n" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/examples/intro.md b/_sources/examples/intro.md new file mode 100644 index 000000000..2af40c2d9 --- /dev/null +++ b/_sources/examples/intro.md @@ -0,0 +1,19 @@ +# Discussing the Aviary Examples + +## Current Aviary examples + +Aviary provides a range of built-in examples that serve as both regression tests and demonstrations of the tool's capabilities. +These examples showcase various full mission analysis and optimization problems, incorporating different subsystem analyses from FLOPS and GASP. +You can find these examples [here](https://github.com/OpenMDAO/om-Aviary/tree/main/aviary/validation_cases/benchmark_tests), especially the files that start `test_swap`. +These cases highlight Aviary's ability to replicate GASP and FLOPS capabilities, as well as use both code's methods in a single analysis. + +In addition to the examples for core Aviary, we also provide some examples for using external subsystems. +These are contained in the `aviary/examples/external_subsystems` folder. +Currently, the folder contains a few different examples, including a battery external subsystem and an example integration with [OpenAeroStruct](https://github.com/mdolab/OpenAerostruct/). +These examples provide a valuable starting point, especially for users interested in integrating their own subsystems into an Aviary model. + +## Future examples + +Aviary's collection of examples is expected to undergo significant expansion in the future, particularly as the user interface continues to evolve and more individuals start using the tool. +The current set of examples provides a solid foundation for understanding Aviary's capabilities and serves as a reference for users. +However, there are plans to greatly expand and diversify the examples to cater to a wider range of aircraft analysis and optimization scenarios. diff --git a/_sources/examples/more_advanced_example.ipynb b/_sources/examples/more_advanced_example.ipynb new file mode 100644 index 000000000..ee8e50ece --- /dev/null +++ b/_sources/examples/more_advanced_example.ipynb @@ -0,0 +1,346 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimizing the Mission Profile of a Conventional Aircraft\n", + "\n", + "Building upon our previous example, this notebook introduces more complexity into the Aviary optimization process.\n", + "Please see the [simple mission example](simple_mission_example) if you haven't already.\n", + "\n", + "## Increasing Complexity in Phase Information\n", + "\n", + "We will now modify the `phase_info` object from our prior example by increasing `num_segments` to 3 and setting `optimize_mach` to `True`.\n", + "This means that we'll query the aircraft performance at more points along the mission and also give the optimizer the freedom to choose an optimal Mach profile.\n", + "\n", + "```{note}\n", + "We are still using a `polynomial_control_order` of 1, which means that the optimal Mach profiles for each phase will be linear (straight lines).\n", + "Later in this example, we increase this order which will allow the optimizer to choose a more complex Mach profile.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_info = {\n", + " \"pre_mission\": {\"include_takeoff\": False, \"optimize_mass\": True},\n", + " \"climb_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": True,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.2, \"unitless\"),\n", + " \"final_mach\": (0.72, \"unitless\"),\n", + " \"mach_bounds\": ((0.18, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (0.0, \"ft\"),\n", + " \"final_altitude\": (30500.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 31000.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": True,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((0.0, 0.0), \"min\"),\n", + " \"duration_bounds\": ((27.0, 81.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([0, 54], \"min\")},\n", + " },\n", + " \"cruise\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": True,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.72, \"unitless\"),\n", + " \"mach_bounds\": ((0.7, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (30500.0, \"ft\"),\n", + " \"final_altitude\": (31000.0, \"ft\"),\n", + " \"altitude_bounds\": ((30000.0, 31500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((27.0, 81.0), \"min\"),\n", + " \"duration_bounds\": ((85.5, 256.5), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([54, 171], \"min\")},\n", + " },\n", + " \"descent_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": True,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 3,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.2, \"unitless\"),\n", + " \"mach_bounds\": ((0.18, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (31000.0, \"ft\"),\n", + " \"final_altitude\": (500.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 31500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": True,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((112.5, 337.5), \"min\"),\n", + " \"duration_bounds\": ((26.5, 79.5), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([225, 53], \"min\")},\n", + " },\n", + " \"post_mission\": {\n", + " \"include_landing\": False,\n", + " \"constrain_range\": True,\n", + " \"target_range\": (1915, \"nmi\"),\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running Aviary with Updated Parameters\n", + "\n", + "Let's run the Aviary optimization with our updated `phase_info` object in the same way as before.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "prob = av.run_aviary('models/test_aircraft/aircraft_for_bench_FwFm_simple.csv',\n", + " phase_info, optimizer=\"SLSQP\", make_plots=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've run Aviary, we can look at the results.\n", + "Open up the automatically generated `traj_results_report.html` and scroll through it to visualize the results.\n", + "\n", + "Here are the altitude and Mach profiles:\n", + "\n", + "![Altitude and Mach Profiles](images/advanced_results.png)\n", + "\n", + "We note two major changes compared to our first example.\n", + "\n", + "The first is that we have many more points where the flight dynamics were evaluated because we increased `num_segments` to 3.\n", + "This means that we have more points shown on the resulting plots.\n", + "\n", + "The second is that the optimizer chose the optimal Mach profile.\n", + "Again, each phase's Mach profile is constrained to be linear because we set `polynomial_control_order` to 1.\n", + "However, we see that the optimizer chose to decrease the Mach number during the cruise-climb segment to minimize fuel burn.\n", + "\n", + "```{note}\n", + "Remember, we did not allow the optimizer to control the altitude profile, so that remains fixed.\n", + "```\n", + "\n", + "Let's take a look at the optimization objective, `fuel_burned`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(prob.get_val('fuel_burned', units='kg')[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modifying the Aircraft Configuration\n", + "\n", + "Next, we'll modify the aircraft configuration by decreasing the wing aspect ratio by 0.2.\n", + "This results in a less slender wing, which will increase the induced drag.\n", + "We've made this change and have a modified aircraft data file called `modified_aircraft.csv`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "import csv\n", + "\n", + "filename = 'models/test_aircraft/aircraft_for_bench_FwFm_simple.csv'\n", + "filename = av.get_path(filename)\n", + "\n", + "# Read the file\n", + "with open(filename, 'r') as file:\n", + " reader = csv.reader(file)\n", + " lines = list(reader)\n", + "\n", + "# Find the index of the line containing 'aircraft:wing:span'\n", + "index = None\n", + "for i, line in enumerate(lines):\n", + " if 'aircraft:wing:aspect_ratio' in line:\n", + " index = i\n", + " break\n", + "\n", + "# Modify the value in the line\n", + "if index is not None:\n", + " aspect_ratio = float(lines[index][1]) - 0.2\n", + " lines[index][1] = str(aspect_ratio)\n", + "\n", + "# Write the modified content to a new CSV file\n", + "new_filename = 'modified_aircraft.csv'\n", + "with open(new_filename, 'w', newline='') as file:\n", + " writer = csv.writer(file)\n", + " writer.writerows(lines)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Re-running the Optimization with Modified Aircraft\n", + "\n", + "Now, let's re-run the optimization with the modified aircraft configuration.\n", + "We'll use the same `phase_info` object as before, but we'll change the input deck to point to our new aircraft file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prob = av.run_aviary('modified_aircraft.csv', phase_info,\n", + " optimizer=\"SLSQP\", make_plots=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The case again converged in relatively few iterations.\n", + "Let's take a look at the fuel burn value:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(prob.get_val('fuel_burned', units='kg')[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, it's a bit higher than our prior run that had a larger aspect ratio.\n", + "\n", + "## Increasing the Polynomial Control Order\n", + "\n", + "Next, we'll increase the `polynomial_control_order` to 3 for the climb and descent phases.\n", + "This means that the optimizer will be able to choose a cubic Mach profile per phase instead of a line.\n", + "We'll use the original aircraft configuration for this run.\n", + "\n", + "```{note}\n", + "We'll use the IPOPT optimizer for this problem as it will handle the increased complexity better than SLSQP.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_info['climb_1']['user_options']['polynomial_control_order'] = 3\n", + "phase_info['cruise']['user_options']['polynomial_control_order'] = 1\n", + "phase_info['descent_1']['user_options']['polynomial_control_order'] = 3\n", + "\n", + "prob = av.run_aviary('models/test_aircraft/aircraft_for_bench_FwFm_simple.csv',\n", + " phase_info, optimizer=\"IPOPT\", make_plots=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And let's print out the objective value, fuel burned:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(prob.get_val('fuel_burned', units='kg')[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The added flexibility in the mission allowed the optimizer to reduce the fuel burn compared to the linear Mach profile case.\n", + "\n", + "Looking at the altitude and Mach profiles, we see that the optimizer chose a more subtly complex Mach profile:\n", + "\n", + "![Altitude and Mach Profiles](images/cubic_advanced_results.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "This example demonstrated how to use Aviary to optimize a more complex mission.\n", + "We increased the number of segments in the mission, allowed the optimizer to choose the optimal Mach profile, and increased the polynomial control order to allow for more complex Mach profiles.\n", + "We also modified the aircraft configuration to demonstrate how Aviary can be used to quickly evaluate the impact of design changes on the mission performance.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/examples/simple_mission_example.ipynb b/_sources/examples/simple_mission_example.ipynb new file mode 100644 index 000000000..40556809d --- /dev/null +++ b/_sources/examples/simple_mission_example.ipynb @@ -0,0 +1,365 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conventional Aircraft and Simple Mission\n", + "\n", + "This is a simple example that explicitly shows all the steps needed to create and solve an Aviary optimization problem.\n", + "We'll be more verbose here than in other examples.\n", + "\n", + "We'll start with an existing aircraft .csv file and discuss some of what goes into that.\n", + "Then we'll define a mission together and explain how you'd modify it to suit your needs.\n", + "Finally, we'll call Aviary to solve the problem and look at the results.\n", + "\n", + "## How to define an aircraft\n", + "\n", + "Aircraft are defined in a .csv file with the following columns:\n", + "\n", + "* variable name: the name of the variable, following the [Aviary variable naming convention](../user_guide/variable_hierarchy.ipynb)\n", + "* value: the user-defined value of the variable\n", + "* units: the units of the variable\n", + "\n", + "Let's take a look at the first few lines of an example aircraft file, `aircraft_for_bench_FwFm_simple.csv`.\n", + "This aircraft is a commercial single-aisle aircraft with two conventional turbofan engines.\n", + "Think of it in the same class as a Boeing 737 or Airbus A320.\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "filename = 'models/test_aircraft/aircraft_for_bench_FwFm_simple.csv'\n", + "filename = av.get_path(filename)\n", + "\n", + "with open(filename, 'r') as file:\n", + " for idx, line in enumerate(file):\n", + " print(line.strip('\\n'))\n", + " if idx > 20:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These are just some of the variables and values contained in the file.\n", + "The full file defines everything we need to model an aircraft in Aviary, including bulk properties, wing and tail geometry, and engine and fuel system parameters.\n", + "\n", + "```{note}\n", + "Depending on which settings you use to run Aviary, your aircraft definition might need specific variables to be defined.\n", + "Please look at relevant examples to see what variables are needed.\n", + "```\n", + "\n", + "For this example case, our model is using the `simple` mission method and `FLOPS`-based mass and aero estimation methods.\n", + "We strongly suggest using the `simple` mission method as it is the most robust and easiest to use.\n", + "There are relatively few reasons to use a more complex mission method and you should only do so if you have a particular reason to use a more detailed method.\n", + "\n", + "## How to define a mission\n", + "\n", + "We'll now discuss how to define the mission that we want the aircraft to fly.\n", + "We could do this a few different ways:\n", + "\n", + "- We could use the `default_simple_mission` file, which contains a default mission definition including climb, cruise, and descent\n", + "- We could programmatically define the mission by defining a `phase_info` dictionary that contains the mission phases and their definitions\n", + "- We could graphically define the mission using the `draw_mission` Aviary command\n", + "\n", + "For this example, let's use the graphical interface to define our mission.\n", + "It's the fastest method, is relatively intuitive, and results in generally less work for the user.\n", + "\n", + "### Drawing a mission profile\n", + "\n", + "To use the graphical interface, open a command prompt (terminal window) and run the following command:\n", + "\n", + "```bash\n", + "aviary draw_mission\n", + "```\n", + "\n", + "This will open a new window with two blank axes and some options and should look like this:\n", + "\n", + "![blank flight profile](images/blank_flight_profile.png)\n", + "\n", + "````{margin}\n", + "```{note}\n", + "Remember that we are defining a mission for a single-aisle commercial aircraft, so our mission definition here should reflect that.\n", + "```\n", + "````\n", + "\n", + "This application is documented in the [drawing and running simple missions doc page](../user_guide/drawing_and_running_simple_missions).\n", + "For now, we'll define a relatively simple mission with three phases: climb, cruise, and descent.\n", + "We've clicked around on our end to make a reasonable flight profile and it looks like this:\n", + "\n", + "![flight profile](images/flight_profile.png)\n", + "\n", + "Feel free to draw your own flight profile or use the results of the one we've drawn here.\n", + "The rest of the example will use the flight profile shown above, but you can replace the `phase_info` dict with your own if you prefer.\n", + "\n", + "Once we're done running the GUI, we hit the `Done` button in the top right corner and we should see output that looks like this:\n", + "\n", + "```bash\n", + "Total range is estimated to be 1915 nautical miles\n", + "reformatted /mnt/c/Users/user/Dropbox/git/Aviary/outputted_phase_info.py\n", + "All done! ✨ 🍰 ✨\n", + "1 file reformatted.\n", + "Phase info has been saved and formatted in /mnt/c/Users/user/Dropbox/git/Aviary/outputted_phase_info.py\n", + "```\n", + "\n", + "If you don't have the [black](https://pypi.org/project/black/) python autoformatter installed, your output may look slightly different - as long as you see confirmation that your phase info has been saved, your mission profile was successfully created.\n", + "\n", + "The `phase_info` dictionary has been saved to a file called `outputted_phase_info.py` in the current directory.\n", + "Let's dig into it.\n", + "\n", + "### Examining the mission definition\n", + "\n", + "Opening the `outputted_phase_info.py` file, we see the entire `phase_info` dictionary that we just defined.\n", + "This is a verbose data object that exposes most of the mission definition parameters that Aviary uses.\n", + "We will not need to modify it for this example, but we are showing it here in its entirety so you can see some of the options that are available to control." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "phase_info = {\n", + " \"pre_mission\": {\"include_takeoff\": False, \"optimize_mass\": True},\n", + " \"climb_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 2,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.2, \"unitless\"),\n", + " \"final_mach\": (0.72, \"unitless\"),\n", + " \"mach_bounds\": ((0.18, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (0.0, \"ft\"),\n", + " \"final_altitude\": (30500.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 31000.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": True,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((0.0, 0.0), \"min\"),\n", + " \"duration_bounds\": ((27.0, 81.0), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([0, 54], \"min\")},\n", + " },\n", + " \"cruise\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 2,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.72, \"unitless\"),\n", + " \"mach_bounds\": ((0.7, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (30500.0, \"ft\"),\n", + " \"final_altitude\": (31000.0, \"ft\"),\n", + " \"altitude_bounds\": ((30000.0, 31500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"boundary_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": False,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((27.0, 81.0), \"min\"),\n", + " \"duration_bounds\": ((85.5, 256.5), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([54, 171], \"min\")},\n", + " },\n", + " \"descent_1\": {\n", + " \"subsystem_options\": {\"core_aerodynamics\": {\"method\": \"computed\"}},\n", + " \"user_options\": {\n", + " \"optimize_mach\": False,\n", + " \"optimize_altitude\": False,\n", + " \"polynomial_control_order\": 1,\n", + " \"num_segments\": 2,\n", + " \"order\": 3,\n", + " \"solve_for_range\": False,\n", + " \"initial_mach\": (0.72, \"unitless\"),\n", + " \"final_mach\": (0.2, \"unitless\"),\n", + " \"mach_bounds\": ((0.18, 0.74), \"unitless\"),\n", + " \"initial_altitude\": (31000.0, \"ft\"),\n", + " \"final_altitude\": (500.0, \"ft\"),\n", + " \"altitude_bounds\": ((0.0, 31500.0), \"ft\"),\n", + " \"throttle_enforcement\": \"path_constraint\",\n", + " \"fix_initial\": False,\n", + " \"constrain_final\": True,\n", + " \"fix_duration\": False,\n", + " \"initial_bounds\": ((112.5, 337.5), \"min\"),\n", + " \"duration_bounds\": ((26.5, 79.5), \"min\"),\n", + " },\n", + " \"initial_guesses\": {\"times\": ([225, 53], \"min\")},\n", + " },\n", + " \"post_mission\": {\n", + " \"include_landing\": False,\n", + " \"constrain_range\": True,\n", + " \"target_range\": (1915, \"nmi\"),\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This `phase_info` dict defines the three-phase mission that we drew in the GUI.\n", + "The first phase is a climb phase that starts at 0 ft and ends at 30500 ft an Mach 0.72.\n", + "The second phase is a cruise-climb phase that starts at 30500 ft and ends at 31000 ft, all at Mach 0.72.\n", + "The third phase is a descent phase that starts at 31000 ft and ends at 500 ft.\n", + "\n", + "We are asking the aircraft to fly a total of 1915 nautical miles.\n", + "This distance was computed based on the user-selected Mach and altitude profiles from the GUI, though you could also specify it directly in the `phase_info`'s `post_mission` nested dict.\n", + "\n", + "```{note}\n", + "When you use the GUI to define a mission, you generally don't need to manually edit the `phase_info` dict.\n", + "If you are doing specific studies or want to fine-tune options, you can edit the `phase_info` dict directly.\n", + "```\n", + "\n", + "## Running Aviary\n", + "\n", + "All right, now that we have an aircraft and a mission, let's run Aviary!\n", + "\n", + "We'll focus on running Aviary using the Level 1 interface, which is the simplest.\n", + "We could do this a few different ways:\n", + "\n", + "- Using the command line interface (CLI) to run Aviary via `aviary run_aviary`\n", + "- Using the Python interface to run Aviary\n", + "\n", + "We'll use the Python interface here, but you can use whichever method you prefer.\n", + "\n", + "### Discussing the problem definition\n", + "\n", + "Before we run Aviary, let's discuss what we're asking it to do.\n", + "We are asking Aviary to fly the prescribed mission using the least amount of fuel possible.\n", + "\n", + "In this case, we are holding the prescribed Mach and altitude values fixed, but allowing the optimizer to control the time spent in each phase.\n", + "To be verbose, in the climb phase the aircraft must start at the initial altitude and Mach values and reach the cruise Mach and altitude values.\n", + "How long it takes to do that is up to the optimizer.\n", + "The same is true for the cruise-climb and descent phases.\n", + "\n", + "In the `simple` mission definition, the throttle value of the propulsion system is solved for by the Aviary model.\n", + "This means that the optimizer will determine the throttle value that allows the aircraft to fly the prescribed mission while minimizing fuel burn across the mission.\n", + "\n", + "We could allow the optimizer to control the Mach and altitude values as well.\n", + "By checking the appropriate boxes in the GUI or by setting the `optimize_mach` or `optimize_altitude` flags to `True` in the `phase_info` dict, Aviary will find the best Mach and altitude values for each phase.\n", + "There are many more options available to expose to the optimizer here that allow us to control the mission definition.\n", + "We will discuss more of these options in other examples.\n", + "\n", + "### Running Aviary using the Python interface\n", + "\n", + "```{note}\n", + "You will see a lot of output when running Aviary. This is normal and expected. We purposefully provide a large amount of information, which is often useful when debugging or understanding your model.\n", + "```\n", + "\n", + "Let's now call Aviary using the `phase_info` object we defined above and the following commands:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "prob = av.run_aviary('models/test_aircraft/aircraft_for_bench_FwFm_simple.csv',\n", + " phase_info, optimizer=\"SLSQP\", make_plots=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our case ran successfully!\n", + "The bottom part of the output, where we see `Optimization Complete`, tells us that Aviary successfully solved the optimization problem.\n", + "\n", + "Because we defined a relatively simple mission, we can use Scipy's SLSQP optimizer to solve the problem.\n", + "More complex mission definitions will require more complex optimizers as discussed in the [optimization algorithms doc page](../theory_guide/optimization_algorithms).\n", + "\n", + "\n", + "### Examining the results\n", + "\n", + "Now that we've run Aviary, let's take a look at the results.\n", + "You could access the `prob` object directly and look at the results, but we'll focus on the examining the automatically-generated output files.\n", + "\n", + "\n", + "\n", + "Navigate to the `reports/problem` folder where you ran Aviary.\n", + "You should see a series of `.html` files that contain the results of the optimization.\n", + "\n", + "We'll look at the `traj_results_report.html` file which is generated by Dymos and shows the results of the trajectory optimization.\n", + "\n", + "![traj results](images/traj_results.png)\n", + "\n", + "This plot shows the points queried by Aviary across the mission and the optimal mission profile.\n", + "Scroll through this report to see how the aircraft flies the mission and how relevant values like drag, throttle, and mass change across the mission.\n", + "\n", + "Each time you run Aviary, these reports are generated and allow you to interpret results.\n", + "You can also use these reports to debug your model if you run into issues.\n", + "\n", + "If you need to access the results programmatically, you can do so by accessing the `prob` object directly.\n", + "\n", + "As an example, here's the objective value (fuel burned):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(prob.get_val('fuel_burned', units='kg')[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "In this example, we showed how to define an aircraft and a mission and then run Aviary to solve the optimization problem.\n", + "We also showed how to examine the results of the optimization.\n", + "\n", + "Other examples go into more detail about controlling optimizer behavior, defining more complex missions, and using different aircraft models." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/getting_started/expected_user_knowledge.md b/_sources/getting_started/expected_user_knowledge.md new file mode 100644 index 000000000..a8bff7ebe --- /dev/null +++ b/_sources/getting_started/expected_user_knowledge.md @@ -0,0 +1,93 @@ +# Expected User Knowledge + +This section details the recommend user knowledge to use Aviary for different purposes. +We'll reference the [three user interface levels](../user_guide/user_interface.md) throughout. + +A graphical summary of the info presented below is shown in the figure. + +![Aviary user knowledge](images/expected_user_knowledge.svg) + +## Recommended background in aircraft design + +One of the most important aspects of performing computational design and optimization is understanding the resulting designs, if they're realistic, and what those designs mean in the real world. +Thus, some knowledge of aircraft design is greatly beneficial when running Aviary. + +At a basic level, the user is expected to understand how conventional aircraft fly simple missions (takeoff, climb, cruise, descent). +Additionally, a simplistic understanding of how forces act on the aircraft during flight is helpful, including aerodynamic lift and drag, propulsive thrust, and the weight of the aircraft. +Many of Aviary's components are based on these basic principles, which are often detailed in introductory aircraft design textbooks, such as [Raymer's Aircraft Design](https://arc.aiaa.org/doi/book/10.2514/4.104909). + +````{margin} +```{note} +We are using Raymer's book as an example of an introductory aircraft design textbook, but there are many other good options available. +We do not explicitly endorse any one textbook or resource. +``` +```` + +More advanced users will benefit by understanding how different mission definitions, constraints, and design variables affect the aircraft design and optimal trajectory. +Advanced users can also benefit from understanding how the different subsystems are modeled and how they interact with each other. +User-defined external subsystems generally require a bit more aircraft design knowledge to understand how to integrate them physically correctly into the Aviary platform. + +## Recommended background in optimization + +Aviary uses many concepts related to multidisciplinary design and optimization (MDO) to perform its design and optimization tasks. +At a simplistic level, knowledge of MDO is not needed to use Aviary. +Aviary's Level 1 interface is made with the goal of being accessible to users with no knowledge of MDO. + +However, to derive the most benefit from Aviary, users should have a basic understanding of MDO concepts. +More advanced knowledge of MDO will be helpful when setting up more complex Aviary models and debugging their behavior. + +The OpenMDAO dev team has a series called [Practical MDO](https://openmdao.github.io/PracticalMDO/intro.html) that is a great resource for learning about MDO. +It consists of short lesson videos and corresponding Python notebooks that teach the basics of MDO. +For a quick view into why we use gradient-based multidisciplinary optimization in Aviary, [check out this video](https://openmdao.github.io/PracticalMDO/Notebooks/Optimization/gradient_based_mdo.html). + +There is also a [free textbook on MDO](http://mdobook.github.io/) written by Professors Joaquim R.R.A. Martins and Andrew Ning. +It is quite readable and available in pdf format. + +````{margin} +```{note} +We also do not officially endorse this textbook. +``` +```` + +## Required programming skills + +The goal of Aviary is to make aircraft design and optimization accessible to a wide range of users while providing a flexible and powerful platform for advanced users. + +This means that the simple user interface at level 1 does not strictly require any programming knowledge. +Users can interact with Aviary through input files and the command line, viewing the results in a web browser. + +At level 2, users are expected to have a basic understanding of Python and object-oriented programming. +Aircraft and mission definition occurs in Python scripts, and users can add their own external subsystems to the Aviary platform. +Knowledge of [OpenMDAO](https://github.com/OpenMDAO/OpenMDAO) is not required at this level, but it is helpful to understand how the Aviary tool is built on top of OpenMDAO. + +Level 3 is the most advanced level, and users are expected to have a strong understanding of Python and object-oriented programming. +Users have complete control over the Aviary model and how the methods are called. + +## Familiarity with dependencies + +As users dig deeper into the Aviary code, they will encounter the various dependencies that Aviary relies on. +The most important of these is OpenMDAO, which is the optimization framework that Aviary is built on top of. In addition to its [basic user guide](https://openmdao.org/newdocs/versions/latest/basic_user_guide/basic_user_guide.htmlAviary), users are encouraged to learn more about the following topics in the [OpenMDAO Advanced User Guide](https://openmdao.org/newdocs/versions/latest/advanced_user_guide/advanced_user_guide.html): + - [Implicit Components](https://openmdao.org/newdocs/versions/latest/features/core_features/working_with_components/implicit_component.html) + - [N2 Diagram](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_details/n2_details.html) + - [Nonlinear and Linear Solvers](https://openmdao.org/newdocs/versions/latest/features/core_features/controlling_solver_behavior/set_solvers.html) + - [BalanceComp](https://openmdao.org/newdocs/versions/latest/advanced_user_guide/models_implicit_components/implicit_with_balancecomp.html) + - [Complex Step](https://openmdao.org/newdocs/versions/latest/advanced_user_guide/complex_step.html) + - [Total Derivative Coloring](https://openmdao.org/newdocs/versions/latest/features/core_features/working_with_derivatives/simul_derivs.html) + - [MetaModelStructuredComp](https://openmdao.org/newdocs/versions/latest/features/building_blocks/components/metamodelstructured_comp.html) + +Aviary also relies on [Dymos](https://github.com/OpenMDAO/Dymos) for its trajectory optimization capabilities. Users are recommended to read through the following sections: + - [Optimal Control](https://openmdao.github.io/dymos/getting_started/optimal_control.html) + - [Phases and Segments](https://openmdao.github.io/dymos/getting_started/intro_to_dymos/intro_segments.html) + - [Aircraft Balanced Field Length Calculation Example](https://openmdao.github.io/dymos/examples/balanced_field/balanced_field.html) + +Again, at levels 1 and 2 an understanding of these dependencies is not strictly required. +More knowledge about OpenMDAO and Dymos when using some portions of level 2 will be helpful. +For example, knowing how to scale variables in OpenMDAO or choosing a reasonable number of nodes in Dymos will be helpful when using the Aviary level 2 interface. + +At level 3, users are expected to have a strong understanding of OpenMDAO and Dymos because they are working directly with these tools. +Starting with no knowledge of OpenMDAO or Dymos is not recommended at this level. + +Starting out with the fantastic [OpenMDAO docs](https://openmdao.org/newdocs/versions/latest/main.html) and looking at some examples there is the best way to learn OpenMDAO. +The [Dymos docs](https://openmdao.github.io/dymos/) and examples are also useful to examine if you're digging more into the trajectory optimization side of Aviary. + + \ No newline at end of file diff --git a/_sources/getting_started/input_csv_phase_info.md b/_sources/getting_started/input_csv_phase_info.md new file mode 100644 index 000000000..08fc04076 --- /dev/null +++ b/_sources/getting_started/input_csv_phase_info.md @@ -0,0 +1,73 @@ +# Vehicle Input .csv File and Phase_info Dictionary + +## Vehicle Input .csv File + +```{note} +This section is under development. +``` + +## Phase Info Dictionary + +`phase_info` is a nested dictionary that Aviary uses for users to define their mission phases - how they are built, the design variables, constraints, connections, etc. + +We will now discuss the meaning of the keys within the `phase_info` objects. + +- If a key starts with `min_` or `max_` or ends with `_lower` or `_upper`, it is a lower or upper bound of a state variable. The following keys are not state variables: + - `required_available_climb_rate`: the minimum rate of climb required from the aircraft at the top of climb (beginning of cruise) point in the mission. You don't want your available rate-of-climb to be 0 in case you need to gain altitude during cruise. + - `EAS_limit`: the maximum descending EAS in knots. + - `throttle_setting`: the prescribed throttle setting. This is only used for `GASP` and `solved` missions. +- If a key ends with `_ref` or `_ref0` (except `duration_ref`, `duration_ref0`, `initial_ref` and `initial_ref0`), it is the unit-reference and zero-reference values of the control variable at the nodes. This option is invalid if opt=False. Note that it is a simple usage of ref and ref0. We refer to [dymos](https://openmdao.github.io/dymos/api/phase_api.html?highlight=ref0#add-state) for details. +- Some keys are for phase time only. + - `duration_ref` and `duration_ref0` are unit-reference and zero reference for phase time duration. + - `duration_bounds` are the bounds (lower, upper) for the time duration of the phase. + - `initial_ref` and `initial_ref0` are the unit-reference and zero references for the initial value of time. + - `time_initial_ref` and `time_initial_ref0` are the unit-reference and zero-reference for the initial value of time. + - `initial_bounds`: the lower and upper bounds of initial time. For `GASP`, it is `time_initial_bounds`. +- If a key starts with `final_`, it is the final value of a state variable. +- If a key ends with `_constraint_eq`, it is an equality constraint. + +- Keys related to altitude: + - In `FLOPS` missions, it is `final_altitude`. In GASP missions, it is `final_alt`. + - Meanwhile, `alt` is a key in acceleration phase parameter for altitude in `GASP` missions and `altitude` is a key in all other phases of all missions. + +- Some keys are a boolean flag of True or False: + - `input_initial`: the flag to indicate whether initial values of of a state (such as: altitude, velocity, mass, etc.) is taken. + - `add_initial_mass_constraint`: the flag to indicate whether to add initial mass constraint + - `clean`: the flag to indicate no flaps or gear are included. + - `connect_initial_mass`: the flag to indicate whether the initial mass is the same as the final mass of previous phase. + - `fix_initial`: the flag to indicate whether the initial state variables is fixed. + - `fix_initial_time`: the flag to indicate whether the initial time is fixed. + - `fix_range`: the flag to indicate whether the range is fixed in this phase. + - `no_climb`: if True for the descent phase, the aircraft is not allowed to climb during the descent phase. + - `no_descent`: if True for the climb phase, the aircraft is not allowed to descend during the climb phase. + - `include_landing`: the flag to indicate whether there is a landing phase. + - `include_takeoff`: the flag to indicate whether there is a takeoff phase. + - `optimize_mass`: if True, the gross takeoff mass of the aircraft is a design variable. + - `target_mach`: the flag to indicate whether to target mach number. +- `initial_guesses`: initial guesses of state variables. +- `COLLOCATION` related keys: + - `num_segments`: the number of segments in transcription creation in dymos. The minimum value is 1. This is needed if 'AnalysisScheme' is `COLLOCATION`. + - `order`: the order of polynomials for interpolation in transcription creation in dymos. The minimum value is 3. This is needed if 'AnalysisScheme' is `COLLOCATION`. +- Other Aviary keys: + - `subsystem_options`: The `aerodynamics` key allows two methods: `computed` and `solved_alpha`. In case of `solved_alpha`, it requires an additional key `aero_data_file`. + - `external_subsystems`: a list of external subsystems. +- other keys that are self-explanatory: + - `clean`: a flag for low speed aero (which includes high-lift devices) or cruise aero (clean, because it does not include high-lift devices). + - `EAS_target`: the target equivalent airspeed. + - `initial_mach`: initial mach number. + - `linear_solver`: provide an instance of a [LinearSolver](https://openmdao.org/newdocs/versions/latest/features/core_features/controlling_solver_behavior/set_solvers.html) to the phase. + - `mach_cruise`: the cruise mach number. + - `mass_f_cruise`: final cruise mass (kg). It is used as `ref` and `defect_ref` in cruise phase. + - `nonlinear_solver`: provide an instance of a [NonlinearSolver](https://openmdao.org/newdocs/versions/latest/features/core_features/controlling_solver_behavior/set_solvers.html) to the phase. + - `ode_class`: default to `MissionODE`. + - `range_f_cruise`: final cruise range (m). It is used as `ref` and `defect_ref` in cruise phase. + - `solve_segments`: False, 'forward', 'backward'. This is a Radau option. + - `polynomial_control_order`: default to `None`. + - `use_actual_takeoff_mass`: default to `False`. + - `fix_duration`: default to `False`. + +```{note} +Not all the keys apply to all phases. The users should select the right keys for each phase of interest. The required keys for each phase are defined in [check_phase_info](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/interface/utils.py) function. Currently, this function does the check only for `FLOPS` and `GASP` missions. +``` + +Users can add their own keys as needed. diff --git a/_sources/getting_started/installation.md b/_sources/getting_started/installation.md new file mode 100644 index 000000000..d8d4fea7d --- /dev/null +++ b/_sources/getting_started/installation.md @@ -0,0 +1,290 @@ +# Installation + +## Quick start installation + +The simplest installation method for users is to install via pip. +Once you have cloned the Aviary repo, change directories into the top-level Aviary folder (not within the `aviary` folder) and run the following command: + + pip install . + +If you want to also run the Aviary test suite (this is not strictly necessary), you can instead run: + + pip install .[test] + +If you also want to install all packages used for the Aviary tests _and_ external subsystem examples, you can instead run: + + pip install .[all] + +If you are a developer and plan to modify parts of the Aviary code, install in an "editable mode" with pip: + + pip install . + +If you are a developer and plan to modify parts of the Aviary code, install in an "editable mode" with ``pip``: + + pip install -e . + +This installs the package in the current environment such that changes to the Python code don't require re-installation. +This command should be performed while in the folder containing ``setup.py``. + +```{note} +You can do this editable installation with any of the `[test]` or `[all]` options as well. +`````` + +## Installation on Linux for Developers + +As an example, let us do a step-by-step installation from scratch on your Linux operating system. We assume that you have [Anaconda](https://www.anaconda.com/distribution) and your new environment will be built on top of it. In this section, we assume you are a developer and hence you will need developer's versions of OpenMDAO and Dymos. As a result, you will need [Git](https://git-scm.com/). We also assume that you have a bash shell. + +We will be installing some Python packages from source in this part of the docs. +Depending on the system you're installing on, the OpenMDAO repositories might require a password-protected SSH key. +This means that users need to [generate a new SSH key and add it to the ssh-agent](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent?platform=linux) and then [add the new SSH key to your GitHub account](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account?platform=linux). +We assume you already have access to the OpenMDAO repos as shown below or that you've already added an SSH key. + +### Preparing your Anaconda Environment + +On the Linux system, log in to your account and create your working directory. +For this doc we will use `workspace`: + +``` +$ mkdir ~/workspace +``` + +Then `cd` to this newly created directory. Please note that `~/workspace` is just an example. In fact, you can install Aviary wherever you want on your system. Save the following as a file named `aviary-linux-dev-modified.yml` to this directory: + +``` +name: av1 +channels: + - defaults +dependencies: + - python=3 + - numpy=1 + - scipy=1 + - matplotlib + - pandas + - jupyter + - pip + - pip: + - parameterized + - testflo + - pyxdsm + - jupyter-book + - mdolab-baseclasses + - sqlitedict + - f90nml + - bokeh +``` + +In this file, the `name` can be anything you like. The version of python is not limited to 3.9, but we recommend that you stay with this version because it is the version that we use to fully test Aviary and that it is required for some packages later on. For example, if you are going to add `OpenVSP` to your environment, you will find that you need this version. + +In the list, we see the popular Python packages for scientific computations: `numpy`, `scipy`, `matplotlib` and `pandas`. Aviary follows a standard source code formatting convention. `autopep8` provides an easy way to check your source code for this purpose. `jupyter` and `jupyter-book` are used to create Aviary manual. `parameterized` and `testflo` are for Aviary testing. `pyxdsm` is used to create XDSM diagrams. Aviary uses a lot of packages developed by [MDOLab](https://mdolab.engin.umich.edu/). So, we want to include its base classes. OpenMDAO records data in SQLite database and that is what `sqlitedict` comes for. `f90nml` is A Python module and command line tool for parsing Fortran namelist files. `bokeh` is an interactive visualization library for modern web browsers. It is needed to generate Aviary output (traj_results_report.html). + +Since we are going to depend on `OpenMDAO` and `dymos`, we could have included them in the `pip` list. We leave them out because we will install the developer version later. In this way, we will get the latest working copies that Aviary depends on. But we do not intend to make changes to them. + +[pre-commit](https://pre-commit.com/) and [autopep8 formatter](https://pypi.org/project/autopep8/) are additionally required for developers who wish to contribute to the Aviary repository. Read our [coding standards](../developer_guide/coding_standards.md) for more information. + +Now, run create your new conda environment using this `.yml` file: + +``` +$ conda env create -n av1 --file aviary-linux-dev-modified.yml +``` + +Suppose everything runs smoothly. You have a new conda environment `av1`. You can start your conda environment: + +``` +$ conda activate av1 +``` + +### Installing Additional Dependencies + +Aviary can run in MPI. So, let us do: + +``` +$ conda install -c conda-forge mpi4py petsc4py +``` + +Download developer version of `OpenMDAO`: + +``` +$ cd ~/workspace +$ git clone git@github.com:OpenMDAO/OpenMDAO.git +``` + +You have a new subdirectory `workspace/OpenMDAO`. You are not expected to modify source code of OpenMDAO, but you want to keep up with the latests version of it. The best way to do is to install OpenMDAO in developer mode. This removes the need to reinstall OpenMDAO after changes are made. Go to this directory where you see a file `setup.py`. Run + +``` +$ cd OpenMDAO +$ pip install -e . +``` + +You should see something like the following: + +``` +Successfully installed networkx-3.1 openmdao-3.29.1.dev0 +``` + +Now, let us install `dymos` in a similar way: + +``` +$ cd ~/workspace/ +$ git clone git@github.com:OpenMDAO/dymos.git +$ cd dymos +$ pip install -e . +``` + +You should see something like the following: + +``` +Successfully installed dymos-1.9.2.dev0 +``` + +### Installing pyOptSparse + +Next, we will install `pyoptsparse`. +The OpenMDAO team provides a [`build_pyoptsparse`](https://github.com/OpenMDAO/build_pyoptsparse) package to help users install MDO Lab's pyOptSparse, optionally including the `SNOPT` and `IPOPT` optimizers. + +This process depends on certain libraries. +One of them is the [Lapack](https://www.netlib.org/lapack/) Fortran library. +If you don't have `Lapack`, you can either [build it from source](https://github.com/Reference-LAPACK/lapack) or try one of the [prebuilt binaries](https://www.netlib.org/lapack/archives/). +We are assuming you have Lapack installed correctly. + +Now do the following: + +``` +$ cd ~/workspace/ +$ git clone git@github.com:OpenMDAO/build_pyoptsparse.git +$ python -m pip install ./build_pyoptsparse +``` + +```{note} +`SNOPT` is a commercial optimizer that is free for academic use and available for puchase for commercial use. Users must obtain it themselves. +``` + +Assuming you have the `SNOPT` source code already, copy it to the `workspace` directory. +Run: + +``` +$ build_pyoptsparse -d -s ~/workspace/SNOPT_Source/ +``` + +Note that you should provide the absolute -- not relative -- path to your SNOPT source files. +If successful, you should get the following: + +``` +---------------------- The pyOptSparse build is complete ---------------------- +NOTE: Set the following environment variable before using this installation: + +export LD_LIBRARY_PATH=$CONDA_PREFIX/lib + +Otherwise, you may encounter errors such as: + "pyOptSparse Error: There was an error importing the compiled IPOPT module" + +----------------------------------- SUCCESS! ---------------------------------- +``` + +So, let us add this environment variable to your bash shell: + +``` +$ export LD_LIBRARY_PATH=$CONDA_PREFIX/lib +``` + +If you don't have the Lapack package and you don't plan to build it by yourself, you can build `pyOptSparse` with `SNOPT` by adding an option `--no-ipopt` to your `build_pyoptsparse` command. + +Alternatively, if `build_pyoptsparse` fails again and you have `SNOPT` source code, you still can build `pyOptSparse` with `SNOPT` by directly building pyOptSparse. +First, clone the `pyOptSparse` repository: + +``` +$ cd ~/workspace/ +$ git clone https://github.com/mdolab/pyoptsparse +``` + +You will see a `pySNOPT` subdirectory in it. Go to your `SNOPT` source folder and copy all Fortran source code files into this directory: + +``` +$ cp -a * ~/workspace/pyoptsparse/pyoptsparse/pySNOPT/source/ +``` + +You are ready to install `pyoptsparse` (with `SNOPT`): + +``` +$ cd ~/workspace/pyoptsparse/ +$ pip install -e . +``` + +You should see something like the following: + +``` +Successfully built pyoptsparse +Installing collected packages: pyoptsparse +Successfully installed pyoptsparse-2.10.1 +``` + +### Installing Aviary and Running Tests + +Now, we are ready to install Aviary. Assuming that you will become a contributor sooner or later, we want to install a copy from the main source. (You will need a GitHub account for this) Let us open `https://github.com/openMDAO/om-aviary/` in a web browser and click [fork](https://github.com/OpenMDAO/om-Aviary/fork) on the top-right corner. You then have created your own copy of Aviary on GitHub website. Now we create a copy on your local drive (supposing `USER_ID` is your GitHub account ID): + +``` +$ cd ~/workspace +$ git clone git@github.com:USER_ID/Aviary.git +$ cd Aviary +$ pip install -e . +``` + +Before we run tests on Aviary, we need to build XDSM diagrams first: + +``` +% cd aviary/xdsm/ +% python run_all.py +``` + +When it is done, let us run test: + +``` +% cd ../.. +% testflo . +``` + +If you run into an MPI error, you can add `--nompi` option to `testflo` command run. If everything runs, you will get something like the following: + +``` +Passed: 875 +Failed: 0 +Skipped: 3 + + +Ran 878 tests using 1 processes +Wall clock time: 00:02:47.31 +``` + +To find which tests are skipped, we can add `--show_skipped` option: + +``` +The following tests were skipped: +test_conventional_problem.py:TestConventionalProblem.test_conventional_problem_ipopt +test_conventional_problem.py:TestConventionalProblem.test_conventional_problem_snopt +test_cruise.py:TestCruise.test_cruise_result +``` + +Actually, those three tests were skipped on purpose. Depending on what optimizers are installed, the number of skipped tests may be different. Your installation is successful. + +To see the test name before each unit test and push all outputs to standard outputs: + +``` +$ testflo -s --pre_announce . +``` + +Run `testflo --help` to see other options. For example, we have a set of longer tests (called bench tests) that perform full trajectory optimizations. To run all the bench tests, you can run this: + +``` +$ cd ~/Aviary/aviary +$ python run_all_benchmarks.py +``` + +If you want to test a particular case (e.g. `test_simplified_takeoff.py`): + +``` +$ testflo test_simplified_takeoff.py +``` + +```{note} +Installing Aviary via pip here does not install all packages needed for external subsystems. +For example, if you're using [OpenVSP](https://openvsp.org/), [pyCycle](https://github.com/OpenMDAO/pyCycle), or other tools outside of "core Aviary", you would need to install those separately. +``` diff --git a/_sources/getting_started/now_what.md b/_sources/getting_started/now_what.md new file mode 100644 index 000000000..32aa296ad --- /dev/null +++ b/_sources/getting_started/now_what.md @@ -0,0 +1,36 @@ +# Now What? + +Now that you've gone through the Getting Started section, you'll probably ask: "Now what?" + +We want to provide a few different avenues and suggested paths forward based on your use cases and background. +These are not the only ways to use Aviary and explicitly do not build on each other. +You could start with one of these sections and then move to another, or you could start with one and never use the others. + +## Starting Simple + +If you just want to start from an existing example and run it, you can do that! +Look at the [Examples docs section](../examples/intro.md), start with a simple one, and modify it as you please. + +We generally recommend starting by running cases using only the `"simple"` mission. +This mission is designed to be more robust and easier to run than other mission types. +[This doc page](../user_guide/drawing_and_running_simple_missions) goes into more detail about how to draw and run simple missions. + +## Adding an External Subsystem + +If you're a user who knows you want to add your own external subsystems and want to get right into it, check out the [external subsystems doc pages](../user_guide/subsystems). +Maybe you want to take an existing aircraft and mission and do some trade studies on the effects of adding a new propulsion system, structural model, or other external subsystem. +If you're not designing an aircraft from the ground up, you might be able to effectively use Aviary without going too deep in the docs or details. + +## Doing Optimization Studies + +The idea of doing "optimization" using Aviary is quite multifaceted. + +You might want to keep an aircraft design fixed and optimize different mission profiles to see how an aircraft should optimally fly for a given range. +Or you might want to redesign an aircraft by doing a wingspan trade study and flying a fixed mission. +Or you can have a fully coupled optimization problem where you're optimizing the aircraft design and mission profile simultaneously. + +For all these problems and more, Aviary can help you better explore your aircraft design space. + +## Go on and Design + +These are just examples of how you might use Aviary -- the sky is the limit! (For now...) diff --git a/_sources/getting_started/onboarding.md b/_sources/getting_started/onboarding.md new file mode 100644 index 000000000..0dda2b818 --- /dev/null +++ b/_sources/getting_started/onboarding.md @@ -0,0 +1,13 @@ +# Onboarding Guide + +We have created a simple onboarding guide to help you get started with Aviary. +This guide goes through Levels 1, 2, and 3 in order, then discusses adding external subsystems to Aviary problems. +This guide is meant to be a quick introduction to Aviary and is not meant to be a comprehensive guide to all of Aviary's features. +Instead, view it as a way to get some more detail and info on portions of Aviary. + +If you have a specific use case for Aviary already and just need to know how to use Aviary to solve your problem, please jump to the User Guide or just search for your desired topic. + +```{note} +These onboarding doc pages were purposefully written by somebody who was new to Aviary. +We hope this addresses some of the first-time questions you may have. +``` \ No newline at end of file diff --git a/_sources/getting_started/onboarding_ext_subsystem.ipynb b/_sources/getting_started/onboarding_ext_subsystem.ipynb new file mode 100644 index 000000000..e9052b03b --- /dev/null +++ b/_sources/getting_started/onboarding_ext_subsystem.ipynb @@ -0,0 +1,763 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ac9434a4", + "metadata": {}, + "source": [ + "# Models with External Subsystems\n", + "\n", + "In level 2, we have given simple examples of defining external subsystems in `phase_info`. The subsystems that we gave were all dummy subsystems and are not really used in simulation. Assume you have an external subsystem and you want to use it. Let us show you how to achieve this goal." + ] + }, + { + "cell_type": "markdown", + "id": "c60ff00e", + "metadata": {}, + "source": [ + "## Installation of Aviary examples\n", + "\n", + "The Aviary team has provided a few external subsystems for you to use.\n", + "These are included in the `aviary/examples/external_subsystems` directory.\n", + "We'll now discuss them here and show you how to use them." + ] + }, + { + "cell_type": "markdown", + "id": "2f17ec04", + "metadata": {}, + "source": [ + "## Adding simple_weight subsystems\n", + "\n", + "Currently, there are a couple of examples: `battery` and `simple_weight`. Let us take a look at `simple_weight` first. As shown in this example, this is a simplified example of a component that computes a weight for the wing and horizontal tail. It does not provide realistic computations but rough estimates to `Aircraft.Wing.MASS` and `Aircraft.HorizontalTail.MASS`. When this external subsystem is added to your pre-mission phase, Aviary will compute these weights in its core subsystem as usual, but then the wing mass and tail mass values will be overridden by this external subsytem.\n", + "\n", + "In [level 2](onboarding_level2), we have briefly covered how to add external subsystems in `phase_info`. Alternatively, external subsystems (and any other new keys) can be added after a `phase_info` is loaded. Let us see how it works using the aircraft_for_bench_FwFm.csv model. First, we import this particular external subsystem.\n", + "\n", + "Then add this external subsystem to `pre_mission`.\n", + "That is all you need to do in addition to our traditional level 2 examples. Here is the complete run script," + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "527dc20b", + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "from aviary.api import Aircraft\n", + "import aviary.api as av\n", + "\n", + "from aviary.examples.external_subsystems.simple_weight.simple_weight_builder import WingWeightBuilder\n", + "\n", + "# Max iterations set to 1 to reduce runtime of example\n", + "max_iter = 1\n", + "phase_info = deepcopy(av.default_simple_phase_info)\n", + "# Here we just add the simple weight system to only the pre-mission\n", + "phase_info['pre_mission']['external_subsystems'] = [WingWeightBuilder(name=\"wing_external\")]\n", + "\n", + "prob = av.AviaryProblem()\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs('models/test_aircraft/aircraft_for_bench_FwFm_simple.csv', phase_info)\n", + "\n", + "# Have checks for clashing user inputs\n", + "# Raise warnings or errors depending on how clashing the issues are\n", + "# prob.check_and_preprocess_inputs()\n", + "\n", + "prob.add_pre_mission_systems()\n", + "\n", + "prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "prob.add_driver(\"SLSQP\", max_iter)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "prob.add_objective()\n", + "\n", + "prob.setup()\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem(suppress_solver_print=True)\n", + "\n", + "print('Engine Mass', prob.get_val(av.Aircraft.Engine.MASS))\n", + "print('Wing Mass', prob.get_val(av.Aircraft.Wing.MASS))\n", + "print('Horizontal Tail Mass', prob.get_val(av.Aircraft.HorizontalTail.MASS))" + ] + }, + { + "cell_type": "markdown", + "id": "3b1d3838", + "metadata": {}, + "source": [ + "Ignore the intermediate warning messages and you see the outputs at the end.\n", + "Since this is a `FLOPS` mission and no objective is provided, we know that the objective is `fuel_burned`.\n", + "\n", + "To see the outputs without external subsystem add-on, let us comment out the lines that add the wing weight builder and run the modified script:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "294128d6", + "metadata": {}, + "outputs": [], + "source": [ + "# # Here we just add the simple weight system to only the pre-mission\n", + "# phase_info['pre_mission']['external_subsystems'] = [WingWeightBuilder(name=\"wing_external\")]\n", + "\n", + "# Max iterations set to 1 to reduce runtime of example\n", + "max_iter = 1\n", + "prob = av.AviaryProblem()\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs('models/test_aircraft/aircraft_for_bench_FwFm_simple.csv', av.default_simple_phase_info)\n", + "\n", + "# Have checks for clashing user inputs\n", + "# Raise warnings or errors depending on how clashing the issues are\n", + "# prob.check_and_preprocess_inputs()\n", + "\n", + "prob.add_pre_mission_systems()\n", + "\n", + "prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "prob.add_driver(\"SLSQP\", max_iter)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "prob.add_objective()\n", + "\n", + "prob.setup()\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem(suppress_solver_print=True)\n", + "\n", + "print('Engine Mass', prob.get_val(Aircraft.Engine.MASS))\n", + "print('Wing Mass', prob.get_val(Aircraft.Wing.MASS))\n", + "print('Horizontal Tail Mass', prob.get_val(Aircraft.HorizontalTail.MASS))" + ] + }, + { + "cell_type": "markdown", + "id": "7df25fe0", + "metadata": {}, + "source": [ + "As we see, the engine mass is not altered but wing mass and tail mass are changed dramatically. This is not surprising because our `simple_weight` subsystem is quite simple. Later on, we will show you a more realistic wing weight external subsystem." + ] + }, + { + "cell_type": "markdown", + "id": "8b725a39", + "metadata": {}, + "source": [ + "## Adding battery subsystem\n", + "\n", + "In the above example, there is no new Aviary variable added to Aviary and the external subsystem is added to pre-mission only. So, the subsystem is not very involved. We will see a more complicated example now. Before we move on, let us recall the steps in Aviary model building:\n", + "\n", + "- **init**\n", + "- **load_inputs**\n", + "- **check_and_preprocess_inputs**\n", + "- **add_pre_mission_systems**\n", + "- **add_phases**\n", + "- **add_post_mission_systems**\n", + "- **link_phases**\n", + "- add_driver\n", + "- **add_design_variables**\n", + "- **add_objective**\n", + "- setup\n", + "- **set_initial_guesses**\n", + "- run_aviary_problem\n", + "\n", + "The steps in bold are related specifically to subsystems. So, almost all of the steps involve subsystems. As long as your external subsystem is built based on the guidelines, Aviary will take care of your subsystem.\n", + "\n", + "The next example is the [battery subsystem](https://github.com/OpenMDAO/Aviary/blob/main/aviary/docs/user_guide/battery_subsystem_example.md). The battery subsystem provides methods to define the battery subsystem's states, design variables, fixed values, initial guesses, and mass names. It also provides methods to build OpenMDAO systems for the pre-mission and mission computations of the subsystem, to get the constraints for the subsystem, and to preprocess the inputs for the subsystem. This subsystem has its own set of variables. We will build an Aviary model with full phases (namely, `climb`, `cruise` and `descent`) and maximize the final total mass: `Dynamic.Mission.MASS`." + ] + }, + { + "cell_type": "markdown", + "id": "689d7dcb", + "metadata": {}, + "source": [ + "We also need `BatteryBuilder` along with battery related aircraft variables and build a new battery object.\n", + "Now, add our new battery subsystem into each phase including pre-mission:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62013c65", + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.examples.external_subsystems.battery.battery_builder import BatteryBuilder\n", + "from aviary.examples.external_subsystems.battery.battery_variables import Aircraft\n", + "\n", + "battery_builder = BatteryBuilder(include_constraints=False)\n", + "\n", + "phase_info['pre_mission']['external_subsystems'] = [battery_builder]\n", + "phase_info['climb']['external_subsystems'] = [battery_builder]\n", + "phase_info['cruise']['external_subsystems'] = [battery_builder]\n", + "phase_info['descent']['external_subsystems'] = [battery_builder]" + ] + }, + { + "cell_type": "markdown", + "id": "4ad934a5", + "metadata": {}, + "source": [ + "Start an Aviary problem and load in an aircraft input deck:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25d2ceb6", + "metadata": {}, + "outputs": [], + "source": [ + "prob = av.AviaryProblem()\n", + "\n", + "prob.load_inputs('models/test_aircraft/aircraft_for_bench_FwFm_simple.csv', phase_info)" + ] + }, + { + "cell_type": "markdown", + "id": "96ebdf23", + "metadata": {}, + "source": [ + "\n", + "In the battery subsystem, the type of battery cell we use is `18650`. The option is not set in `input_file`, instead is is controlled by importing the correct battery map [here](https://github.com/OpenMDAO/om-Aviary/blob/1fca1c03cb2e1d6387442162e8d7dabf83eee197/aviary/examples/external_subsystems/battery/model/reg_thevenin_interp_group.py#L5)." + ] + }, + { + "cell_type": "markdown", + "id": "e92d14c1", + "metadata": {}, + "source": [ + "We can then check our inputs:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7cf0222f", + "metadata": {}, + "outputs": [], + "source": [ + "# Have checks for clashing user inputs\n", + "# Raise warnings or errors depending on severity of the issues\n", + "prob.check_and_preprocess_inputs()" + ] + }, + { + "cell_type": "markdown", + "id": "e8e14515", + "metadata": {}, + "source": [ + "### Checking in the setup function call\n", + "\n", + "Function `setup` can have an argument `check` with default value `False`. If we set it to `True`, it will cause a default set of checks to be run. So, instead of a simple `prob.setup()` call, let us do the following:\n", + "\n", + "The following are a few check points printed on the command line:\n", + "\n", + "```\n", + "INFO: checking system\n", + "INFO: checking solvers\n", + "INFO: checking dup_inputs\n", + "INFO: checking missing_recorders\n", + "```\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00ca5a1f", + "metadata": {}, + "outputs": [], + "source": [ + "prob.add_pre_mission_systems()\n", + "\n", + "traj = prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "max_iter = 1\n", + "prob.add_driver(\"SLSQP\", max_iter)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "prob.add_objective('mass')\n", + "\n", + "prob.setup(check=True)\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem()\n", + "\n", + "# user defined outputs\n", + "print('Battery MASS', prob.get_val(Aircraft.Battery.MASS))\n", + "print('Cell Max', prob.get_val(Aircraft.Battery.Cell.MASS))\n", + "masses_descent = prob.get_val('traj.descent.timeseries.states:mass', units='kg')\n", + "print(f\"Final Descent Mass: {masses_descent[-1]}\")\n", + "\n", + "print('done')" + ] + }, + { + "cell_type": "markdown", + "id": "2fff1bd5", + "metadata": {}, + "source": [ + "## More on outputs\n", + "\n", + "We are done with our model. For our current example, let us add a few more lines after the aviary run:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d376033", + "metadata": {}, + "outputs": [], + "source": [ + "print('Battery MASS', prob.get_val(Aircraft.Battery.MASS))\n", + "print('Cell Max', prob.get_val(Aircraft.Battery.Cell.MASS))" + ] + }, + { + "cell_type": "markdown", + "id": "ed8c764a", + "metadata": {}, + "source": [ + "Since our objective is `mass`, we want to print the value of `Dynamic.Mission.Mass`. Remember, we have imported Dynamic from aviary.variable_info.variables for this purpose.\n", + "\n", + "So, we have to print the final mass in a different way. Keep in mind that we have three phases in the mission and that final mass is our objective. So, we can get the final mass of the descent phase instead. Let us try this approach. Let us comment out the print statement of final mass (and the import of Dynamic), then add the following lines:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eed4e9cf", + "metadata": {}, + "outputs": [], + "source": [ + "masses_descent = prob.get_val('traj.descent.timeseries.states:mass', units='kg')\n", + "print(f\"Final Descent Mass: {masses_descent[-1]}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a60948bc", + "metadata": {}, + "source": [ + "## More on objectives\n", + "\n", + "Now, let us change our objective to battery state of charge after the climb phase. So, comment out `prob.add_objective('mass')` and add the following line right after:\n", + "\n", + "```\n", + "prob.model.add_objective(\n", + " f'traj.climb.states:{Mission.Battery.STATE_OF_CHARGE}', index=-1, ref=-1)\n", + "```\n", + "\n", + "In the above, `index=-1` means the end of climb phase and `ref=-1` means that we want to maximize the state of charge at the end of climb phase. Once again, we are unable to print battery state of charge as we did with battery mass and battery cell mass. We will use the same approach to get mass. In fact, we have prepared for this purpose by setting up time series of climb and cruise phases as well. All we need to do is to add the following lines:\n", + "\n", + "```\n", + "soc_cruise = prob.get_val(\n", + " 'traj.climb.timeseries.states:mission:battery:state_of_charge')\n", + "print(f\"State of Charge: {soc_cruise[-1]}\")\n", + "```\n", + "\n", + "Now you get a new output:\n", + "\n", + "```\n", + "State of Charge: [0.97458496]" + ] + }, + { + "cell_type": "markdown", + "id": "06252511", + "metadata": {}, + "source": [ + "## The check_partials function\n", + "\n", + "In order to make sure that your model computes all the derivatives correctly, OpenMDAO provides a method called `check_partials` which checks partial derivatives comprehensively for all Components in your model. Let us continue in our model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a33a2664", + "metadata": {}, + "outputs": [], + "source": [ + "prob.check_partials(compact_print=True)" + ] + }, + { + "cell_type": "markdown", + "id": "11a63365", + "metadata": {}, + "source": [ + "## Adding an OpenAeroStruct wingbox external subsystem\n", + "\n", + "[OpenAeroStruct](https://github.com/mdolab/OpenAerostruct/) (OAS) is a lightweight tool that performs aerostructural optimization using OpenMDAO. This is an example that shows you how to use an existing external package with Aviary." + ] + }, + { + "cell_type": "markdown", + "id": "2962e2f1", + "metadata": {}, + "source": [ + "### Installation of OpenAeroStruct\n", + "\n", + "We would like to have easy access to the examples and source code. So we install OpenAeroStruct by cloning the OpenAeroStruct repository. We show you how to do the installation on Linux. Assume you want to install it at `~/$USER/workspace`. Do the following:\n", + "\n", + "```\n", + "cd ~/$USER/workspace\n", + "git clone https://github.com/mdolab/OpenAeroStruct.git\n", + "~/$USER/workspace/OpenAeroStruct\n", + "pip install -e .\n", + "```\n", + "\n", + "If everything runs smoothly, you should see something like:\n", + "\n", + "```\n", + "Successfully installed openaerostruct\n", + "```\n", + "\n", + "Most of the packages that OpenAeroStruct depends on are installed already (see [here](https://mdolab-openaerostruct.readthedocs-hosted.com/en/latest/installation.html)). For our example, we need [ambiance](https://pypi.org/project/ambiance/) and an optional package: [OpenVSP](http://openvsp.org/).\n", + "\n", + "To install `ambiance`, do the following:\n", + "\n", + "```\n", + "pip install ambiance\n", + "```\n", + "\n", + "You should see something like:\n", + "\n", + "```\n", + "Installing collected packages: ambiance\n", + "Successfully installed ambiance-1.3.1\n", + "```\n", + "\n", + "```{note}\n", + "You must ensure that the Python version in your environment matches the Python used to compile OpenVSP. You must [install OpenVSP](https://openvsp.org/wiki/doku.php?id=install) on your Linux box yourself.\n", + "```\n", + "\n", + "To check your installation of OpenVSP is successful, please run\n", + "\n", + "```\n", + "(av1)$ python openaerostruct/tests/test_vsp_aero_analysis.py\n", + "```\n", + "\n", + "Windows users should visit [OpenVSP](http://openvsp.org/download.php) and follow the instruction there." + ] + }, + { + "cell_type": "markdown", + "id": "3eb10495", + "metadata": {}, + "source": [ + "### Understanding the OpenAeroStruct Example\n", + "\n", + "The OpenAeroStruct example is explained in detail in [Using Aviary and OpenAeroStruct Together](../examples/OAS_subsystem)." + ] + }, + { + "cell_type": "markdown", + "id": "a9d285b7", + "metadata": {}, + "source": [ + "### Running the OpenAeroStruct Example\n", + "\n", + "We are ready to run this example. First, we create an `OASWingWeightBuilder` instance." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e4482ac", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import openmdao.api as om\n", + "import aviary.api as av\n", + "from aviary.examples.external_subsystems.OAS_weight.OAS_wing_weight_builder import OASWingWeightBuilder\n", + "\n", + "wing_weight_builder = OASWingWeightBuilder()" + ] + }, + { + "cell_type": "markdown", + "id": "3f657b61", + "metadata": {}, + "source": [ + "Let's add a few phases in the mission. In particular, let's add the object we just created as an external subsystem to `pre_mission`.\n", + "We are only adding to `pre_mission` here as the OpenAeroStruct design is only done in the sizing portion of pre-mission and doesn't need to be called during the mission." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d779a398", + "metadata": {}, + "outputs": [], + "source": [ + "# Load the phase_info and other common setup tasks\n", + "phase_info = {\n", + " 'climb_1': {\n", + " 'subsystem_options': {'core_aerodynamics': {'method': 'computed'}},\n", + " 'user_options': {\n", + " 'optimize_mach': False,\n", + " 'optimize_altitude': False,\n", + " 'polynomial_control_order': 1,\n", + " 'num_segments': 5,\n", + " 'order': 3,\n", + " 'solve_for_range': False,\n", + " 'initial_mach': (0.2, 'unitless'),\n", + " 'final_mach': (0.72, 'unitless'),\n", + " 'mach_bounds': ((0.18, 0.74), 'unitless'),\n", + " 'initial_altitude': (0.0, 'ft'),\n", + " 'final_altitude': (32000.0, 'ft'),\n", + " 'altitude_bounds': ((0.0, 34000.0), 'ft'),\n", + " 'throttle_enforcement': 'path_constraint',\n", + " 'fix_initial': True,\n", + " 'constrain_final': False,\n", + " 'fix_duration': False,\n", + " 'initial_bounds': ((0.0, 0.0), 'min'),\n", + " 'duration_bounds': ((64.0, 192.0), 'min'),\n", + " },\n", + " 'initial_guesses': {'times': ([0, 128], 'min')},\n", + " },\n", + " 'climb_2': {\n", + " 'subsystem_options': {'core_aerodynamics': {'method': 'computed'}},\n", + " 'user_options': {\n", + " 'optimize_mach': False,\n", + " 'optimize_altitude': False,\n", + " 'polynomial_control_order': 1,\n", + " 'num_segments': 5,\n", + " 'order': 3,\n", + " 'solve_for_range': False,\n", + " 'initial_mach': (0.72, 'unitless'),\n", + " 'final_mach': (0.72, 'unitless'),\n", + " 'mach_bounds': ((0.7, 0.74), 'unitless'),\n", + " 'initial_altitude': (32000.0, 'ft'),\n", + " 'final_altitude': (34000.0, 'ft'),\n", + " 'altitude_bounds': ((23000.0, 38000.0), 'ft'),\n", + " 'throttle_enforcement': 'boundary_constraint',\n", + " 'fix_initial': False,\n", + " 'constrain_final': False,\n", + " 'fix_duration': False,\n", + " 'initial_bounds': ((64.0, 192.0), 'min'),\n", + " 'duration_bounds': ((56.5, 169.5), 'min'),\n", + " },\n", + " 'initial_guesses': {'times': ([128, 113], 'min')},\n", + " },\n", + " 'descent_1': {\n", + " 'subsystem_options': {'core_aerodynamics': {'method': 'computed'}},\n", + " 'user_options': {\n", + " 'optimize_mach': False,\n", + " 'optimize_altitude': False,\n", + " 'polynomial_control_order': 1,\n", + " 'num_segments': 5,\n", + " 'order': 3,\n", + " 'solve_for_range': False,\n", + " 'initial_mach': (0.72, 'unitless'),\n", + " 'final_mach': (0.36, 'unitless'),\n", + " 'mach_bounds': ((0.34, 0.74), 'unitless'),\n", + " 'initial_altitude': (34000.0, 'ft'),\n", + " 'final_altitude': (500.0, 'ft'),\n", + " 'altitude_bounds': ((0.0, 38000.0), 'ft'),\n", + " 'throttle_enforcement': 'path_constraint',\n", + " 'fix_initial': False,\n", + " 'constrain_final': True,\n", + " 'fix_duration': False,\n", + " 'initial_bounds': ((120.5, 361.5), 'min'),\n", + " 'duration_bounds': ((29.0, 87.0), 'min'),\n", + " },\n", + " 'initial_guesses': {'times': ([241, 58], 'min')},\n", + " },\n", + " 'post_mission': {\n", + " 'include_landing': False,\n", + " 'constrain_range': True,\n", + " 'target_range': (1800., 'nmi'),\n", + " },\n", + "}\n", + "\n", + "phase_info['pre_mission'] = {'include_takeoff': False, 'optimize_mass': True}\n", + "phase_info['pre_mission']['external_subsystems'] = [wing_weight_builder]" + ] + }, + { + "cell_type": "markdown", + "id": "0f1ce46e", + "metadata": {}, + "source": [ + "We can now create an Aviary problem, load in an aircraft input deck, and do routine input checks:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4bef599e", + "metadata": {}, + "outputs": [], + "source": [ + "aircraft_definition_file = 'models/test_aircraft/aircraft_for_bench_FwFm_simple.csv'\n", + "make_plots = False\n", + "max_iter = 0\n", + "optimizer = 'SNOPT'\n", + "\n", + "prob = av.AviaryProblem()\n", + "\n", + "prob.load_inputs(aircraft_definition_file, phase_info)\n", + "prob.check_and_preprocess_inputs()\n", + "prob.add_pre_mission_systems()\n", + "prob.add_phases()\n", + "prob.add_post_mission_systems()\n", + "prob.link_phases()" + ] + }, + { + "cell_type": "markdown", + "id": "0802ff94", + "metadata": {}, + "source": [ + "Next we select the driver and call setup on the problem:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4491a9d", + "metadata": {}, + "outputs": [], + "source": [ + "driver = prob.driver = om.pyOptSparseDriver()\n", + "driver.options[\"optimizer\"] = optimizer\n", + "driver.declare_coloring()\n", + "driver.opt_settings[\"Major iterations limit\"] = max_iter\n", + "driver.opt_settings[\"Major optimality tolerance\"] = 1e-4\n", + "driver.opt_settings[\"Major feasibility tolerance\"] = 1e-5\n", + "driver.opt_settings[\"iSumm\"] = 6\n", + "\n", + "prob.add_design_variables()\n", + "prob.add_objective()\n", + "prob.setup()\n", + "prob.set_initial_guesses()" + ] + }, + { + "cell_type": "markdown", + "id": "354d81f3", + "metadata": {}, + "source": [ + "Now we need to set some OpenAeroStruct-specific parameters before running Aviary:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d83c778", + "metadata": {}, + "outputs": [], + "source": [ + "OAS_sys = 'pre_mission.wing_weight.aerostructures.'\n", + "prob.set_val(OAS_sys + 'box_upper_x', np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6]), units='unitless')\n", + "prob.set_val(OAS_sys + 'box_lower_x', np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6]), units='unitless')\n", + "prob.set_val(OAS_sys + 'box_upper_y', np.array([ 0.0447, 0.046, 0.0472, 0.0484, 0.0495, 0.0505, 0.0514, 0.0523, 0.0531, 0.0538, 0.0545, 0.0551, 0.0557, 0.0563, 0.0568, 0.0573, 0.0577, 0.0581, 0.0585, 0.0588, 0.0591, 0.0593, 0.0595, 0.0597, 0.0599, 0.06, 0.0601, 0.0602, 0.0602, 0.0602, 0.0602, 0.0602, 0.0601, 0.06, 0.0599, 0.0598, 0.0596, 0.0594, 0.0592, 0.0589, 0.0586, 0.0583, 0.058, 0.0576, 0.0572, 0.0568, 0.0563, 0.0558, 0.0553, 0.0547, 0.0541]), units='unitless')\n", + "prob.set_val(OAS_sys + 'box_lower_y', np.array([-0.0447, -0.046, -0.0473, -0.0485, -0.0496, -0.0506, -0.0515, -0.0524, -0.0532, -0.054, -0.0547, -0.0554, -0.056, -0.0565, -0.057, -0.0575, -0.0579, -0.0583, -0.0586, -0.0589, -0.0592, -0.0594, -0.0595, -0.0596, -0.0597, -0.0598, -0.0598, -0.0598, -0.0598, -0.0597, -0.0596, -0.0594, -0.0592, -0.0589, -0.0586, -0.0582, -0.0578, -0.0573, -0.0567, -0.0561, -0.0554, -0.0546, -0.0538, -0.0529, -0.0519, -0.0509, -0.0497, -0.0485, -0.0472, -0.0458, -0.0444]), units='unitless')\n", + "prob.set_val(OAS_sys + 'twist_cp', np.array([-6., -6., -4., 0.]), units='deg')\n", + "prob.set_val(OAS_sys + 'spar_thickness_cp', np.array([0.004, 0.005, 0.008, 0.01]), units='m')\n", + "prob.set_val(OAS_sys + 'skin_thickness_cp', np.array([0.005, 0.01, 0.015, 0.025]), units='m')\n", + "prob.set_val(OAS_sys + 't_over_c_cp', np.array([0.08, 0.08, 0.10, 0.08]), units='unitless')\n", + "prob.set_val(OAS_sys + 'airfoil_t_over_c', 0.12, units='unitless')\n", + "prob.set_val(OAS_sys + 'fuel', 40044.0, units='lbm')\n", + "prob.set_val(OAS_sys + 'fuel_reserve', 3000.0, units='lbm')\n", + "prob.set_val(OAS_sys + 'CD0', 0.0078, units='unitless')\n", + "prob.set_val(OAS_sys + 'cruise_Mach', 0.785, units='unitless')\n", + "prob.set_val(OAS_sys + 'cruise_altitude', 11303.682962301647, units='m')\n", + "prob.set_val(OAS_sys + 'cruise_range', 3500, units='nmi')\n", + "prob.set_val(OAS_sys + 'cruise_SFC', 0.53 / 3600, units='1/s')\n", + "prob.set_val(OAS_sys + 'engine_mass', 7400, units='lbm')\n", + "prob.set_val(OAS_sys + 'engine_location', np.array([25, -10.0, 0.0]), units='m')" + ] + }, + { + "cell_type": "markdown", + "id": "d345e83d", + "metadata": {}, + "source": [ + "We are now ready to run Aviary on this model.\n", + "Note that there are multiple numbers of optimization loops that are output from this run even though we have set `max_iter` to 0.\n", + "This is because OpenAeroStruct has an optimization process internally. In order to shorten the runtime, we have set `run_driver = False`. This means that we will not run optimization but [run model](https://openmdao.org/newdocs/versions/latest/features/core_features/running_your_models/run_model.html). " + ] + }, + { + "cell_type": "markdown", + "id": "b72253c8", + "metadata": {}, + "source": [ + "Finally, we print the newly computed wing mass:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dbb2078f", + "metadata": {}, + "outputs": [], + "source": [ + "print('wing mass = ',prob.model.get_val(av.Aircraft.Wing.MASS, units='lbm'))" + ] + }, + { + "cell_type": "markdown", + "id": "c04ddce7", + "metadata": {}, + "source": [ + "The result is comparable to the output without OpenAeroStruct external subsystem." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/getting_started/onboarding_level1.ipynb b/_sources/getting_started/onboarding_level1.ipynb new file mode 100644 index 000000000..62fff50a8 --- /dev/null +++ b/_sources/getting_started/onboarding_level1.ipynb @@ -0,0 +1,740 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e78c2158", + "metadata": {}, + "source": [ + "# Level 1\n", + "\n", + "## What is level 1\n", + "\n", + "This part is a tutorial type introduction. We assume users have read [Aviary User Interface](../user_guide/user_interface.md). In this doc page we discuss Level 1's interface, but also other details, such as inputs and outputs.\n", + "\n", + "If you have not yet, make sure to [install Aviary](installation.md).\n", + "\n", + "To run Aviary in the Level 1 command-line interface (CLI), type this in a terminal:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e8edc4a", + "metadata": {}, + "outputs": [], + "source": [ + "!aviary" + ] + }, + { + "cell_type": "markdown", + "id": "3d90517d", + "metadata": {}, + "source": [ + "We'll now discuss the different parts of the CLI.\n", + "\n", + "## Aviary fortran_to_aviary command\n", + "\n", + "```{note}\n", + "You only need to use the `fortran_to_aviary` command if you are converting a FLOPS or GASP deck to Aviary's csv format.\n", + "```\n", + "\n", + "This [`fortran_to_aviary`](../user_guide/aviary_commands.ipynb) tool converts FORTRAN namelists into Aviary's csv based format using the mappings found in the `historical_name` section of the [variable_meta_data](../user_guide/variable_metadata.ipynb). The resulting csv is automatically sorted into three sections:\n", + "1. **Input Values:**\n", + " Any FORTRAN variables that were mapped to input variables in Aviary components\n", + "2. **Initial Guesses:**\n", + " Some variables are only used as initial guesses for the trajectory.\n", + " These are displayed separately from the Input Values because they will not be passed directly to components\n", + "3. **Unconverted Values:**\n", + " If the fortran_to_aviary converter can't find an Aviary variable that matches the FORTRAN variable, it is added to the end of the csv file.\n", + " We recommend that you check this section after converting a namelist to ensure that there aren't any variables you expected to be converted here.\n", + " Many of these unconverted variables represent features or options that are not used in Aviary and can be safely ignored. Variables related to mission definition are important, but Aviary defines mission profiles in a significantly different way. Currently, the user must build a new [mission definition file](../examples/simple_mission_example.ipynb) that recreates the mission.\n", + " Aviary will ignore unconverted variables when loading the csv, so you can safely leave them.\n" + ] + }, + { + "cell_type": "markdown", + "id": "3283590e", + "metadata": {}, + "source": [ + "## Aviary run_mission command\n", + "\n", + "The Level 1 CLI (i.e. `run_mission` option) is designed to offer the lowest barrier to entry for new users.\n", + "Analysts who have experience with legacy tools, such as `FLOPS` and `GASP`, should find the switch from FORTRAN namelists to csv-based input decks to be straightforward. Aviary input decks allow the user the ability to set aircraft characteristics and basic mission parameters,\n", + "such as cruise Mach number and altitude, in a simple text-based format that does not require any familiarity with Python or OpenMDAO.\n", + "\n", + "Aviary can then be executed by calling [`aviary run_mission`](../user_guide/aviary_commands.ipynb) with the csv input deck.\n", + "Although the order of the variables in the input deck is not important, you might find it helpful to separate the variables based on if they're used as initial guesses or in the metadata." + ] + }, + { + "cell_type": "markdown", + "id": "d0094350", + "metadata": {}, + "source": [ + "## First aircraft model\n", + "\n", + "We have a few sample aircraft csv files in `aviary/models`. They are all `.csv` files. For example, `aircraft_for_bench_GwGm.csv` is a large single aisle aircraft mission model.\n", + "\n", + "Open `aircraft_for_bench_GwGm.csv` using your favorite editor (e.g., MS Excel or VS Code). If you choose to use MS Excel, you need to take extra steps to make sure that it is in the original format. We recommend running dos2unix first (e.g. `dos2unix aircraft_for_bench_GwGm.csv`).\n", + "\n", + "The file `aircraft_for_bench_GwGm.csv` is a data input file modeling large single aisle aircraft which was converted from a `GASP` input deck.\n", + "Here is a snippet of the file:\n", + "\n", + "```\n", + "debug_mode,False\n", + "\n", + "aircraft:controls:cockpit_control_mass_scaler,1,unitless\n", + "aircraft:controls:control_mass_increment,0,lbm\n", + "aircraft:controls:stability_augmentation_system_mass,0,lbm\n", + "......\n", + "mission:design:cruise_altitude,37500,ft\n", + "mission:design:gross_mass,175400,lbm\n", + "......\n", + "reserves,0\n", + "rotation_mass,0.99\n", + "time_to_climb,0\n", + "......\n", + "INGASP.ALR,1.11,\n", + "INGASP.BENGOB,0.05,\n", + "INGASP.CINP,0.11,\n", + "......\n", + "```\n", + "\n", + "The input `.csv` file defines the aircraft and mission. In an Aviary input file you see a list of Aviary variables, their values, and units. Aviary variables are colon delimited strings (e.g. `aircraft:wing:aspect_ratio`). An Aviary variable name usually has three words. The first word is `aircraft` or `mission`, the second word is a subsystem name and the third is the variable name. Each variable has a value and units. Aviary requires units for every variable because it reduces errors and is a good engineering practice.\n", + "\n", + "```{note}\n", + "If you have used the `fortran_to_aviary` tool to create a `.csv` file you must check the outputted variable values and units to ensure the file is valid and what you expect.\n", + "```\n", + "\n", + "Be aware that some variables do not follow the standard naming format (e.g. `reserves`). These are used for the initial guessing of the trajectory. They are intentionally separate to prevent conflicts with some similarly named variables. They are only used once to set up the problem and then are discarded.\n", + "\n", + "Finally we see a list of `GASP` variables that are not converted. Not all variables are converted to Aviary right now. They may represent some features in `FLOPS` and `GASP` that we haven't implemented in Aviary yet.\n", + "\n", + "To find information about a variable (e.g. description, data type, etc.), users should read the [Variable Metadata Doc](../user_guide/variable_metadata).\n", + "\n", + "There are special rules for the mapping from the input file variable names to the metadata. For example, variable `aircraft:wing:aspect_ratio` in `aircraft_for_bench_GwGm.csv` is mapped to `Aircraft.Wing.ASPECT_RATIO` in `aviary/variable_info/variable_meta_data.py`. So, the first part (e.g., `aircraft` or `mission`) is mapped to the same word but with the first letter capitalized (e.g., `Aircraft` or `Mission`). The third word is all caps (e.g., `ASPECT_RATIO`). The middle part (e.g., `wing`) is a little more complicated. In most cases, this part capitalizes the first letter (e.g., `Wing`). The following words have special mappings:\n", + "\n", + "- `air_conditioning -> AirConditioning`\n", + "- `anti_icing -> AntiIcing`\n", + "- `blended_wing_body -> BWB`\n", + "- `crew_and_payload -> CrewPayload`\n", + "- `horizontal_tail -> HorizontalTail`\n", + "- `landing_gear -> LandingGear`\n", + "- `tail_boom -> TailBoom`\n", + "- `vertical_tail -> VerticalTail`\n", + "\n", + "This can be summarized as to capitalize the leading letter and to capitalize the first letter after special character “`_`”.\n", + "\n", + "File `aviary/variable_info/variables.py` is a variable hierarchy that is for a single mission. Each mission gets a copy of this hierarchy. Below is a snippet of this file:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f57d6c96", + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "# Get the path of variables.py within the aviary package\n", + "file_path = av.get_path('variable_info/variables.py')\n", + "\n", + "# Read and print the first 15 lines of the file\n", + "with open(file_path, 'r') as file:\n", + " for i in range(18):\n", + " print(file.readline().strip('\\n'))" + ] + }, + { + "cell_type": "markdown", + "id": "b597474e", + "metadata": {}, + "source": [ + "Aviary variables are always set to default values before the input file is read in. Then Aviary will update the values based on the user-provided `.csv` input file. If you want to set different values, you can set them in the `.csv` input file.\n", + "\n", + "In input `*.csv` files, the first line is usually `debug_mode` with value of `FALSE`. If you are debugging, you may set it to `TRUE` and more information will be output on the command line when you run your model. Most of the additional lines of output are from your optimizer. The `debug_mode` variable does not help a new user very much and is primarily for advanced users.\n", + "\n", + "## First level 1 run\n", + "\n", + "We are ready to run some models. By default, Aviary runs the optimizer for up to 50 iterations. In order to reduce the run time, we will limit the maximum number of iterations to 1. It will be faster for these examples, but you will not get optimal solutions. Issue the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67de9023", + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "!aviary run_mission models/test_aircraft/aircraft_for_bench_GwGm.csv --max_iter 1 --optimizer IPOPT" + ] + }, + { + "cell_type": "markdown", + "id": "64022b56", + "metadata": {}, + "source": [ + "The argument `models/test_aircraft/aircraft_for_bench_GwGm.csv` shows where the aircraft csv file lives. This argument must be one of the following three options:\n", + "\n", + "- an absolute path,\n", + "- a relative path relative to the current working directory,\n", + "- a relative path relative to the Aviary package.\n", + "\n", + "Aviary searches for the given dataset in this order. If a dataset file exists in multiple directories, the first one Aviary finds will be used." + ] + }, + { + "cell_type": "markdown", + "id": "dac23ffb", + "metadata": {}, + "source": [ + "## Warning messages\n", + "\n", + "During your first run you may notice some warning messages in the Aviary output. Frequently seen warnings are:\n", + "\n", + "- **PromotionWarning:** Issued when there is ambiguity due to variable promotion (an [OpenMDAO warning](https://openmdao.org/newdocs/versions/latest/features/warning_control/warnings.html)).\n", + "- **RuntimeWarning:** Issued for warnings about dubious runtime features (a [Python warning](https://docs.python.org/3/library/warnings.html)).\n", + "- **UserWarning:** Issued for warnings about potential OpenMDAO, Dymos, and/or Aviary problems.\n", + "- **DerivativesWarning:** Issued when the approximated partials or coloring cannot be evaluated as expected (an [OpenMDAO warning](https://openmdao.org/newdocs/versions/latest/features/warning_control/warnings.html)).\n", + "\n", + "Some of these warnings are expected and can be ignored. For example, the following warnings are expected when running the `aircraft_for_bench_GwGm.csv` model:\n", + "\n", + "```\n", + "~/workspace/OpenMDAO/openmdao/core/group.py:326: PromotionWarning:: Setting input defaults for input 'mission:takeoff:ascent_duration' which override previously set defaults for ['auto', 'prom', 'src_shape', 'val'].\n", + "~/workspace/dymos/dymos/phase/phase.py:2007: RuntimeWarning: Invalid options for non-optimal control 'throttle' in phase 'groundroll': lower, upper\n", + " warnings.warn(f\"Invalid options for non-optimal control '{name}' in phase \"\n", + "~/workspace/dymos/dymos/phase/phase.py:1967: UserWarning: Phase time options have no effect because fix_initial=True or input_initial=True for phase 'traj.phases.rotation': initial_ref\n", + " warnings.warn(f'Phase time options have no effect because fix_initial=True '\n", + "```\n", + "\n", + "For now, we can ignore the warning messages and continue.\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "4102fcb4", + "metadata": {}, + "source": [ + "## Level 1 run options\n", + "In addition to a model input file, this option has additional options that are important, as seen here:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8463ef9b", + "metadata": {}, + "outputs": [], + "source": [ + "!aviary run_mission" + ] + }, + { + "cell_type": "markdown", + "id": "8986a4d5", + "metadata": {}, + "source": [ + "Let us discuss these in more detail:\n", + "\n", + "- `-o ––outdir`: Use specified directory to write output. The default is the current directory.\n", + "\n", + "- `--optimizer`: Name of optimizer. Choices are: `SNOPT`, `IPOPT`, `SLSQP`, and `None`. The default is `SNOPT`. If optimizer is `None`, it will be set to `IPOPT` or `SNOPT` depending on the analysis scheme. The optimization objective is fuel burn for level 1 runs. The objective is\n", + " - `mission:objectives:fuel` if `mission_method` is `GASP` \n", + " - `fuel_burned` if `mission_method` is `FLOPS`.\n", + "\n", + "- `--phase_info`: Path to phase info file. If not provided, it is `default_phase_info/gasp.py` if Mission origin is `2DOF` and `default_phase_info/flops.py` for `height_energy`.\n", + "\n", + "- `--n2`: Generate an n2 diagram after the analysis. “[N2](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_basics/n2_basics.html)” diagram is an OpenMDAO helper to visualize the model (see [details](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_details/n2_details.html) too and [tutorial](https://www.youtube.com/watch?v=42VtbX6CX3A)). It is highly recommended that this option is turned on for new users.\n", + "\n", + "- `--max_iter`: Maximum number of iterations. Default is 50.\n", + "\n", + "- `shooting`: Use shooting instead of collocation.\n", + "\n", + "For `aircraft_for_bench_GwGm` example so far, we have used the `SNOPT` optimizer because it is the default. If we want to use the `IPOPT` optimizer, we can run:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6308c017", + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "!aviary run_mission models/test_aircraft/aircraft_for_bench_GwGm.csv --optimizer IPOPT --max_iter 1" + ] + }, + { + "cell_type": "markdown", + "id": "74c88a21", + "metadata": {}, + "source": [ + "## Other available input files\n", + "\n", + "Other input files reside in aviary/models. They include:\n", + "\n", + "```\n", + "aviary/models/validation_data/N3CC/N3CC_generic_low_speed_polars_FLOPSinp.csv\n", + "aviary/models/large_single_aisle_1/large_single_aisle_1_GwGm.csv\n", + "aviary/models/small_single_aisle/small_single_aisle_GwGm.csv\n", + "aviary/models/test_aircraft/converter_configuration_test_data_GwGm.csv\n", + "```\n", + "\n", + "For example, to run `large_single_aisle_1` model, you execute the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f10bc75", + "metadata": {}, + "outputs": [], + "source": [ + "!aviary run_mission models/large_single_aisle_1/large_single_aisle_1_GwGm.csv --max_iter 1 --optimizer IPOPT" + ] + }, + { + "cell_type": "markdown", + "id": "c64a853c", + "metadata": {}, + "source": [ + "For FLOPS-derived models, let us run:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5217ccc8", + "metadata": {}, + "outputs": [], + "source": [ + "!aviary run_mission models/test_aircraft/aircraft_for_bench_FwFm.csv --max_iter 1 --optimizer IPOPT" + ] + }, + { + "cell_type": "markdown", + "id": "30ec0526", + "metadata": {}, + "source": [ + "## Phase info\n", + "\n", + "Aviary runs depend not only on input `*.csv` files, but also on `phase_info` dictionaries. A `phase_info` dictionary defines the mission and any analysis settings used within Aviary. It is used by Aviary to build a mission trajectory (e.g., from take-off to landing).\n", + "\n", + "A [Python dictionary](https://www.w3schools.com/python/python_dictionaries.asp) is a set of key-value pairs. Most keys in `phase_info` are self-explained. Users should read Dymos' [Phase Options](https://openmdao.github.io/dymos/api/phase_api.html). For more details about phase_info keys, especially their example usages, please read [onboarding phase information](input_csv_phase_info.md).\n", + "\n", + "### Default GASP phases\n", + "\n", + "The `default_phase_info/two_dof.py` file is shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b52be376", + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "# Get the path of variables.py within the aviary package\n", + "file_path = av.get_path('interface/default_phase_info/two_dof.py')\n", + "\n", + "# Read the file contents\n", + "with open(file_path, 'r') as file:\n", + " # Find the line that starts with 'phase_info ='\n", + " for line in file:\n", + " if line.startswith('phase_info ='):\n", + " print(line.strip('\\n'))\n", + " break\n", + " \n", + " # Print the remaining lines\n", + " for line in file:\n", + " print(line.strip('\\n'))\n" + ] + }, + { + "cell_type": "markdown", + "id": "73ee7276", + "metadata": {}, + "source": [ + "The file `default_phase_info/gasp.py` contains the following phases:\n", + "\n", + "```\n", + "groundroll, rotation, ascent, accel, climb1, climb2, cruise, desc1, desc2.\n", + "```\n", + "\n", + "All of the above phases belong to mission. No pre-mission phase is provided. If `pre_mission` is missing, a default `pre_mission` is provided:\n", + "```\n", + " 'pre_mission': {\n", + " 'include_takeoff': True,\n", + " 'external_subsystems': [],\n", + " }\n", + "```\n", + "\n", + "Similarly, if no post-mission phase is provided, then a default `post_mission` is provided:\n", + "```\n", + " 'post_mission': {\n", + " 'include_landing': True,\n", + " 'external_subsystems': [],\n", + " },\n", + "```\n", + "\n", + "For `GASP' missions, taxi is considered part of pre-mission and landing is considered part of post-mission." + ] + }, + { + "cell_type": "markdown", + "id": "831d9967", + "metadata": {}, + "source": [ + "#### Groundroll phase\n", + "\n", + "Let us discuss the groundroll phase in detail as an example.\n", + "\n", + "In `groundroll` phase, we are given `duration_bounds` of `((1., 100.), 's')` and a reference value `duration_ref` of `(50., 's')`. Here, `duration_bounds` is a tuple of (lower, upper) bounds for the duration of the integration variable across the phase and `duration_ref` is the unit-reference value for the duration of the integration variable across the phase (see [Dymos Variables](https://openmdao.github.io/dymos/features/phases/variables.html)). This implies a time range of `(0.2, 2)` in ground roll phase, or:\n", + "```\n", + "0.02 ≤ traj.groundroll.t_duration ≤ 2.\n", + "```\n", + "We see `TAS_lower: (0, 'kn')`, `TAS_upper: (1000, 'kn')`, and `TAS_ref: (100, 'kn')`. They result in `TAS` as a design variable with a range: `(0, 10)`, or\n", + "```\n", + "0 ≤ traj.groundroll.states:TAS ≤ 10.\n", + "```\n", + "Similarly, we get:\n", + "```\n", + "0 ≤ traj.groundroll.states:distance ≤ 3.3333\n", + "```\n", + "The mass parameter is a little bit different because we have `mass_upper: (None, 'lbm')` (and `mass_lower: (0, 'lbm')`). In this situation, OpenMDAO provides replaces the `None` with an actual upper bound that is very large. We get:\n", + "```\n", + "0 ≤ traj.groundroll.states:mass ≤ 5.7e+15.\n", + "```\n", + "Comparing to `TAS` and `distance`, `mass` is not scaled to the same range. This is okay because aircraft mass is actually a constant in this phase. A huge upper bound will not have an impact.\n", + "\n", + "In ground roll phase, throttle setting is set to maximum (1.0). Aviary sets a phase parameter:\n", + "```\n", + "Dynamic.Mission.THROTTLE = 1.0\n", + "```\n", + "For the [`COLLOCATION`](https://openmdao.github.io/dymos/getting_started/collocation.html) setting, there is one [segment](https://openmdao.github.io/dymos/getting_started/intro_to_dymos/intro_segments.html) (`'num_segments': 1`) and polynomial interpolation degree is 3 (`'order': 3`). Increasing the number of segments and/or increasing the degree of polynomial will improve accuracy but will also increase the complexity of computation. For groundroll, it is unnecessary.\n", + "\n", + "Since groundroll is the first phase, `connect_initial_mass` is set to `False`. `fix_initial` is set to `True`, but `fix_initial_mass` to `False` because aircraft total mass is a design parameter.\n", + "\n", + "Parameter `mass_defect_ref: (10.e3, 'lbm')` (or `mass_defect_ref: (1.e4, 'lbm')`) lbm. Defect is a residual that measures how accurately the proposed state and control history obeyed the ODE governing the system dynamics. For distance, the defect reference is `100` ft. For `TAS`, `defect_ref` is not provided. The default behavior is to make make the `defect_ref` equal to the `ref` value. Please see [here](https://stackoverflow.com/questions/65243017/openmdao-dymos-defect-refs-how-should-i-set-these) for more info.\n", + "\n", + "#### Other phases\n", + "\n", + "We will not discuss the other phases in detail.\n", + "\n", + "Phase `climb1` is for climb up to 10,000 ft and phase `climb2` is for climb to cruise phase. Phase `desc1` is for descent down to 10,000 ft and phase `desc2` is for descent from 10,000 ft down to 1,000 ft." + ] + }, + { + "cell_type": "markdown", + "id": "086a4719", + "metadata": {}, + "source": [ + "### Default FLOPS phases\n", + "\n", + "The file `default_phase_info/flops.py` contains the following phases:\n", + "\n", + "```\n", + "pre_mission, climb, cruise, descent, post_mission\n", + "```\n", + "\n", + "The differences between `GASP` and `FLOPS` phases are due to how `GASP` and `FLOPS` implement trajectory analysis.\n", + "\n", + "```{note}\n", + "File `default_phase_info/flops.py` has a `pre_mission` phase and a `post_mission` phase. In `pre_mission`, `takeoff` is the simplified takeoff and in `post_mission`, `landing` is the simplified landing. For `FLOPS` missions, there are [detailed takeoff and landing](../user_guide/FLOPS_based_detailed_takeoff_and_landing) available. But they are not used in `default_phase_info/flops.py`. The other phases are mission phases.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "0d519d21", + "metadata": {}, + "source": [ + "## Outputted files and how to read them\n", + "\n", + "```{note}\n", + "Please also see [this doc page](../user_guide/outputs_and_how_to_read_them.md) for more info about the Aviary dashboard and the information is contains.\n", + "```\n", + "\n", + "Each standard run generates several output files. Which output files are generated depend on the run options. In this section, we assume that we've set `max_iter = 50` in order to make sure of convergence. The following screenshots used in this article are all from a run using `aircraft_for_bench_GwGm.csv`.\n", + "\n", + "First, there is always a sub-folder `reports/aviary` that contains a few HTML files.\n", + "\n", + "- `driver_scaling_report.html`\n", + "- `inputs.html`\n", + "- `n2.html`\n", + "- `opt_report.html`\n", + "- `total_coloring.html`\n", + "- `traj_linkage_report.html`\n", + "- `traj_results_report.html`" + ] + }, + { + "cell_type": "markdown", + "id": "3794fb45", + "metadata": {}, + "source": [ + "### File `driver_scaling_report.html`\n", + "\n", + "This file is a summary of driver scaling information. After all design variables, objectives, and constraints are declared and the problem has been set up, this report presents all the design variables and constraints in all phases as well as the objectives. The file is divided to three blocks: `Design Variables`, `Constraints`, and `Objectives`. It contains the following columns: name, size, indices, driver value and units, model value and units, ref, ref0, scaler, adder, etc. It also shows `Jacobian Info` - responses with respect to design variables (`DV`). A screen shot of design variables is shown here:\n", + "\n", + "> ![Sample driver_scaling_report.html (top lines)](images/driver_scaling_report_top.PNG)\n", + "\n", + "This file is needed when you are debugging. New users can skip it." + ] + }, + { + "cell_type": "markdown", + "id": "7b66d5d3", + "metadata": {}, + "source": [ + "### File `inputs.html`\n", + "\n", + "File `inputs.html` is a sortable and filterable input report of input variables in different phases. It contains all the input variables (with possibly duplicate names for different phases) but only shows those in `Source is IVC` (abbreviation for [IndepVarComp](https://openmdao.org/newdocs/versions/latest/features/core_features/working_with_components/indepvarcomp.html)) on opening up. Users can choose to show other inputs by selecting and deselecting this checkbox. Users can filter their inputs by input name, source name, units, shape, tags, values (`Val`), or design variables (`Source is DV`). Here is a screen shot (top part) when it is opened:\n", + "\n", + "> ![Sample inputs.html (top lines)](images/inputs_html_top.PNG)\n", + "\n", + "New users can choose to use `input_list.txt` instead (see below)." + ] + }, + { + "cell_type": "markdown", + "id": "25a81fa7", + "metadata": {}, + "source": [ + "### File `n2.html`\n", + "\n", + "N2 is a powerful tool in OpenMDAO. It is an N-squared diagram in the shape of a matrix, representing functional or physical interfaces between system elements. It can be used to systematically identify, define, tabulate, design, and analyze functional and physical interfaces.\n", + "\n", + "```{note}\n", + "We *strongly* recommend that you understand N2 diagrams well, especially if you are debugging a model or adding external subsystems. Here is a [doc page](https://openmdao.github.io/PracticalMDO/Notebooks/ModelConstruction/using_n2.html) featuring an informative video on how to use N2 diagrams effectively.\n", + "```\n", + "\n", + " Here is a screenshot of an N2 diagram after we run `aviary run_mission models/test_aircraft/aircraft_for_bench_GwGm.csv`.\n", + "\n", + "> ![Sample n2.html (on start)](images/N2_start.PNG)\n", + "\n", + "At level 1, we are interested in the phases, so let us `Hide solvers`. So from `model`, zoom into `traj`, then into `phases`. We see the phases from `groundroll` to `desc2` as expected. To see how those phases are connected, we click on `Show all connections in view`. Here is what we see:\n", + "\n", + "> ![Sample n2.html (on phases)](images/N2_phases.PNG)\n", + "\n", + "The solid arrow connections show how outputs of one phase feed as inputs to the next. As you can see, the input of each phase is linked from the previous phase and its output is linked to the next phase. This is pretty much what we expect. The dashed arrows are links to and/or from other places not in the view. If you are curious where those links go, you must zoom out. This can be done by clicking the vertical bar on the left. Let us click it twice. Here is what we get:\n", + "\n", + "> ![Sample n2.html (on phases)](images/N2_phases_links.PNG)\n", + "\n", + "Note that `desc2` phase is linked back up to `static_analysis`. This means that at least one variable must be matched in the two places. There must be a nonlinear solver for this step. \n", + "\n", + "For `GASP` missions, there is a takeoff subsystem (including `taxi` phase) within `pre_mission`. For `FLOPS` missions, there is a takeoff subsystem within `pre_mission` in which a `takeoff` phase is added. It is added after `static_analysis` in `add_pre_mission_systems` method.\n", + "\n", + "Similarly, there is a `landing` phase within `post_mission`." + ] + }, + { + "cell_type": "markdown", + "id": "aacb7268", + "metadata": {}, + "source": [ + "### File `opt_report.html`\n", + "\n", + "This file is OpenMDAO Optimization Report. All values are in unscaled, physical units. On the top is a summary of the optimization, followed by the objective, design variables, constraints, and optimizer settings. Here is a screenshot:\n", + "\n", + "> ![Sample opt_report.html (top lines)](images/opt_report_top.PNG)\n", + "\n", + "This file is important when dissecting optimal results produced by Aviary." + ] + }, + { + "cell_type": "markdown", + "id": "0b9ccf6b", + "metadata": {}, + "source": [ + "### Coloring files\n", + "\n", + "There is a sub-folder `coloring_files`. Those are used internally by OpenMDAO for derivative computation. Users should generally skip those files." + ] + }, + { + "cell_type": "markdown", + "id": "4e04587c", + "metadata": {}, + "source": [ + "### File `traj_linkage_report.html`\n", + "\n", + "This is a dymos linkage report in a customized N2 diagram. It provides a report detailing how phases are linked together via constraint or connection. It can be used to identify errant linkages between fixed quantities.\n", + "\n", + "> ![Sample traj_linkage_report.html (top of timeseries)](images/traj_linkage_report_top.PNG)\n", + "\n", + "We clearly see how those mission phases are linked." + ] + }, + { + "cell_type": "markdown", + "id": "7cf04bea", + "metadata": {}, + "source": [ + "### File `traj_results_report.html`\n", + "\n", + "```{note}\n", + "This is one of the most important files produced by Aviary. It will help you visualize and understand the optimal trajectory produced by Aviary.\n", + "```\n", + "\n", + "This file contains timeseries and phase parameters in different tabs. For our `aircraft_for_bench_GwGm` run, they are: groundroll, rotation, ascent, accel, climb1, climb2, cruise, desc1, and desc2 parameters. On the timeseries tab, users can select which phases to view. The following are the top of timeseries tab and ascent parameters tab:\n", + "\n", + "> ![Sample traj_results_report.html (top part of timeseries)](images/traj_results_report_top.PNG)\n", + "\n", + "Let's find the altitude chart. Move the cursor to the top of climb2. We see that the aircraft climbs to 37910 feet at 2814 second. Then it enters to cruise phase. At 28290 second, it starts descent from 37660 feet.\n", + "\n", + "> ![Sample traj_results_report.html (altitude)](images/traj_results_report_altitude.PNG)\n", + "\n", + "Let's switch to `ascent` tab. We see the following:\n", + "\n", + "> ![Sample traj_results_report.html (top lines) of ascent](images/traj_results_report_top_ascent.PNG)\n", + "\n", + "This file is quite important. Users should play with it and try to grasp all possible features. For example, you can hover the mouse over the solution points to see solution value; you can save the interesting images; you can zoom into a particular region for details, etc." + ] + }, + { + "cell_type": "markdown", + "id": "0ef908f2", + "metadata": {}, + "source": [ + "### Optimizer output\n", + "\n", + "If `IPOPT` is the optimizer, `IPOPT.out` is generated. If `SLSQP` is the optimizer and `pyOptSparseDriver` is the driver, `SLSQP.out` is generated. Generally speaking, `IPOPT` and `SNOPT` converge Aviary optimization problems better than `SLSQP`, but `SLSQP` is bundled with Scipy by default, making it more widely available." + ] + }, + { + "cell_type": "markdown", + "id": "9da1571f", + "metadata": {}, + "source": [ + "### SQLite database file\n", + "\n", + "There is a `.db` file after run. By default, it is `aviary_history.db`. This is an SQLite database file. In level 2 and level 3, we will be able to choose a different name. Our run is recorded into this file. You generally shouldn't need to parse through this file on your own, but it is available if you're seeking additional problem information." + ] + }, + { + "cell_type": "markdown", + "id": "bc26df51", + "metadata": {}, + "source": [ + "### Plain text inputs and outputs\n", + "\n", + "If `debug_mode` is set to `True`, `input_list.txt` and `output_list.txt` are generated. We recommend this parameter be set to `True` for beginners. \n", + "\n", + "Let us look at `input_list.txt`:\n", + "\n", + "> ![Sample input_list.txt (top lines)](images/input_list_top.PNG)\n", + "\n", + "In this screenshot, we see a tree structure. There are three columns. The left column is a list of variable names. The middle column is the value and the right column is the [promoted](https://openmdao.org/newdocs/versions/latest/basic_user_guide/multidisciplinary_optimization/linking_vars.html) variable name. `pre_mission` is a phase, `static_analysis` is a subgroup which contains other subcomponents (e.g. `propulsion_group`). `engine` is a component under which is a list of input variables (e.g. `aircraft:engine:scaled_sls_thrust`).\n", + "\n", + "An input variable can appear under different phases and within different components. Note that its values can be different because its value has been updated during the computation. On the top-left corner is the total number of inputs. That number counts the duplicates because one variable can appear in different phases. Aviary variable structure are discussed in [Understanding the Variable Hierarchy](https://github.com/OpenMDAO/Aviary/blob/main/aviary/docs/user_guide/variable_hierarchy.ipynb) and [Understanding the Variable Metadata](https://github.com/OpenMDAO/Aviary/blob/main/aviary/docs/user_guide/variable_metadata.ipynb).\n", + "\n", + "If you zoom the N2 diagram into `propulsion_group` and `gasp_based_geom`, you see the exact same tree structure:\n", + "\n", + "> ![Sample N2 Diagram (top blocks)](images/N2_top.PNG)\n", + "\n", + "File `output_list.txt` follows the same pattern. But there is another tree for implicit outputs. That helps when debugging is needed." + ] + }, + { + "cell_type": "markdown", + "id": "4dbd3cd1", + "metadata": {}, + "source": [ + "### Additional messages\n", + "\n", + "When Aviary is run, some messages are printed on the command line and they are important. For example, the following constraint report tells us whether our desired constraints are met:\n", + "\n", + "```\n", + "--- Constraint Report [traj] ---\n", + " --- groundroll ---\n", + " None\n", + " --- rotation ---\n", + " [final] 0.0000e+00 == normal_force [lbf]\n", + " --- ascent ---\n", + " [final] 5.0000e+02 == altitude [ft]\n", + " [path] 0.0000e+00 <= load_factor <= 1.1000e+00 [unitless]\n", + " [path] 0.0000e+00 <= fuselage_pitch <= 1.5000e+01 [deg]\n", + " --- accel ---\n", + " [final] 2.5000e+02 == EAS [kn]\n", + " --- climb1 ---\n", + " [final] 1.0000e+04 == altitude [ft]\n", + " --- climb2 ---\n", + " [final] 3.7500e+04 == altitude [ft]\n", + " [final] 1.0000e-01 <= altitude_rate [ft/min]\n", + " [final] 8.0000e-01 == mach [unitless]\n", + " --- cruise ---\n", + " None\n", + " --- desc1 ---\n", + " [final] 1.0000e+04 == altitude [ft]\n", + " --- desc2 ---\n", + " [final] 1.0000e+03 == altitude [ft]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "15e1f0b4", + "metadata": {}, + "source": [ + "## Beyond level 1\n", + "\n", + "Aviary Level 1 is quite capable yet limited in how much is exposed to the user. If you need additional flexibility or want to add your own subsystems, you will need to move to Levels 2 or 3. Let us briefly discuss some of the possible reasons for you to move to Levels 2 or 3.\n", + "\n", + "If you examine the Aviary metadata, you find that Aviary has two choices of objectives: `Mission.Objectives.FUEL` and `Mission.Objectives.RANGE`. But in level 1, you are limited to minimizing fuel. Users will be able to make other choices in level 2 and level 3.\n", + "\n", + "Level 1 uses the default `phase_info` dictionaries, though there is an option to use a customized `phase_info`.\n", + "For more details, please read [drawing and running simple missions](../user_guide/drawing_and_running_simple_missions).\n", + "\n", + "There may be more or fewer key-value pairs in each of the phases. For example, if you have an external subsystem, say, a battery with `BatteryBuilder()`, you can add a key `external_subsystems` with value `BatteryBuilder()`. We will go into details later.\n", + "\n", + "No matter what mission method users choose, they can create their own phase sequences and run Aviary using either level 2 or 3 interface.\n", + "\n", + "In the `aviary/interface/default_phase_info` subdirectory, you see another `phase_info` file `solved.py`. It defines the `phase_info` object for the \"solved\" mission method which is not explained in level 1. The “solved” mission method is a more simplified and robust method than the other methods. In just a few words, it's a way of implementing a trajectory where the aircraft only flies in straight lines in the altitude-range space and usually at constant velocity. The idea is to simplify the design space by reducing the flexibility the optimizer has to choose a trajectory profile. It still uses a collocation method to solve the mission dynamics, but the complexity of the design problem is lessened.\n", + "\n", + "We are ready to move on to [Level 2](onboarding_level2.ipynb)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/getting_started/onboarding_level2.ipynb b/_sources/getting_started/onboarding_level2.ipynb new file mode 100644 index 000000000..0d47cdf7f --- /dev/null +++ b/_sources/getting_started/onboarding_level2.ipynb @@ -0,0 +1,936 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "04133934", + "metadata": {}, + "source": [ + "# Level 2\n", + "\n", + "We have discussed [Level 1](onboarding_level1.ipynb) in great detail. As we have seen, Level 1 is relatively simple.\n", + "\n", + "In Level 2, we see more flexibility and additional choices. You will be exposed to some simple Python code and see how Aviary establishes a problem from beginning to end. Each step is built upon the capabilities of [Level 3](onboarding_level3). Users will be led to Level 3 in a natural way.\n", + "\n", + "Level 2 is defined in the [aviary/interface/methods_for_level1.py file](https://github.com/OpenMDAO/Aviary/blob/main/aviary/interface/methods_for_level1.py) and it has a single method `run_aviary()` with a few arguments. If you examine `interface/level1.py` you see that Level 1 prepares those arguments and then call `run_aviary()`. For `aviary run_mission aircraft_for_bench_GwGm` examples, those arguments are:\n", + "\n", + "- `aircraft_filename`: `aircraft_for_bench_GwGm`\n", + "- `phase_info`: `phase_info` (loaded from `aviary/interface/default_phase_info/gasp.py`)\n", + "- `optimizer`: `IPOPT` (the default is `None`)\n", + "- `analysis_scheme`: `AnalysisScheme.COLLOCATION` (the default)\n", + "- `objective_type`: `None` (default)\n", + "- `record_filename`: `aviary_history.db` (the default)\n", + "- `restart_filename`: `None` (the default)\n", + "- `max_iter`: 50 (the default)\n", + "\n", + "All the above arguments are straightforward except `objective_type`. Even though `objective_type` is `None`, it is not treated as `None`. In this scenario, the objective is set based on `problem_type` when using the GASP-based mission method, but not the FLOPS-based mission. There are three options for `problem_type`. Aviary has the following mapping when `objective_type` is not set by user and `mission_method` is `GASP`:\n", + "\n", + "| problem_type | objective |\n", + "| ------------ | --------- |\n", + "| `SIZING` | Mission.Objectives.FUEL |\n", + "| `ALTERNATE` | Mission.Objectives.FUEL |\n", + "| `FALLOUT` | Mission.Objectives.RANGE |\n", + "\n", + "In Aviary, `problem_type` is set to `SIZING` when it creates a vehicle (see [create_vehicle](https://github.com/OpenMDAO/Aviary/blob/main/aviary/utils/UI.py)). As you can see, since `problem_type` is `SIZING` by default in our case and we don't manually alter this setting, Aviary set objective to `Mission.Objectives.FUEL`. We will discuss more options of `objective_type` later on.\n", + "\n", + "In our onboarding runs, we want to limit the number of iterations to 1 so that they all run faster. As a result, we will not consider whether the optimization converges. So, we will have\n", + "\n", + "```\n", + "`max_iter`: 1\n", + "```\n", + "\n", + "Level 2 cannot be run via `aviary` command on the command line. Users must develop level 2 Python code. The good news is that the Python code is pretty small. You can follow the following steps in order (we do not include function arguments for simplicity):\n", + "\n", + "- `prob = AviaryProblem()`\n", + "- `prob.load_inputs()`\n", + "- `prob.check_and_preprocess_inputs()`\n", + "- `prob.add_pre_mission_systems()`\n", + "- `prob.add_phases()`\n", + "- `prob.add_post_mission_systems()`\n", + "- `prob.link_phases()`\n", + "- `prob.add_driver()`\n", + "- `prob.add_design_variables()`\n", + "- `prob.add_objective()`\n", + "- `prob.setup()`\n", + "- `prob.set_initial_guesses()`\n", + "- `prob.run_aviary_problem()`\n", + "\n", + "In the rest of this page, we will show a few examples to demonstrate how level 2 runs these steps. We start from rebuilding `aircraft_for_bench_GwGm` model in great details." + ] + }, + { + "cell_type": "markdown", + "id": "a1b573a9", + "metadata": {}, + "source": [ + "## Build level 2 for the same `aircraft_for_bench_GwGm` Model\n", + "\n", + "We create a level 2 Python script to reproduce the `aircraft_for_bench_GwGm` model run that was used as an example in the level 1 document (this time we won’t use the level 1 functionality). The methods listed above are defined in level 3 (namely, [interface/methods_for_level2.py](https://github.com/OpenMDAO/Aviary/blob/main/aviary/interface/methods_for_level2.py)). You can run the code as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe134855", + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.api import Aircraft, Mission\n", + "import aviary.api as av\n", + "\n", + "\n", + "# inputs that run_aviary() requires\n", + "aircraft_filename = \"models/test_aircraft/aircraft_for_bench_GwGm.csv\"\n", + "optimizer = \"IPOPT\"\n", + "analysis_scheme = av.AnalysisScheme.COLLOCATION\n", + "objective_type = None\n", + "record_filename = 'aviary_history.db'\n", + "restart_filename = None\n", + "max_iter = 0\n", + "\n", + "# Build problem\n", + "prob = av.AviaryProblem(analysis_scheme)\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs(aircraft_filename, av.default_2DOF_phase_info)\n", + "\n", + "# Preprocess inputs\n", + "prob.check_and_preprocess_inputs()\n", + "\n", + "# adds a pre-mission group (propulsion, geometry, static aerodynamics, and mass)\n", + "prob.add_pre_mission_systems()\n", + "\n", + "# adds a sequence of core mission phases.\n", + "prob.add_phases()\n", + "\n", + "# adds a landing phase\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "# adds an optimizer to the driver\n", + "prob.add_driver(optimizer, max_iter=max_iter)\n", + "\n", + "# adds relevant design variables\n", + "prob.add_design_variables()\n", + "\n", + "# Load optimization problem formulation\n", + "# Detail which variables the optimizer can control\n", + "prob.add_objective(objective_type=objective_type)\n", + "\n", + "# setup the problem\n", + "prob.setup()\n", + "\n", + "# set initial guesses of states and controls variables\n", + "prob.set_initial_guesses()\n", + "\n", + "# run the problem we just set up\n", + "prob.run_aviary_problem(record_filename, restart_filename=restart_filename)" + ] + }, + { + "cell_type": "markdown", + "id": "96066213", + "metadata": {}, + "source": [ + "In this code, you do the same import as `methods_for_level1.py` does and set the values of all the arguments in `run_aviary()`. Now we will go through each line in detail to explain each step:\n", + "\n", + "## Dissection of level 2 for the same `aircraft_for_bench_GwGm` model\n", + "\n", + "All the methods of `prob` object (including its creation) are defined in level 3 (`methods_for_level2.py`). We now look at each of them.\n", + "\n", + "We add other inputs that `run_aviary()` requires:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0baac27", + "metadata": {}, + "outputs": [], + "source": [ + "aircraft_filename = \"models/test_aircraft/aircraft_for_bench_GwGm.csv\"\n", + "optimizer = \"IPOPT\"\n", + "analysis_scheme = av.AnalysisScheme.COLLOCATION\n", + "objective_type = None\n", + "record_filename = 'aviary_history.db'\n", + "restart_filename = None\n", + "max_iter = 1\n", + "\n", + "prob = av.AviaryProblem(analysis_scheme)" + ] + }, + { + "cell_type": "markdown", + "id": "7e1d5726", + "metadata": {}, + "source": [ + "Several objects are initialized in this step:\n", + "\n", + "```\n", + "self.model = om.Group()\n", + "self.pre_mission = PreMissionGroup()\n", + "self.post_mission = PostMissionGroup()\n", + "self.aviary_inputs = None\n", + "self.phase_info = phase_info\n", + "self.traj = None\n", + "self.analysis_scheme = analysis_scheme\n", + "self.pre_mission_info = self.phase_info.pop('pre_mission')\n", + "self.post_mission_info = self.phase_info.pop('post_mission')\n", + "```\n", + "\n", + "`phase_info` is a user defined dictionary (in a Python file) that controls the profile of the mission to be simulated (e.g. climb, cruise, descent segments etc).\n", + "\n", + "For `analysis_scheme`, the two options are: `AnalysisScheme.COLLOCATION` (default) and `AnalysisScheme.SHOOTING` which are defined and described in [variables_info/enums.py`](https://github.com/OpenMDAO/Aviary/blob/main/aviary/variable_info/enums.py):\n", + "- COLLOCATION uses the collocation method to optimize all points simultaneously.\n", + "- SHOOTING is a forward in time integration method that simulates the trajectory.\n", + "\n", + "In this onboarding document, only the `COLLOCATION` scheme will be discussed. The line" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8cac423c", + "metadata": {}, + "outputs": [], + "source": [ + "prob.load_inputs(aircraft_filename, av.default_2DOF_phase_info)" + ] + }, + { + "cell_type": "markdown", + "id": "42a2ee97", + "metadata": {}, + "source": [ + "is a function that has a few tasks:\n", + "\n", + "- read aircraft deck file `aircraft_filename`\n", + "- read phase info file `phase_info`\n", + "- build core subsystems, including setting up engines\n", + "\n", + "We have seen `aircraft_filename` file (a `.csv` file) in our level 1 examples. In [level 1](onboarding_level1), we simply called it input file. Engine is built by using `aircraft:engine:data_file` in the .csv file. For example in `aircraft_for_bench_GwGm.csv` file, we see:\n", + "\n", + "```\n", + "aircraft:engine:data_file,models/engines/turbofan_28k.deck,unitless\n", + "```\n", + "\n", + "So, `aircraft:engine:data_file` has value `models/engines/turbofan_28k.deck,unitless`. The top rows of engine deck file are:\n", + "\n", + "| **Mach_Number (unitless)** | **Altitude (ft)** | **Throttle (unitless)** | **Gross_Thrust (lbf)** | **Ram_Drag (lbf)** | **Fuel_Flow (lb/h)** | **NOx_Rate (lb/h)** |\n", + "| ---------------------- | -------------- | -------------------- | ------------------- | --------------- | --- | --- |\n", + "| 0.0, | 0.0, | 50.0, | 28928.1, | 0.0, | 8662.3, | 61.9894 |\n", + "| 0.0, | 0.0, | 48.0, | 26999.7, | 0.0, | 7932.6, | 49.2185 |\n", + "| 0.0, | 0.0, | 46.0, | 25071.1, | 0.0, | 7258.1, | 33.3976 |\n", + "| 0.0, | 0.0, | 42.0, | 21214.0, | 0.0, | 5979.1, | 19.8547 |\n", + "| 0.0, | 0.0, | 38.0, | 17356.9, | 0.0, | 4795.2, | 17.5877 |\n", + "\n", + "The engine builder allows users to provide an `EngineModel` instance of their own to use in Aviary's propulsion systems.\n", + "\n", + "Other subsystems, including mass, geometry, and aerodynamics, are set up according to which legacy code options the user has specified in their input file, using `settings:equations_of_motion` and `settings:mass_method`. Aerodynamics is set up to match the selected equations of motion, while geometry will use either GASP, FLOPS, or both methods as required to calculate all values needed by other subsystems.\n", + "\n", + "Next we check the user-provided inputs:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3d91612", + "metadata": {}, + "outputs": [], + "source": [ + "prob.check_and_preprocess_inputs()" + ] + }, + { + "cell_type": "markdown", + "id": "7f312145", + "metadata": {}, + "source": [ + "This method checks the user-supplied input values for any potential problems. These problems include variable names that are not recognized in Aviary, conflicting options or values, or units mismatching.\n", + "\n", + "Next, we add pre-mission systems:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00de09c8", + "metadata": {}, + "outputs": [], + "source": [ + "prob.add_pre_mission_systems()" + ] + }, + { + "cell_type": "markdown", + "id": "12d71c79", + "metadata": {}, + "source": [ + "This call adds a pre-mission group (also called static analysis group) which includes pre-mission propulsion, geometry, pre-mission aerodynamics, and mass subsystems. \n", + "\n", + "For `height_energy` missions, aviary currently models FLOPS' \"simplified\" takeoff as defined in [mission/flops_based/phases/simplified_takeoff.py](https://github.com/OpenMDAO/Aviary/blob/main/aviary/mission/flops_based/phases/simplified_takeoff.py).\n", + "\n", + "Next is the line" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b17b6637", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [], + "source": [ + "prob.add_phases()" + ] + }, + { + "cell_type": "markdown", + "id": "f9f50477", + "metadata": {}, + "source": [ + "which adds a sequence of core mission phases. In addition, if `mission_method` is `2dof` and `ascent` is a phase, it adds an equality constraint to the problem to ensure that the TAS at the end of the groundroll phase is equal to the rotation velocity at the start of the rotation phase (`_add_groundroll_eq_constraint(phase)`). If `mission_method` is `height_energy`, it sets up trajectory parameters by calling `setup_trajectory_params()`. If `mission_method` is `solved`, it has a block of code to make sure that the trajectory is smooth by applying boundary constraints between phases (e.g. fuselage pitch angle or true airspeed).\n", + "\n", + "It follows by adding post-mission subsystems:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af5ba774", + "metadata": {}, + "outputs": [], + "source": [ + "prob.add_post_mission_systems()" + ] + }, + { + "cell_type": "markdown", + "id": "0c8038df", + "metadata": {}, + "source": [ + "Similar to pre-mission, it adds a landing phase if `include_landing` key of `post_mission` has value of `True`. If user chooses to define a `post_mission`, it will override the default. For `2dof` missions, landing is defined in [mission/gasp_based/phases/landing_group.py](https://github.com/OpenMDAO/Aviary/blob/main/aviary/mission/gasp_based/phases/landing_group.py). For `height_energy` mission, landing means a [simplified landing](https://github.com/OpenMDAO/Aviary/blob/main/aviary/mission/flops_based/phases/simplified_landing.py). Note that the `solved` method currently doesn't have any post mission systems.\n", + "\n", + "The next line is" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f765815b", + "metadata": {}, + "outputs": [], + "source": [ + "prob.link_phases()" + ] + }, + { + "cell_type": "markdown", + "id": "0f5006a5", + "metadata": {}, + "source": [ + "This is important for allowing each phase of flight to pass to the next without discontinuities in the parameters. Consider Dymos' [Aircraft Balanced Field Length Calculation](https://openmdao.github.io/dymos/examples/balanced_field/balanced_field.html) example. In that example, we see separate nonlinear boundary constraints, nonlinear path constraints, and phase continuity constraints between phases. We don't want to go deeper in this function call, but just point out that each individual link can be set via dymos function `link_phases`. See [dymos API](https://openmdao.github.io/dymos/api/trajectory_api.html) for more details.\n", + "\n", + "The code blocks in this function (namely, `link_phases()`) are for `2DOF`, `height_energy`, and `solved` missions. The links are set up based on physical principals (e.g. you can’t have instantaneous changes in mass, velocity, position etc.). Special care is required if the user selects a different or unusual set of phases. \n", + "\n", + "Now, our aircraft and the mission are fully defined. We are ready to define an optimization problem. This is achieved by adding an optimization driver, adding design variables, and an objective. \n", + "\n", + "For `add_driver` function, we accept `use_coloring=None`. Coloring is a technique that OpenMDAO uses to compute partial derivatives efficiently. This will become important later." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87e863bc", + "metadata": {}, + "outputs": [], + "source": [ + "prob.add_driver(optimizer, max_iter=max_iter)" + ] + }, + { + "cell_type": "markdown", + "id": "1cd6d86a", + "metadata": {}, + "source": [ + "Drivers available for use in Aviary are `SLSQP`, `SNOPT`, and `IPOPT`. The table below summarizes the basic setting along with sample values (the settings are options required by each optimizer):\n", + "\n", + "| **Optimizers** | **Drivers** | **Settings** |\n", + "| ---------- | ------- | -------- |\n", + "| `SNOPT` | om.pyOptSparseDriver() | `Major iterations limit`: 50
`Major optimality tolerance`: 1e-4
`Major feasibility tolerance`: 1e-6
`iSumm`: 6 |\n", + "| `IPOPT` | om.pyOptSparseDriver() | `tol`: 1e-9
`mu_init`: 1e-5
`max_iter`: 50
`print_level`: 5 |\n", + "| `SLSQP` | om.ScipyOptimizeDriver() | `tol`: 1.0E-9
`maxiter`: 50
`disp`: True |\n", + "\n", + "Note that `SLSQP` is freely available, but its performance is not as good as `SNOPT` and `IPOPT` sometimes. `SNOPT` is a commercial optimizer, but it is free for academic use. `IPOPT` is an open-source optimizer and it is free for all users.\n", + "\n", + "Design variables (and constraints) are set in the line `prob.add_design_variables()`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a408e2e", + "metadata": {}, + "outputs": [], + "source": [ + "prob.add_design_variables()" + ] + }, + { + "cell_type": "markdown", + "id": "5dfe75ac", + "metadata": {}, + "source": [ + "For default `FLOPS` mission model, it is relatively simple:\n", + "\n", + "| **Design Variables** | **Lower Bound** | **Upper Bound** | **Reference Value** | **Units** |\n", + "| ----------- | ----------- | ----------- | --------------- | ----- |\n", + "| Mission.Design.GROSS_MASS | 100.e3 | 200.e3 | 135.e3 | lbm |\n", + "\n", + "For default `GASP` mission model, the design variables and constraints depend on the type of problems (`SIZING`, `ALTERNATE`, or `FALLOUT`, see `ProblemType` class in `aviary/variable_info/enums.py` for details). First, there are four common design variables and two common constraints. There are two more design variables and two constraints for sizing problem.\n", + "\n", + "| **Problem Type** | **Design Variables** | **Lower Bound** | **Upper Bound** | **Reference** Value | Units |\n", + "| ----------- | ----------- | ----------- | ----------- | --------------- | ----- |\n", + "| Any | Mission.Takeoff.ASCENT_T_INITIAL | 0 | 100 | 30.0 | s |\n", + "| Any | Mission.Takeoff.ASCENT_DURATION | 1 | 1000 | 10.0 | s |\n", + "| Any | tau_gear | 0.01 | 1.0 | 1 | s |\n", + "| Any | tau_flaps | 0.01 | 1.0 | 1 | s |\n", + "| SIZING | Mission.Design.GROSS_MASS | 10. | 400.e3 | 175_000 | lbm |\n", + "| SIZING | Mission.Summary.GROSS_MASS | 10. | 400.e3 | 175_000 | lbm |\n", + "| ALTERNATE | Mission.Summary.GROSS_MASS | 0 | infinite | 175_000 | lbm |\n", + "| **Problem Type** | **Constraint** | **Relation** | **Value** | **Reference Value** | **Units** |\n", + "| Any | h_fit.h_init_gear | = | 50.0 | 50.0 | ft |\n", + "| Any | h_fit.h_init_flaps | = | 400.0 | 400.0 | ft |\n", + "| SIZING | Mission.Constraints.RANGE_RESIDUAL | = | 0 | 10 | unitless |\n", + "| ALTERNATE | Mission.Constraints.RANGE_RESIDUAL | = | 0 | 10 | lbm |\n", + "\n", + "In the above table, there are two hard-coded design variables: `tau_gear` and `tau_flaps`. They represent fractions of ascent time to start gear retraction and flaps retraction. There are two hard-coded constraints: `h_fit.h_init_gear` and `h_fit.h_init_flaps`. They are the altitudes of initial gear retraction and initial flaps retraction. The underscore in number \"175_000\" is for readability only. \n", + "\n", + "There are other constraints using OpenMDAO's `EQConstraintComp` component. We will not go into the details as this part is complicated and needs special attention. Note that each subsystem (for example engine model) might have their own design variables (think, for example, sizing the engine). Aviary goes through all subsystems and adds appropriate design variables.\n", + "\n", + "You can override all the functions in level 3. So, you can set up your constraints in level 3 if the above ones do not meet your requirements.\n", + "\n", + "The optimization objective is added to the problem by this line:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46eee283", + "metadata": {}, + "outputs": [], + "source": [ + "prob.add_objective(objective_type=objective_type)" + ] + }, + { + "cell_type": "markdown", + "id": "f7a233ac", + "metadata": {}, + "source": [ + "The selection of objective is a little complicated. \n", + "\n", + "Earlier in this page, we have discussed the objective when `objective_type=None` and `mission_method` is `2DOF`. Let us discuss the other situations.\n", + "\n", + "There are several objective types that users can choose: `mass`, `hybrid_objective`, `fuel_burned`, and `fuel`. \n", + "\n", + "| objective_type | objective |\n", + "| -------------- | --------- |\n", + "| mass | `Dynamic.Mission.MASS` |\n", + "| hybrid_objective | `-final_mass / {takeoff_mass} + final_time / 5.` |\n", + "| fuel_burned | `initial_mass - mass_final` (for `FLOPS` mission only)|\n", + "| fuel | `Mission.Objectives.FUEL` |\n", + "\n", + "As listed in the above, if `objective_type=\"mass\"`, the objective is the final value of `Dynamic.Mission.MASS` at the end of the mission.\n", + "If `objective_type=\"fuel\"`, the objective is the `Mission.Objectives.FUEL`.\n", + "There is a special objective type: `hybrid_objective`. When `objective_type=\"hybrid_objective\"`, the objective is a mix of minimizing fuel burn and minimizing the mission duration:\n", + "\n", + "```\n", + " obj = -final_mass / {takeoff_mass} + final_time / 5.\n", + "```\n", + "This is because if we just minimized fuel burn then the optimizer would probably fly the plane slowly to save fuel, but we actually care about some mix of minimizing fuel burn while providing a reasonable travel time for the passengers. This leads to the `hybrid_objective` which seeks to minimize a combination of those two objectives. `final_time` is the duration of the full mission and is usually in the range of hours. So, the denominator `5.` means `5 hours`. That's just a value to scale the final_time variable. Since it's a composite objective we didn't want to have OpenMDAO do the scaling because the two variables in the objective are of a different order of magnitude. We will show an example of this objective type in level 2 discussion.\n", + "\n", + "If `objective_type=None` for a `2DOF` mission, Aviary will choose the objective based on `mission_method` and `problem_type`. We have discussed this case earlier in this page.\n", + "\n", + "If `objective_type=None` for a `FLOPS` mission method, Aviary adds a `fuel_burned` objective. In fact, this objective is available for `FLOPS` mission only. That number you get is for the actual fuel burned in lbm. You may get something like `fuel_burned` with the scaled value `[3.91228276]`, reference value `1e+04`. It translates to the dimensional physical quantity of `39,122.8276` lbm. To see this in action, check the resulting `reports/opt_report.html` file to see the optimal results.\n", + "\n", + "**Note:** Aviary variable `Mission.Objectives.FUEL` when using the GASP-based mission is actually a hybrid objective defined as\n", + "\n", + "```\n", + " reg_objective = overall_fuel/10000 + ascent_duration/30.\n", + "```\n", + "where `overall_fuel` has the unit of `lbm` and `ascent_duration` has the unit of seconds. In our case, `settings:equations_of_motion = 2DOF`, the final value of objective is `[5.5910123]`, with `ref: 1.0` and `units: blank`. The units should be interpreted as `unitless`.\n", + "\n", + "Here, `ref` is the reference value. For different objectives, the range may vary significantly different. We want to normalize the value. Ideally, users should choose `ref` such that the objective is in the range of `(0,1)`. This is required by optimizer.\n", + "\n", + "**Note:** Unfortunately, not all `objective_type` and `mission_method` combinations work.\n", + "\n", + "Next is a line to call" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dbfca715", + "metadata": {}, + "outputs": [], + "source": [ + "prob.setup()" + ] + }, + { + "cell_type": "markdown", + "id": "40b9cfea", + "metadata": {}, + "source": [ + "This is a lightly wrapped OpenMDAO `setup()` method for the problem. It allows us to do `pre-` and `post-setup` changes, like adding calls to `set_input_defaults` and do some simple `set_vals` if needed. \n", + "\n", + "If we look at the signature of `setup()` in OpenMDAO's [Problem](https://openmdao.org/newdocs/versions/latest/_srcdocs/packages/core/problem.html) class, we find that the available kwargs are: `check`, `logger`, `mode`, `force_alloc_complex`, `distributed_vector_class`, `local_vector_class`, and `derivatives`. The ones that Aviary uses are `check` and `force_alloc_complex`. Argument `check` is a flag to determine default checks are performed. [Default checks](https://openmdao.org/newdocs/versions/latest/theory_manual/setup_stack.html) are: 'auto_ivc_warnings', comp_has_no_outputs', 'dup_inputs', 'missing_recorders', 'out_of_order', 'solvers', 'system', 'unserializable_options'.\n", + "\n", + "If [force_alloc_complex](https://openmdao.org/newdocs/versions/latest/advanced_user_guide/complex_step.html) is true, sufficient memory will be allocated to allow nonlinear vectors to store complex values while operating under complex step. For our example, we don't use any of them.\n", + "\n", + "For optimization problems, initial guesses are important." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "afdf6203", + "metadata": {}, + "outputs": [], + "source": [ + "prob.set_initial_guesses()" + ] + }, + { + "cell_type": "markdown", + "id": "57986647", + "metadata": {}, + "source": [ + "For `height_energy` and `2DOF` missions, this method performs several calls to `set_val` on the trajectory for states and controls to seed the problem with reasonable initial guesses using `initial_guesses` within corresponding phases (e.g. `default_flops_phases.py` and `default_gasp_phases.py`). For `solved` missions, it performs similar tasks but for hard-coded state parameters. This is reasonable because a `solved` mission is actually a level 3 Aviary approach. We will cover it in [level 3 onboarding doc](onboarding_level3.ipynb) in the next page. Note that initial guesses for all phases are especially important for collocation methods.\n", + "\n", + "The last line is to run the problem we just set up:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f1a2b82", + "metadata": {}, + "outputs": [], + "source": [ + "prob.run_aviary_problem()" + ] + }, + { + "cell_type": "markdown", + "id": "107f7407", + "metadata": {}, + "source": [ + "This is a simple wrapper of Dymos' [run_problem()](https://openmdao.github.io/dymos/api/run_problem_function.html) function. It allows the users to provide `record_filename`, `restart_filename`, `suppress_solver_print`, and `run_driver`. In our case, `record_filename` is changed to `aviary_history.db` and `restart_filename` is set to `None`. The rest of the arguments take default values. If a restart file name is provided, aviary (or dymos) will load the states, controls, and parameters as given in the provided case as the initial guess for the next run. We have discussed the `.db` file in [level 1 onboarding doc](onboarding_level1.ipynb) and will discuss how to use it to generate useful output in [level 3 onboarding doc](onboarding_level3.ipynb).\n", + "\n", + "Finally, we can add a few print statements for the variables that we are interested:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb152e48", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Zero Fuel Mass (lbm)\",\n", + " prob.get_val(Aircraft.Design.ZERO_FUEL_MASS, units='lbm'))\n", + "print(\"Mission.Objectives.FUEL\",\n", + " prob.get_val(Mission.Objectives.FUEL, units='unitless'))\n", + "print(\"Mission.Design.FUEL_MASS\",\n", + " prob.get_val(Mission.Design.FUEL_MASS, units='lbm'))\n", + "print(\"Mission.Design.FUEL_MASS_REQUIRED\",\n", + " prob.get_val(Mission.Design.FUEL_MASS_REQUIRED, units='lbm'))\n", + "print(\"Mission.Summary.TOTAL_FUEL_MASS\",\n", + " prob.get_val(Mission.Summary.TOTAL_FUEL_MASS, units='lbm'))\n", + "print(\"Mission.Summary.GROSS_MASS (takeoff_mass)\",\n", + " prob.get_val(Mission.Summary.GROSS_MASS, units='lbm'))\n", + "print(\"Mission.Landing.TOUCHDOWN_MASS (final_mass)\",\n", + " prob.get_val(Mission.Landing.TOUCHDOWN_MASS, units='lbm'))\n", + "print()\n", + "\n", + "print(\"Groundroll Final Mass (lbm)\",\n", + " prob.get_val('traj.phases.groundroll.states:mass', units='lbm')[-1])\n", + "print(\"Rotation Final Mass (lbm)\",\n", + " prob.get_val('traj.rotation.states:mass', units='lbm')[-1])\n", + "print(\"Ascent Final Mass (lbm)\",\n", + " prob.get_val('traj.ascent.states:mass', units='lbm')[-1])\n", + "print(\"Accel Final Mass (lbm)\",\n", + " prob.get_val('traj.accel.states:mass', units='lbm')[-1])\n", + "print(\"Climb1 Final Mass (lbm)\",\n", + " prob.get_val('traj.climb1.states:mass', units='lbm')[-1])\n", + "print(\"Climb2 Final Mass (lbm)\",\n", + " prob.get_val('traj.climb2.states:mass', units='lbm')[-1])\n", + "print(\"Cruise Final Mass (lbm)\",\n", + " prob.get_val('traj.phases.cruise.rhs.calc_weight.mass', units='lbm')[-1])\n", + "print(\"Desc1 Final Mass (lbm)\",\n", + " prob.get_val('traj.desc1.states:mass', units='lbm')[-1])\n", + "print(\"Desc2 Final Mass (lbm)\",\n", + " prob.get_val('traj.desc2.states:mass', units='lbm')[-1])\n", + "print('done')" + ] + }, + { + "cell_type": "markdown", + "id": "3fece473", + "metadata": {}, + "source": [ + "We will cover user customized outputs in [level 3](onboarding_level3.ipynb)." + ] + }, + { + "cell_type": "markdown", + "id": "7bc55bf2", + "metadata": {}, + "source": [ + "## Level 2: Another example\n", + "\n", + "We now use a similar aircraft, a large single aisle commercial transport aircraft, but with a different mass estimation and mission method. Let us run Aviary using this input deck in level 1 first." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0da2bfee", + "metadata": {}, + "outputs": [], + "source": [ + "!aviary run_mission models/test_aircraft/aircraft_for_bench_FwFm.csv --max_iter 0 --optimizer IPOPT" + ] + }, + { + "cell_type": "markdown", + "id": "bf021f13", + "metadata": {}, + "source": [ + "Once again, to convert it to a level 2 model, we need to set all the arguments in level 1 manually.\n", + "\n", + "By running a model in level 2 directly, we have the flexibility to modify the input parameters (e.g. `phase_info`). Let us continue to make modifications and obtain a different run script shown below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "807902e2", + "metadata": {}, + "outputs": [], + "source": [ + "phase_info = {\n", + " 'pre_mission': {\n", + " 'include_takeoff': False,\n", + " 'optimize_mass': False,\n", + " },\n", + " 'cruise': {\n", + " 'subsystem_options': {\n", + " 'core_aerodynamics': {'method': 'computed'}\n", + " },\n", + " 'user_options': {\n", + " 'fix_initial': False,\n", + " 'fix_duration': True,\n", + " 'num_segments': 1,\n", + " 'order': 3,\n", + " 'initial_bounds': ((500., 4000.), 's'),\n", + " 'initial_ref': (1., 's'),\n", + " 'duration_ref': (24370.8, 's'),\n", + " 'duration_bounds': ((726., 48741.6), 's'),\n", + " 'min_altitude': (10.668e3, 'm'),\n", + " 'max_altitude': (10.668e3, 'm'),\n", + " 'min_mach': 0.79,\n", + " 'max_mach': 0.79,\n", + " 'fix_final': False,\n", + " 'required_available_climb_rate': (1.524, 'm/s'),\n", + " 'mass_f_cruise': (1.e4, 'lbm'),\n", + " 'range_f_cruise': (1.e6, 'm'),\n", + " },\n", + " 'initial_guesses': {\n", + " 'times': ([26.2, 406.18], 'min'),\n", + " 'altitude': ([35.e3, 35.e3], 'ft'),\n", + " 'velocity': ([455.49, 455.49], 'kn'),\n", + " 'mass': ([165.e3, 140.e3], 'lbm'),\n", + " 'range': ([160.3, 3243.9], 'nmi'),\n", + " 'velocity_rate': ([0., 0.], 'm/s**2'),\n", + " 'throttle': ([0.95, 0.9], 'unitless'),\n", + " }\n", + " },\n", + " 'post_mission': {\n", + " 'include_landing': False,\n", + " },\n", + "}\n", + "\n", + "# inputs that run_aviary() requires\n", + "aircraft_filename = \"models/test_aircraft/aircraft_for_bench_FwFm.csv\"\n", + "mission_method = \"FLOPS\"\n", + "mass_method = \"FLOPS\"\n", + "optimizer = \"SLSQP\"\n", + "analysis_scheme = av.AnalysisScheme.COLLOCATION\n", + "objective_type = None\n", + "record_filename = 'history.db'\n", + "restart_filename = None\n", + "\n", + "# Build problem\n", + "prob = av.AviaryProblem(analysis_scheme)\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs(aircraft_filename, phase_info)\n", + "\n", + "# Preprocess inputs\n", + "prob.check_and_preprocess_inputs()\n", + "\n", + "prob.add_pre_mission_systems()\n", + "\n", + "prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "prob.add_driver(optimizer, max_iter=0)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "# Load optimization problem formulation\n", + "# Detail which variables the optimizer can control\n", + "prob.add_objective(objective_type=objective_type)\n", + "\n", + "prob.setup()\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem(record_filename)\n", + "\n", + "print(\"done\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "105e300d", + "metadata": {}, + "source": [ + "As you see, there is a single phase `cruise`, no takeoff, no landing. Note that we must set `include_takeoff` to `False` because Aviary internally tries to connect takeoff to climb phase which we don't provide. There should be a check to see if both takeoff and climb phase exist first. Aviary still has many things to be improved.\n", + "\n", + "We will see more details for what users can do in [level 3](onboarding_level3.ipynb).\n", + "\n", + "Level 2 is where you can integrate user-defined [external subsystems](https://github.com/OpenMDAO/Aviary/blob/main/aviary/docs/user_guide/subsystems.md), which is one of the main features of the Aviary tool. [Examples](https://github.com/OpenMDAO/Aviary/blob/main/aviary/docs/user_guide/using_external_subsystems.md) of external subsystems are: acoustics, battery modeling, etc.\n", + "Assume that you already have an external subsystem that you want to incorporate it into your model. We show how to add external subsystems via `external_subsystems` key in `phase_info`. External subsystems can be added in all phases. For example, we can have:\n", + "\n", + "```\n", + "from aviary.subsystems.test.test_dummy_subsystem import PreOnlyBuilder, PostOnlyBuilder, \\\n", + " ArrayGuessSubsystemBuilder, AdditionalArrayGuessSubsystemBuilder\n", + "\n", + "phase_info = {\n", + "\t'pre_mission': {\n", + "\t\t'include_takeoff': True,\n", + "\t\t'external_subsystems': [ArrayGuessSubsystemBuilder()],\n", + "\t\t'optimize_mass': False,\n", + "\t},\n", + "\t'cruise': {\n", + "\t\t...\n", + " 'external_subsystems': \n", + " [\n", + " ArrayGuessSubsystemBuilder(),\n", + " AdditionalArrayGuessSubsystemBuilder()\n", + " ],\n", + "\t},\n", + "\t'post_mission': {\n", + "\t\t'include_landing': False,\n", + "\t\t'external_subsystems': [PostOnlyBuilder()],\n", + "\t}\n", + "}\n", + "```\n", + "\n", + "We will cover external subsystems in details in [Models with External Subsystems](onboarding_ext_subsystem.ipynb) page.\n" + ] + }, + { + "cell_type": "markdown", + "id": "d463da8c", + "metadata": {}, + "source": [ + "\n", + "### Level 2: A solved mission example\n", + "\n", + "Aviary provides an example of \"solved mission\" using level 2 at:\n", + "\n", + "```\n", + "validation_cases/benchmark_tests/test_full_mission_solved_level3.py\n", + "```\n", + "using the `aircraft_for_bench_GwGm_solved.csv` input deck. It can be run using level 2 or level 3. Here we are using the level 2 API, but as we will show in [level 3](onboarding_level3) onboarding document, `solved` missions generally fall into the level 3 category. Let us look at the key differences.\n", + "\n", + "Note that this input file specifies `solved` instead of `2DOF` under `settings:equations_of_motion`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ad02f55", + "metadata": {}, + "outputs": [], + "source": [ + "# inputs that run_aviary() requires\n", + "aircraft_filename = \"models/test_aircraft/aircraft_for_bench_GwGm_solved.csv\"\n", + "optimizer = \"IPOPT\"\n", + "analysis_scheme = av.AnalysisScheme.COLLOCATION" + ] + }, + { + "cell_type": "markdown", + "id": "aab4c294", + "metadata": {}, + "source": [ + "Here, we are specifying an objective rather than letting Aviary to choose one:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7481beb5", + "metadata": {}, + "outputs": [], + "source": [ + "objective_type = \"hybrid_objective\"\n", + "record_filename = 'aviary_history.db'\n", + "restart_filename = None\n", + "max_iter = 1" + ] + }, + { + "cell_type": "markdown", + "id": "442cfc9e", + "metadata": {}, + "source": [ + "The following block of code is normal:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15027bcc", + "metadata": {}, + "outputs": [], + "source": [ + "# Build problem\n", + "prob = av.AviaryProblem(analysis_scheme)\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs(aircraft_filename, av.default_solved_phase_info)" + ] + }, + { + "cell_type": "markdown", + "id": "96198806", + "metadata": {}, + "source": [ + "The third difference is that it alters the mission design range:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5036d584", + "metadata": {}, + "outputs": [], + "source": [ + "prob.aviary_inputs.set_val(Mission.Design.RANGE, 2000.0, units=\"NM\")" + ] + }, + { + "cell_type": "markdown", + "id": "299a9a80", + "metadata": {}, + "source": [ + "So, instead of updating entries in the vehicle deck (i.e. the `.csv` file), you can set any Aviary variables here.\n", + "\n", + "The rest of the code is the same:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "502d1eda", + "metadata": {}, + "outputs": [], + "source": [ + "# Preprocess inputs\n", + "prob.check_and_preprocess_inputs()\n", + "\n", + "prob.add_pre_mission_systems()\n", + "\n", + "prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "prob.add_driver(optimizer, max_iter=max_iter)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "# Load optimization problem formulation\n", + "# Detail which variables the optimizer can control\n", + "prob.add_objective(objective_type=objective_type)\n", + "\n", + "prob.setup()\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem(record_filename, restart_filename=restart_filename)" + ] + }, + { + "cell_type": "markdown", + "id": "638223f0", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "As you see, level 2 is more flexible than level 1. In level 2, you can:\n", + "- add/remove pre-defined mission phases (via `phase_info`, see example above);\n", + "- scale design variables (via reference value in `phase_info`)\n", + "- import additional files (e.g. `aero_data_file`);\n", + "- set pre-defined objective (e.g. `hybrid_objective`);\n", + "- add external subsystems (via `phase_info`);\n", + "- set `use_coloring` (see example above).\n", + "\n", + "Most Aviary users should be well-served by Level 2; we have purposefully constructed it to be capable of most all use cases, even those on the forefront of research in aircraft design.\n", + "\n", + "That being said, there are some cases where Level 2 is not sufficient and you may need additional flexibility. We are ready to move on to [Level 3](onboarding_level3.ipynb)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/getting_started/onboarding_level3.ipynb b/_sources/getting_started/onboarding_level3.ipynb new file mode 100644 index 000000000..67f10696b --- /dev/null +++ b/_sources/getting_started/onboarding_level3.ipynb @@ -0,0 +1,1226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "be2759f4", + "metadata": {}, + "source": [ + "# Level 3\n", + "\n", + "Level 3 represents the highest level of user control and customization in Aviary's user interface.\n", + "At this level, users have full access to Python and OpenMDAO methods that Aviary calls.\n", + "They can use the complete set of Aviary's methods, functionalities, and classes to construct and fine-tune their aircraft models.\n", + "Level 3 enables users to have supreme control over every aspect of the model, including subsystems, connections, and advanced optimization techniques.\n", + "\n", + "Level 3 is the most complex but specific methods defined at this level are used in levels 1 and 2, hopefully reducing user activation energy when learning more about Aviary.\n", + "This progressive approach helps users gradually enhance their analysis capabilities and adapt to more complex modeling requirements as they gain proficiency and experience.\n", + "\n", + "We will show two approaches of level 3 development using two examples: The first one will implement all methods differently from what are available in `aviary/interface/methods_for_level2.py` but will follow the same steps. It will show that you don't have to have a `.csv` input file and you don't have to have a `phase_info` dictionary. The second is a `solved` mission approach that is embedded into all the methods of `aviary/interface/methods_for_level2.py`.\n", + "\n", + "```{note}\n", + "For each of these examples we have set `max_iter = 0`, which means that the optimization will not run. This is done to reduce the computational time for the examples. If you want to run the optimization, you can set `max_iter = 100` or some similar value.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "e23001ca", + "metadata": {}, + "source": [ + "## A level 3 example: N3CC\n", + "\n", + "In [level 2](onboarding_level2.ipynb), we have shown how to follow the standard steps to build an Aviary model, but sometimes you may find that the model you have in mind does not match that predefined structure. If you start a new model that cannot been embedded in those methods, we can write special methods ourselves. This example will show you how to do that.\n", + "\n", + "In `aviary/validation_cases/benchmark_tests` folder, there is an N3CC aircraft full mission benchmark test `test_FLOPS_based_full_mission_N3CC.py`. Now, we will show how to create an N3CC example in level3. The key is that we follow the same steps:\n", + "- init\n", + "- load_inputs\n", + "- check_and_preprocess_inputs (optional)\n", + "- add_pre_mission_systems\n", + "- add_phases\n", + "- add_post_mission_systems\n", + "- link_phases\n", + "- add_driver\n", + "- add_design_variables (optional)\n", + "- add_objective\n", + "- setup\n", + "- set_initial_guesses\n", + "- run_aviary_problem" + ] + }, + { + "cell_type": "markdown", + "id": "1bd3c686", + "metadata": {}, + "source": [ + "### Examining an N3CC design case" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "42c6704a", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "NOTES:\n", + "Includes:\n", + "Takeoff, Climb, Cruise, Descent, Landing\n", + "Computed Aero\n", + "N3CC data\n", + "'''\n", + "import warnings\n", + "\n", + "import dymos as dm\n", + "import openmdao.api as om\n", + "import scipy.constants as _units\n", + "from packaging import version\n", + "\n", + "from aviary.api import Aircraft, Mission, Dynamic\n", + "import aviary.api as av\n", + "\n", + "use_new_dymos_syntax = version.parse(dm.__version__) > version.parse(\"1.8.0\")\n", + "\n", + "# benchmark based on N3CC (fixed cruise alt) FLOPS model\n", + "\n", + "\n", + "##########################################\n", + "# init problem #\n", + "##########################################\n", + "prob = om.Problem(model=om.Group())\n", + "\n", + "prob.driver = driver = om.pyOptSparseDriver(optimizer='IPOPT')\n", + "driver.opt_settings[\"max_iter\"] = 0\n", + "driver.opt_settings[\"tol\"] = 1e-3\n", + "driver.opt_settings['print_level'] = 4\n", + "\n", + "##########################################\n", + "# Aircraft Input Variables and Options #\n", + "##########################################\n", + "\n", + "aviary_inputs = av.get_flops_inputs('N3CC')\n", + "\n", + "aviary_inputs.set_val(\n", + " Mission.Landing.LIFT_COEFFICIENT_MAX, 2.4, units='unitless')\n", + "aviary_inputs.set_val(\n", + " Mission.Takeoff.LIFT_COEFFICIENT_MAX, 2.0, units='unitless')\n", + "aviary_inputs.set_val(\n", + " Mission.Takeoff.ROLLING_FRICTION_COEFFICIENT, val=.0175,\n", + " units='unitless')\n", + "\n", + "takeoff_fuel_burned = 577 # lbm\n", + "takeoff_thrust_per_eng = 24555.5 # lbf\n", + "takeoff_L_over_D = 17.35\n", + "\n", + "aviary_inputs.set_val(\n", + " Mission.Takeoff.FUEL_SIMPLE, takeoff_fuel_burned, units='lbm')\n", + "aviary_inputs.set_val(\n", + " Mission.Takeoff.LIFT_OVER_DRAG, takeoff_L_over_D, units='unitless')\n", + "aviary_inputs.set_val(\n", + " Mission.Design.THRUST_TAKEOFF_PER_ENG, takeoff_thrust_per_eng, units='lbf')\n", + "\n", + "##########################################\n", + "# Phase Info #\n", + "##########################################\n", + "\n", + "alt_airport = 0 # ft\n", + "cruise_mach = .785\n", + "\n", + "alt_i_climb = 0*_units.foot # m\n", + "alt_f_climb = 35000.0*_units.foot # m\n", + "mass_i_climb = 131000*_units.lb # kg\n", + "mass_f_climb = 126000*_units.lb # kg\n", + "v_i_climb = 198.44*_units.knot # m/s\n", + "v_f_climb = 455.49*_units.knot # m/s\n", + "# initial mach set to lower value so it can intersect with takeoff end mach\n", + "# mach_i_climb = 0.3\n", + "mach_i_climb = 0.2\n", + "mach_f_climb = cruise_mach\n", + "range_i_climb = 0*_units.nautical_mile # m\n", + "range_f_climb = 160.3*_units.nautical_mile # m\n", + "t_i_climb = 2 * _units.minute # sec\n", + "t_f_climb = 26.20*_units.minute # sec\n", + "t_duration_climb = t_f_climb - t_i_climb\n", + "\n", + "alt_i_cruise = 35000*_units.foot # m\n", + "alt_f_cruise = 35000*_units.foot # m\n", + "alt_min_cruise = 35000*_units.foot # m\n", + "alt_max_cruise = 35000*_units.foot # m\n", + "mass_i_cruise = 126000*_units.lb # kg\n", + "mass_f_cruise = 102000*_units.lb # kg\n", + "v_i_cruise = 455.49*_units.knot # m/s\n", + "v_f_cruise = 455.49*_units.knot # m/s\n", + "mach_min_cruise = cruise_mach\n", + "mach_max_cruise = cruise_mach\n", + "range_i_cruise = 160.3*_units.nautical_mile # m\n", + "range_f_cruise = 3243.9*_units.nautical_mile # m\n", + "t_i_cruise = 26.20*_units.minute # sec\n", + "t_f_cruise = 432.38*_units.minute # sec\n", + "t_duration_cruise = t_f_cruise - t_i_cruise\n", + "\n", + "alt_i_descent = 35000*_units.foot\n", + "# final altitude set to 35 to ensure landing is feasible point\n", + "# alt_f_descent = 0*_units.foot\n", + "alt_f_descent = 35*_units.foot\n", + "v_i_descent = 455.49*_units.knot\n", + "v_f_descent = 198.44*_units.knot\n", + "mach_i_descent = cruise_mach\n", + "mach_f_descent = 0.3\n", + "mass_i_descent = 102000*_units.pound\n", + "mass_f_descent = 101000*_units.pound\n", + "range_i_descent = 3243.9*_units.nautical_mile\n", + "range_f_descent = 3378.7*_units.nautical_mile\n", + "t_i_descent = 432.38*_units.minute\n", + "t_f_descent = 461.62*_units.minute\n", + "t_duration_descent = t_f_descent - t_i_descent\n", + "\n", + "##################\n", + "# Define Phases #\n", + "##################\n", + "\n", + "num_segments_climb = 6\n", + "num_segments_cruise = 1\n", + "num_segments_descent = 5\n", + "\n", + "climb_seg_ends, _ = dm.utils.lgl.lgl(num_segments_climb + 1)\n", + "descent_seg_ends, _ = dm.utils.lgl.lgl(num_segments_descent + 1)\n", + "\n", + "transcription_climb = dm.Radau(\n", + " num_segments=num_segments_climb, order=3, compressed=True,\n", + " segment_ends=climb_seg_ends)\n", + "transcription_cruise = dm.Radau(\n", + " num_segments=num_segments_cruise, order=3, compressed=True)\n", + "transcription_descent = dm.Radau(\n", + " num_segments=num_segments_descent, order=3, compressed=True,\n", + " segment_ends=descent_seg_ends)\n", + "\n", + "takeoff_options = av.HeightEnergyTakeoffPhaseBuilder(\n", + " airport_altitude=alt_airport, # ft\n", + " num_engines=aviary_inputs.get_val(Aircraft.Engine.NUM_ENGINES)\n", + ")\n", + "\n", + "climb_options = av.HeightEnergyClimbPhaseBuilder(\n", + " 'test_climb',\n", + " user_options=av.AviaryValues({\n", + " 'initial_altitude': (alt_i_climb, 'm'),\n", + " 'final_altitude': (alt_f_climb, 'm'),\n", + " 'initial_mach': (mach_i_climb, 'unitless'),\n", + " 'final_mach': (mach_f_climb, 'unitless'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_range': (False, 'unitless'),\n", + " 'input_initial': (True, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_climb,\n", + ")\n", + "\n", + "cruise_options = av.HeightEnergyCruisePhaseBuilder(\n", + " 'test_cruise',\n", + " user_options=av.AviaryValues({\n", + " 'min_altitude': (alt_min_cruise, 'm'),\n", + " 'max_altitude': (alt_max_cruise, 'm'),\n", + " 'min_mach': (mach_min_cruise, 'unitless'),\n", + " 'max_mach': (mach_max_cruise, 'unitless'),\n", + " 'required_available_climb_rate': (300, 'ft/min'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_final': (False, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_cruise,\n", + ")\n", + "\n", + "descent_options = av.HeightEnergyDescentPhaseBuilder(\n", + " 'test_descent',\n", + " user_options=av.AviaryValues({\n", + " 'final_altitude': (alt_f_descent, 'm'),\n", + " 'initial_altitude': (alt_i_descent, 'm'),\n", + " 'initial_mach': (mach_i_descent, 'unitless'),\n", + " 'final_mach': (mach_f_descent, 'unitless'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_range': (True, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_descent,\n", + ")\n", + "\n", + "landing_options = av.HeightEnergyLandingPhaseBuilder(\n", + " ref_wing_area=aviary_inputs.get_val(Aircraft.Wing.AREA, 'ft**2'),\n", + " Cl_max_ldg=aviary_inputs.get_val(Mission.Landing.LIFT_COEFFICIENT_MAX)\n", + ")\n", + "\n", + "av.preprocess_crewpayload(aviary_inputs)\n", + "\n", + "##########################################\n", + "# add pre mission systems #\n", + "##########################################\n", + "\n", + "# Upstream static analysis for aero\n", + "prob.model.add_subsystem(\n", + " 'pre_mission',\n", + " av.CorePreMission(aviary_options=aviary_inputs,\n", + " subsystems=av.default_premission_subsystems),\n", + " promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['aircraft:*', 'mission:*'])\n", + "\n", + "##########################################\n", + "# add phases #\n", + "##########################################\n", + "\n", + "# directly connect phases (strong_couple = True), or use linkage constraints (weak\n", + "# coupling / strong_couple=False)\n", + "strong_couple = False\n", + "\n", + "takeoff = takeoff_options.build_phase(False)\n", + "\n", + "climb = climb_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + "cruise = cruise_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + "descent = descent_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + "landing = landing_options.build_phase(False)\n", + "\n", + "prob.model.add_subsystem(\n", + " 'takeoff', takeoff, promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['mission:*'])\n", + "\n", + "traj = prob.model.add_subsystem('traj', dm.Trajectory())\n", + "\n", + "# if fix_initial is false, can we always set input_initial to be true for\n", + "# necessary states, and then ignore if we use a linkage?\n", + "climb.set_time_options(\n", + " fix_initial=True, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_climb*2), duration_ref=t_duration_climb)\n", + "cruise.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_cruise*2), duration_ref=t_duration_cruise)\n", + "descent.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_descent*2), duration_ref=t_duration_descent)\n", + "\n", + "traj.add_phase('climb', climb)\n", + "\n", + "traj.add_phase('cruise', cruise)\n", + "\n", + "traj.add_phase('descent', descent)\n", + "\n", + "if use_new_dymos_syntax:\n", + " climb.timeseries_options['use_prefix'] = True\n", + " cruise.timeseries_options['use_prefix'] = True\n", + " descent.timeseries_options['use_prefix'] = True\n", + "\n", + "##########################################\n", + "# add post mission system #\n", + "##########################################\n", + "\n", + "prob.model.add_subsystem(\n", + " 'landing', landing, promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['mission:*'])\n", + "\n", + "##########################################\n", + "# link phases #\n", + "##########################################\n", + "\n", + "traj.link_phases([\"climb\", \"cruise\"], [\"time\", Dynamic.Mission.ALTITUDE,\n", + " Dynamic.Mission.VELOCITY, Dynamic.Mission.MASS, Dynamic.Mission.RANGE], connected=strong_couple)\n", + "traj.link_phases([\"cruise\", \"descent\"], [\"time\", Dynamic.Mission.ALTITUDE,\n", + " Dynamic.Mission.VELOCITY, Dynamic.Mission.MASS, Dynamic.Mission.RANGE], connected=strong_couple)\n", + "\n", + "traj = av.setup_trajectory_params(prob.model, traj, aviary_inputs)\n", + "\n", + "##################################\n", + "# Connect in Takeoff and Landing #\n", + "##################################\n", + "\n", + "prob.model.add_subsystem(\n", + " \"takeoff_constraints\",\n", + " om.ExecComp(\n", + " [\n", + " \"takeoff_mass_con=takeoff_mass-climb_start_mass\",\n", + " \"takeoff_range_con=takeoff_range-climb_start_range\",\n", + " \"takeoff_vel_con=takeoff_vel-climb_start_vel\",\n", + " \"takeoff_alt_con=takeoff_alt-climb_start_alt\"\n", + " ],\n", + " takeoff_mass_con={'units': 'lbm'}, takeoff_mass={'units': 'lbm'},\n", + " climb_start_mass={'units': 'lbm'},\n", + " takeoff_range_con={'units': 'ft'}, takeoff_range={'units': 'ft'},\n", + " climb_start_range={'units': 'ft'},\n", + " takeoff_vel_con={'units': 'm/s'}, takeoff_vel={'units': 'm/s'},\n", + " climb_start_vel={'units': 'm/s'},\n", + " takeoff_alt_con={'units': 'ft'}, takeoff_alt={'units': 'ft'},\n", + " climb_start_alt={'units': 'ft'}\n", + " ),\n", + " promotes_inputs=[\n", + " (\"takeoff_mass\", Mission.Takeoff.FINAL_MASS),\n", + " (\"takeoff_range\", Mission.Takeoff.GROUND_DISTANCE),\n", + " (\"takeoff_vel\", Mission.Takeoff.FINAL_VELOCITY),\n", + " (\"takeoff_alt\", Mission.Takeoff.FINAL_ALTITUDE),\n", + " ],\n", + " promotes_outputs=[\"takeoff_mass_con\", \"takeoff_range_con\",\n", + " \"takeoff_vel_con\", \"takeoff_alt_con\"],\n", + ")\n", + "\n", + "prob.model.connect('traj.climb.states:mass',\n", + " 'takeoff_constraints.climb_start_mass', src_indices=[0])\n", + "prob.model.connect('traj.climb.states:range',\n", + " 'takeoff_constraints.climb_start_range', src_indices=[0])\n", + "prob.model.connect('traj.climb.states:velocity',\n", + " 'takeoff_constraints.climb_start_vel', src_indices=[0])\n", + "prob.model.connect('traj.climb.states:altitude',\n", + " 'takeoff_constraints.climb_start_alt', src_indices=[0])\n", + "\n", + "prob.model.connect(Mission.Takeoff.FINAL_MASS,\n", + " 'traj.climb.initial_states:mass')\n", + "prob.model.connect(Mission.Takeoff.GROUND_DISTANCE,\n", + " 'traj.climb.initial_states:range')\n", + "prob.model.connect(Mission.Takeoff.FINAL_VELOCITY,\n", + " 'traj.climb.initial_states:velocity')\n", + "prob.model.connect(Mission.Takeoff.FINAL_ALTITUDE,\n", + " 'traj.climb.initial_states:altitude')\n", + "\n", + "prob.model.connect('traj.descent.states:mass',\n", + " Mission.Landing.TOUCHDOWN_MASS, src_indices=[-1])\n", + "prob.model.connect('traj.descent.states:altitude', Mission.Landing.INITIAL_ALTITUDE,\n", + " src_indices=[-1])\n", + "\n", + "##########################\n", + "# Add Objective Function #\n", + "##########################\n", + "\n", + "# This is an example of a overall mission objective\n", + "# create a compound objective that minimizes climb time and maximizes final mass\n", + "# we are maxing final mass b/c we don't have an independent value for fuel_mass yet\n", + "# we are going to normalize these (makign each of the sub-objectives approx = 1 )\n", + "prob.model.add_subsystem(\n", + " \"regularization\",\n", + " om.ExecComp(\n", + " \"reg_objective = - descent_mass_final/60000\",\n", + " reg_objective=0.0,\n", + " descent_mass_final={\"units\": \"kg\", \"shape\": 1},\n", + " ),\n", + " promotes_outputs=['reg_objective']\n", + ")\n", + "# connect the final mass from cruise into the objective\n", + "prob.model.connect(\"traj.descent.states:mass\",\n", + " \"regularization.descent_mass_final\", src_indices=[-1])\n", + "\n", + "prob.model.add_objective('reg_objective', ref=1)\n", + "\n", + "prob.model.add_subsystem(\n", + " 'input_sink',\n", + " av.VariablesIn(aviary_options=aviary_inputs),\n", + " promotes_inputs=['*'],\n", + " promotes_outputs=['*']\n", + ")\n", + "\n", + "# suppress warnings:\n", + "# \"input variable '...' promoted using '*' was already promoted using 'aircraft:*'\n", + "with warnings.catch_warnings():\n", + "\n", + " # Set initial default values for all LEAPS aircraft variables.\n", + " warnings.simplefilter(\"ignore\", om.PromotionWarning)\n", + " av.set_aviary_initial_values(prob.model, aviary_inputs)\n", + "\n", + " warnings.simplefilter(\"ignore\", om.PromotionWarning)\n", + " prob.setup()\n", + "\n", + "###########################################\n", + "# Intial Settings for States and Controls #\n", + "###########################################\n", + "\n", + "prob.set_val('traj.climb.t_initial', t_i_climb, units='s')\n", + "prob.set_val('traj.climb.t_duration', t_duration_climb, units='s')\n", + "\n", + "prob.set_val('traj.climb.states:altitude', climb.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_climb, alt_f_climb]), units='m')\n", + "# prob.set_val(\n", + "# 'traj.climb.states:velocity', climb.interp(Dynamic.Mission.VELOCITY, ys=[170, v_f_climb]),\n", + "# units='m/s')\n", + "prob.set_val('traj.climb.states:velocity', climb.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_climb, v_f_climb]), units='m/s')\n", + "prob.set_val('traj.climb.states:mass', climb.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_climb, mass_f_climb]), units='kg')\n", + "prob.set_val('traj.climb.states:range', climb.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_climb, range_f_climb]), units='m') # nmi\n", + "\n", + "prob.set_val('traj.climb.controls:velocity_rate',\n", + " climb.interp(Dynamic.Mission.VELOCITY_RATE, ys=[0.25, 0.0]),\n", + " units='m/s**2')\n", + "prob.set_val('traj.climb.controls:throttle',\n", + " climb.interp(Dynamic.Mission.THROTTLE, ys=[1.0, 1.0]),\n", + " units='unitless')\n", + "\n", + "prob.set_val('traj.cruise.t_initial', t_i_cruise, units='s')\n", + "prob.set_val('traj.cruise.t_duration', t_duration_cruise, units='s')\n", + "\n", + "prob.set_val('traj.cruise.states:altitude', cruise.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_cruise, alt_f_cruise]), units='m')\n", + "prob.set_val('traj.cruise.states:velocity', cruise.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_cruise, v_f_cruise]), units='m/s')\n", + "prob.set_val('traj.cruise.states:mass', cruise.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_cruise, mass_f_cruise]), units='kg')\n", + "prob.set_val('traj.cruise.states:range', cruise.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_cruise, range_f_cruise]), units='m') # nmi\n", + "\n", + "prob.set_val('traj.cruise.controls:velocity_rate',\n", + " cruise.interp(Dynamic.Mission.VELOCITY_RATE, ys=[0.0, 0.0]),\n", + " units='m/s**2')\n", + "prob.set_val('traj.cruise.controls:throttle',\n", + " cruise.interp(Dynamic.Mission.THROTTLE, ys=[0.8, 0.75]),\n", + " units='unitless')\n", + "\n", + "prob.set_val('traj.descent.t_initial', t_i_descent, units='s')\n", + "prob.set_val('traj.descent.t_duration', t_duration_descent, units='s')\n", + "\n", + "prob.set_val('traj.descent.states:altitude', descent.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_descent, alt_f_descent]), units='m')\n", + "prob.set_val('traj.descent.states:velocity', descent.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_descent, v_f_descent]), units='m/s')\n", + "prob.set_val('traj.descent.states:mass', descent.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_descent, mass_f_descent]), units='kg')\n", + "prob.set_val('traj.descent.states:range', descent.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_descent, range_f_descent]), units='m')\n", + "\n", + "prob.set_val('traj.descent.controls:velocity_rate',\n", + " descent.interp(Dynamic.Mission.VELOCITY_RATE, ys=[-0.25, 0.0]),\n", + " units='m/s**2')\n", + "prob.set_val('traj.descent.controls:throttle',\n", + " descent.interp(Dynamic.Mission.THROTTLE, ys=[0.0, 0.0]),\n", + " units='unitless')\n", + "\n", + "# Turn off solver printing so that the SNOPT output is readable.\n", + "prob.set_solver_print(level=0)\n", + "\n", + "dm.run_problem(prob, make_plots=False, solution_record_file='N3CC_full_mission.db')\n", + "prob.record(\"final\")\n", + "prob.cleanup()\n", + "\n", + "times_climb = prob.get_val('traj.climb.timeseries.time', units='s')\n", + "altitudes_climb = prob.get_val(\n", + " 'traj.climb.timeseries.states:altitude', units='m')\n", + "masses_climb = prob.get_val('traj.climb.timeseries.states:mass', units='kg')\n", + "ranges_climb = prob.get_val('traj.climb.timeseries.states:range', units='m')\n", + "velocities_climb = prob.get_val(\n", + " 'traj.climb.timeseries.states:velocity', units='m/s')\n", + "thrusts_climb = prob.get_val('traj.climb.timeseries.thrust_net_total', units='N')\n", + "times_cruise = prob.get_val('traj.cruise.timeseries.time', units='s')\n", + "altitudes_cruise = prob.get_val(\n", + " 'traj.cruise.timeseries.states:altitude', units='m')\n", + "masses_cruise = prob.get_val('traj.cruise.timeseries.states:mass', units='kg')\n", + "ranges_cruise = prob.get_val('traj.cruise.timeseries.states:range', units='m')\n", + "velocities_cruise = prob.get_val(\n", + " 'traj.cruise.timeseries.states:velocity', units='m/s')\n", + "thrusts_cruise = prob.get_val(\n", + " 'traj.cruise.timeseries.thrust_net_total', units='N')\n", + "times_descent = prob.get_val('traj.descent.timeseries.time', units='s')\n", + "altitudes_descent = prob.get_val(\n", + " 'traj.descent.timeseries.states:altitude', units='m')\n", + "masses_descent = prob.get_val('traj.descent.timeseries.states:mass', units='kg')\n", + "ranges_descent = prob.get_val('traj.descent.timeseries.states:range', units='m')\n", + "velocities_descent = prob.get_val(\n", + " 'traj.descent.timeseries.states:velocity', units='m/s')\n", + "thrusts_descent = prob.get_val(\n", + " 'traj.descent.timeseries.thrust_net_total', units='N')\n", + "\n", + "print(\"-------------------------------\")\n", + "print(f\"times_climb: {times_climb[-1]} (s)\")\n", + "print(f\"altitudes_climb: {altitudes_climb[-1]} (m)\")\n", + "print(f\"masses_climb: {masses_climb[-1]} (kg)\")\n", + "print(f\"ranges_climb: {ranges_climb[-1]} (m)\")\n", + "print(f\"velocities_climb: {velocities_climb[-1]} (m/s)\")\n", + "print(f\"thrusts_climb: {thrusts_climb[-1]} (N)\")\n", + "print(f\"times_cruise: {times_cruise[-1]} (s)\")\n", + "print(f\"altitudes_cruise: {altitudes_cruise[-1]} (m)\")\n", + "print(f\"masses_cruise: {masses_cruise[-1]} (kg)\")\n", + "print(f\"ranges_cruise: {ranges_cruise[-1]} (m)\")\n", + "print(f\"velocities_cruise: {velocities_cruise[-1]} (m/s)\")\n", + "print(f\"thrusts_cruise: {thrusts_cruise[-1]} (N)\")\n", + "print(f\"times_descent: {times_descent[-1]} (s)\")\n", + "print(f\"altitudes_descent: {altitudes_descent[-1]} (m)\")\n", + "print(f\"masses_descent: {masses_descent[-1]} (kg)\")\n", + "print(f\"ranges_descent: {ranges_descent[-1]} (m)\")\n", + "print(f\"velocities_descent: {velocities_descent[-1]} (m/s)\")\n", + "print(f\"thrusts_descent: {thrusts_descent[-1]} (N)\")\n", + "print(\"-------------------------------\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "4c0f7de8", + "metadata": {}, + "source": [ + "### Move each code block to a function\n", + "\n", + "This code is quite verbose!\n", + "\n", + "To make it easier to follow the steps mentioned above, we split this script into several functions each representing a step at the beginning of this section (except `check_and_preprocess_inputs()` and `add_design_variables()`).\n", + "These methods also closely mirror those from `aviary/interface/methods_for_level2.py`, so you can draw parallels between Level 2 and 3.\n", + "\n", + "Here's what the new run script looks like:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1b0432f", + "metadata": {}, + "outputs": [], + "source": [ + "'''\n", + "NOTES:\n", + "Includes:\n", + "Takeoff, Climb, Cruise, Descent, Landing\n", + "Computed Aero\n", + "N3CC data\n", + "'''\n", + "import warnings\n", + "\n", + "import dymos as dm\n", + "import openmdao.api as om\n", + "import scipy.constants as _units\n", + "from packaging import version\n", + "\n", + "import aviary.api as av\n", + "\n", + "use_new_dymos_syntax = version.parse(dm.__version__) > version.parse(\"1.8.0\")\n", + "\n", + "\n", + "##########################################\n", + "# Phase Info\n", + "##########################################\n", + "\n", + "alt_airport = 0 # ft\n", + "cruise_mach = .785\n", + "\n", + "alt_i_climb = 0*_units.foot # m\n", + "alt_f_climb = 35000.0*_units.foot # m\n", + "mass_i_climb = 131000*_units.lb # kg\n", + "mass_f_climb = 126000*_units.lb # kg\n", + "v_i_climb = 198.44*_units.knot # m/s\n", + "v_f_climb = 455.49*_units.knot # m/s\n", + "# initial mach set to lower value so it can intersect with takeoff end mach\n", + "# mach_i_climb = 0.3\n", + "mach_i_climb = 0.2\n", + "mach_f_climb = cruise_mach\n", + "range_i_climb = 0*_units.nautical_mile # m\n", + "range_f_climb = 160.3*_units.nautical_mile # m\n", + "t_i_climb = 2 * _units.minute # sec\n", + "t_f_climb = 26.20*_units.minute # sec\n", + "t_duration_climb = t_f_climb - t_i_climb\n", + "\n", + "alt_i_cruise = 35000*_units.foot # m\n", + "alt_f_cruise = 35000*_units.foot # m\n", + "alt_min_cruise = 35000*_units.foot # m\n", + "alt_max_cruise = 35000*_units.foot # m\n", + "mass_i_cruise = 126000*_units.lb # kg\n", + "mass_f_cruise = 102000*_units.lb # kg\n", + "v_i_cruise = 455.49*_units.knot # m/s\n", + "v_f_cruise = 455.49*_units.knot # m/s\n", + "mach_min_cruise = cruise_mach\n", + "mach_max_cruise = cruise_mach\n", + "range_i_cruise = 160.3*_units.nautical_mile # m\n", + "range_f_cruise = 3243.9*_units.nautical_mile # m\n", + "t_i_cruise = 26.20*_units.minute # sec\n", + "t_f_cruise = 432.38*_units.minute # sec\n", + "t_duration_cruise = t_f_cruise - t_i_cruise\n", + "\n", + "alt_i_descent = 35000*_units.foot\n", + "# final altitude set to 35 to ensure landing is feasible point\n", + "# alt_f_descent = 0*_units.foot\n", + "alt_f_descent = 35*_units.foot\n", + "v_i_descent = 455.49*_units.knot\n", + "v_f_descent = 198.44*_units.knot\n", + "mach_i_descent = cruise_mach\n", + "mach_f_descent = 0.3\n", + "mass_i_descent = 102000*_units.pound\n", + "mass_f_descent = 101000*_units.pound\n", + "range_i_descent = 3243.9*_units.nautical_mile\n", + "range_f_descent = 3378.7*_units.nautical_mile\n", + "t_i_descent = 432.38*_units.minute\n", + "t_f_descent = 461.62*_units.minute\n", + "t_duration_descent = t_f_descent - t_i_descent\n", + "\n", + "def load_inputs():\n", + " aviary_inputs = av.get_flops_inputs('N3CC')\n", + "\n", + " aviary_inputs.set_val(\n", + " Mission.Landing.LIFT_COEFFICIENT_MAX, 2.4, units='unitless')\n", + " aviary_inputs.set_val(\n", + " Mission.Takeoff.LIFT_COEFFICIENT_MAX, 2.0, units='unitless')\n", + " aviary_inputs.set_val(\n", + " Mission.Takeoff.ROLLING_FRICTION_COEFFICIENT, val=.0175,\n", + " units='unitless')\n", + "\n", + " takeoff_fuel_burned = 577 # lbm\n", + " takeoff_thrust_per_eng = 24555.5 # lbf\n", + " takeoff_L_over_D = 17.35\n", + "\n", + " aviary_inputs.set_val(\n", + " Mission.Takeoff.FUEL_SIMPLE, takeoff_fuel_burned, units='lbm')\n", + " aviary_inputs.set_val(\n", + " Mission.Takeoff.LIFT_OVER_DRAG, takeoff_L_over_D, units='unitless')\n", + " aviary_inputs.set_val(\n", + " Mission.Design.THRUST_TAKEOFF_PER_ENG, takeoff_thrust_per_eng, units='lbf')\n", + "\n", + " return aviary_inputs\n", + "\n", + "\n", + "def add_pre_mission_system(aviary_inputs, prob):\n", + " takeoff_options = av.HeightEnergyTakeoffPhaseBuilder(\n", + " airport_altitude=alt_airport, # ft\n", + " num_engines=aviary_inputs.get_val(Aircraft.Engine.NUM_ENGINES)\n", + " )\n", + "\n", + " av.preprocess_crewpayload(aviary_inputs)\n", + "\n", + " # Upstream static analysis for aero\n", + " prob.model.add_subsystem(\n", + " 'pre_mission',\n", + " av.CorePreMission(aviary_options=aviary_inputs,\n", + " subsystems=av.default_premission_subsystems),\n", + " promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['aircraft:*', 'mission:*'])\n", + "\n", + " takeoff = takeoff_options.build_phase(False)\n", + "\n", + " prob.model.add_subsystem(\n", + " 'takeoff', takeoff, promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['mission:*'])\n", + "\n", + " prob.model.add_subsystem(\n", + " \"takeoff_constraints\",\n", + " om.ExecComp(\n", + " [\n", + " \"takeoff_mass_con=takeoff_mass-climb_start_mass\",\n", + " \"takeoff_range_con=takeoff_range-climb_start_range\",\n", + " \"takeoff_vel_con=takeoff_vel-climb_start_vel\",\n", + " \"takeoff_alt_con=takeoff_alt-climb_start_alt\"\n", + " ],\n", + " takeoff_mass_con={'units': 'lbm'}, takeoff_mass={'units': 'lbm'},\n", + " climb_start_mass={'units': 'lbm'},\n", + " takeoff_range_con={'units': 'ft'}, takeoff_range={'units': 'ft'},\n", + " climb_start_range={'units': 'ft'},\n", + " takeoff_vel_con={'units': 'm/s'}, takeoff_vel={'units': 'm/s'},\n", + " climb_start_vel={'units': 'm/s'},\n", + " takeoff_alt_con={'units': 'ft'}, takeoff_alt={'units': 'ft'},\n", + " climb_start_alt={'units': 'ft'}\n", + " ),\n", + " promotes_inputs=[\n", + " (\"takeoff_mass\", Mission.Takeoff.FINAL_MASS),\n", + " (\"takeoff_range\", Mission.Takeoff.GROUND_DISTANCE),\n", + " (\"takeoff_vel\", Mission.Takeoff.FINAL_VELOCITY),\n", + " (\"takeoff_alt\", Mission.Takeoff.FINAL_ALTITUDE),\n", + " ],\n", + " promotes_outputs=[\"takeoff_mass_con\", \"takeoff_range_con\",\n", + " \"takeoff_vel_con\", \"takeoff_alt_con\"],\n", + " )\n", + "\n", + " prob.model.connect(Mission.Takeoff.FINAL_MASS,\n", + " 'traj.climb.initial_states:mass')\n", + " prob.model.connect(Mission.Takeoff.GROUND_DISTANCE,\n", + " 'traj.climb.initial_states:range')\n", + " prob.model.connect(Mission.Takeoff.FINAL_VELOCITY,\n", + " 'traj.climb.initial_states:velocity')\n", + " prob.model.connect(Mission.Takeoff.FINAL_ALTITUDE,\n", + " 'traj.climb.initial_states:altitude')\n", + "\n", + "\n", + "def add_post_mission_systems(aviary_inputs, prob):\n", + " landing_options = av.HeightEnergyLandingPhaseBuilder(\n", + " ref_wing_area=aviary_inputs.get_val(Aircraft.Wing.AREA, 'ft**2'),\n", + " Cl_max_ldg=aviary_inputs.get_val(Mission.Landing.LIFT_COEFFICIENT_MAX)\n", + " )\n", + "\n", + " landing = landing_options.build_phase(\n", + " False,\n", + " )\n", + "\n", + " prob.model.add_subsystem(\n", + " 'landing', landing, promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['mission:*'])\n", + "\n", + " prob.model.connect('traj.descent.states:mass',\n", + " Mission.Landing.TOUCHDOWN_MASS, src_indices=[-1])\n", + " prob.model.connect('traj.descent.states:altitude', Mission.Landing.INITIAL_ALTITUDE,\n", + " src_indices=[-1])\n", + "\n", + "\n", + "def set_initial_guesses(prob, traj):\n", + " # have to add this block to recover climb, cruise, and descent phases first\n", + " phase_items = traj._phases.items()\n", + " for idx, (_, phase) in enumerate(phase_items):\n", + " if idx == 0: climb = phase\n", + " elif idx == 1: cruise = phase\n", + " else: descent = phase\n", + "\n", + " prob.set_val('traj.climb.t_initial', t_i_climb, units='s')\n", + " prob.set_val('traj.climb.t_duration', t_duration_climb, units='s')\n", + "\n", + " prob.set_val('traj.climb.states:altitude', climb.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_climb, alt_f_climb]), units='m')\n", + " # prob.set_val(\n", + " # 'traj.climb.states:velocity', climb.interp(Dynamic.Mission.VELOCITY, ys=[170, v_f_climb]),\n", + " # units='m/s')\n", + " prob.set_val('traj.climb.states:velocity', climb.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_climb, v_f_climb]), units='m/s')\n", + " prob.set_val('traj.climb.states:mass', climb.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_climb, mass_f_climb]), units='kg')\n", + " prob.set_val('traj.climb.states:range', climb.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_climb, range_f_climb]), units='m') # nmi\n", + "\n", + " prob.set_val('traj.climb.controls:velocity_rate',\n", + " climb.interp(Dynamic.Mission.VELOCITY_RATE, ys=[0.25, 0.0]),\n", + " units='m/s**2')\n", + " prob.set_val('traj.climb.controls:throttle',\n", + " climb.interp(Dynamic.Mission.THROTTLE, ys=[1.0, 1.0]),\n", + " units='unitless')\n", + "\n", + " prob.set_val('traj.cruise.t_initial', t_i_cruise, units='s')\n", + " prob.set_val('traj.cruise.t_duration', t_duration_cruise, units='s')\n", + "\n", + " prob.set_val('traj.cruise.states:altitude', cruise.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_cruise, alt_f_cruise]), units='m')\n", + " prob.set_val('traj.cruise.states:velocity', cruise.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_cruise, v_f_cruise]), units='m/s')\n", + " prob.set_val('traj.cruise.states:mass', cruise.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_cruise, mass_f_cruise]), units='kg')\n", + " prob.set_val('traj.cruise.states:range', cruise.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_cruise, range_f_cruise]), units='m') # nmi\n", + "\n", + " prob.set_val('traj.cruise.controls:velocity_rate',\n", + " cruise.interp(Dynamic.Mission.VELOCITY_RATE, ys=[0.0, 0.0]),\n", + " units='m/s**2')\n", + " prob.set_val('traj.cruise.controls:throttle',\n", + " cruise.interp(Dynamic.Mission.THROTTLE, ys=[0.8, 0.75]),\n", + " units='unitless')\n", + "\n", + " prob.set_val('traj.descent.t_initial', t_i_descent, units='s')\n", + " prob.set_val('traj.descent.t_duration', t_duration_descent, units='s')\n", + "\n", + " prob.set_val('traj.descent.states:altitude', descent.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_descent, alt_f_descent]), units='m')\n", + " prob.set_val('traj.descent.states:velocity', descent.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_descent, v_f_descent]), units='m/s')\n", + " prob.set_val('traj.descent.states:mass', descent.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_descent, mass_f_descent]), units='kg')\n", + " prob.set_val('traj.descent.states:range', descent.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_descent, range_f_descent]), units='m')\n", + "\n", + " prob.set_val('traj.descent.controls:velocity_rate',\n", + " descent.interp(Dynamic.Mission.VELOCITY_RATE, ys=[-0.25, 0.0]),\n", + " units='m/s**2')\n", + " prob.set_val('traj.descent.controls:throttle',\n", + " descent.interp(Dynamic.Mission.THROTTLE, ys=[0.0, 0.0]),\n", + " units='unitless')\n", + "\n", + "\n", + "def setup(aviary_inputs, prob):\n", + " prob.model.add_subsystem(\n", + " 'input_sink',\n", + " av.VariablesIn(aviary_options=aviary_inputs),\n", + " promotes_inputs=['*'],\n", + " promotes_outputs=['*']\n", + " )\n", + "\n", + " # suppress warnings:\n", + " # \"input variable '...' promoted using '*' was already promoted using 'aircraft:*'\n", + " with warnings.catch_warnings():\n", + "\n", + " # Set initial default values for all LEAPS aircraft variables.\n", + " warnings.simplefilter(\"ignore\", om.PromotionWarning)\n", + " av.set_aviary_initial_values(prob.model, aviary_inputs)\n", + "\n", + " warnings.simplefilter(\"ignore\", om.PromotionWarning)\n", + " prob.setup()\n", + "\n", + "\n", + "def add_objective(prob):\n", + " # This is an example of a overall mission objective\n", + " # create a compound objective that minimizes climb time and maximizes final mass\n", + " # we are maxing final mass b/c we don't have an independent value for fuel_mass yet\n", + " # we are going to normalize these (makign each of the sub-objectives approx = 1 )\n", + " prob.model.add_subsystem(\n", + " \"regularization\",\n", + " om.ExecComp(\n", + " \"reg_objective = - descent_mass_final/60000\",\n", + " reg_objective=0.0,\n", + " descent_mass_final={\"units\": \"kg\", \"shape\": 1},\n", + " ),\n", + " promotes_outputs=['reg_objective']\n", + " )\n", + " # connect the final mass from descent into the objective\n", + " prob.model.connect(\"traj.descent.states:mass\",\n", + " \"regularization.descent_mass_final\", src_indices=[-1])\n", + "\n", + " prob.model.add_objective('reg_objective', ref=1)\n", + "\n", + "\n", + "def add_phases(aviary_inputs, prob):\n", + " ##################\n", + " # Define Phases #\n", + " ##################\n", + "\n", + " num_segments_climb = 6\n", + " num_segments_cruise = 1\n", + " num_segments_descent = 5\n", + "\n", + " climb_seg_ends, _ = dm.utils.lgl.lgl(num_segments_climb + 1)\n", + " descent_seg_ends, _ = dm.utils.lgl.lgl(num_segments_descent + 1)\n", + "\n", + " transcription_climb = dm.Radau(\n", + " num_segments=num_segments_climb, order=3, compressed=True,\n", + " segment_ends=climb_seg_ends)\n", + " transcription_cruise = dm.Radau(\n", + " num_segments=num_segments_cruise, order=3, compressed=True)\n", + " transcription_descent = dm.Radau(\n", + " num_segments=num_segments_descent, order=3, compressed=True,\n", + " segment_ends=descent_seg_ends)\n", + "\n", + " climb_options = av.HeightEnergyClimbPhaseBuilder(\n", + " 'test_climb',\n", + " user_options=av.AviaryValues({\n", + " 'initial_altitude': (alt_i_climb, 'm'),\n", + " 'final_altitude': (alt_f_climb, 'm'),\n", + " 'initial_mach': (mach_i_climb, 'unitless'),\n", + " 'final_mach': (mach_f_climb, 'unitless'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_range': (False, 'unitless'),\n", + " 'input_initial': (True, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_climb,\n", + " )\n", + "\n", + " cruise_options = av.HeightEnergyCruisePhaseBuilder(\n", + " 'test_cruise',\n", + " user_options=av.AviaryValues({\n", + " 'min_altitude': (alt_min_cruise, 'm'),\n", + " 'max_altitude': (alt_max_cruise, 'm'),\n", + " 'min_mach': (mach_min_cruise, 'unitless'),\n", + " 'max_mach': (mach_max_cruise, 'unitless'),\n", + " 'required_available_climb_rate': (300, 'ft/min'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_final': (False, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_cruise,\n", + " )\n", + "\n", + " descent_options = av.HeightEnergyDescentPhaseBuilder(\n", + " 'test_descent',\n", + " user_options=av.AviaryValues({\n", + " 'final_altitude': (alt_f_descent, 'm'),\n", + " 'initial_altitude': (alt_i_descent, 'm'),\n", + " 'initial_mach': (mach_i_descent, 'unitless'),\n", + " 'final_mach': (mach_f_descent, 'unitless'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_range': (True, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_descent,\n", + " )\n", + "\n", + " climb = climb_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + " cruise = cruise_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + " descent = descent_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + " traj = prob.model.add_subsystem('traj', dm.Trajectory())\n", + "\n", + " climb.set_time_options(\n", + " fix_initial=True, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_climb*2), duration_ref=t_duration_climb)\n", + " cruise.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_cruise*2), duration_ref=t_duration_cruise)\n", + " descent.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_descent*2), duration_ref=t_duration_descent)\n", + "\n", + " traj.add_phase('climb', climb)\n", + "\n", + " traj.add_phase('cruise', cruise)\n", + "\n", + " traj.add_phase('descent', descent)\n", + "\n", + " if use_new_dymos_syntax: # needed for print_outputs()\n", + " climb.timeseries_options['use_prefix'] = True\n", + " cruise.timeseries_options['use_prefix'] = True\n", + " descent.timeseries_options['use_prefix'] = True\n", + "\n", + " return traj\n", + "\n", + "\n", + "def link_phases(aviary_inputs, prob, traj):\n", + " # directly connect phases (strong_couple = True), or use linkage constraints (weak\n", + " # coupling / strong_couple=False)\n", + " strong_couple = False\n", + "\n", + " traj.link_phases([\"climb\", \"cruise\"], [\"time\", Dynamic.Mission.ALTITUDE,\n", + " Dynamic.Mission.VELOCITY, Dynamic.Mission.MASS, Dynamic.Mission.RANGE], connected=strong_couple)\n", + " traj.link_phases([\"cruise\", \"descent\"], [\"time\", Dynamic.Mission.ALTITUDE,\n", + " Dynamic.Mission.VELOCITY, Dynamic.Mission.MASS, Dynamic.Mission.RANGE], connected=strong_couple)\n", + "\n", + " traj = av.setup_trajectory_params(prob.model, traj, aviary_inputs)\n", + "\n", + " ##################################\n", + " # Connect in Takeoff #\n", + " ##################################\n", + "\n", + " prob.model.connect('traj.climb.states:mass',\n", + " 'takeoff_constraints.climb_start_mass', src_indices=[0])\n", + " prob.model.connect('traj.climb.states:range',\n", + " 'takeoff_constraints.climb_start_range', src_indices=[0])\n", + " prob.model.connect('traj.climb.states:velocity',\n", + " 'takeoff_constraints.climb_start_vel', src_indices=[0])\n", + " prob.model.connect('traj.climb.states:altitude',\n", + " 'takeoff_constraints.climb_start_alt', src_indices=[0])\n", + "\n", + "\n", + "def run_aviary_problem(prob, sim):\n", + " # Turn off solver printing so that the SNOPT output is readable.\n", + " prob.set_solver_print(level=0)\n", + "\n", + " dm.run_problem(prob, simulate=sim, make_plots=True, simulate_kwargs={\n", + " 'times_per_seg': 100, 'atol': 1e-9, 'rtol': 1e-9}, \n", + " solution_record_file='N3CC_full_mission.db')\n", + " prob.record(\"final\")\n", + " prob.cleanup()\n", + "\n", + "\n", + "def run_N3CC_full_mission(sim=True):\n", + " ##########################################\n", + " # Build problem #\n", + " ##########################################\n", + " prob = om.Problem(model=om.Group())\n", + " #prob.driver = driver\n", + "\n", + " traj = None\n", + "\n", + " ##########################################\n", + " # Aircraft Input Variables and Options #\n", + " ##########################################\n", + "\n", + " aviary_inputs = load_inputs()\n", + "\n", + " ##########################################\n", + " # add pre-mission systems #\n", + " ##########################################\n", + "\n", + " add_pre_mission_system(aviary_inputs, prob)\n", + "\n", + " ##########################################\n", + " # add phases #\n", + " ##########################################\n", + "\n", + " traj = add_phases(aviary_inputs, prob)\n", + "\n", + " ##########################################\n", + " # add post mission system #\n", + " ##########################################\n", + "\n", + " add_post_mission_systems(aviary_inputs, prob)\n", + "\n", + " ##########################################\n", + " # add driver #\n", + " ##########################################\n", + "\n", + " prob.driver = add_driver()\n", + "\n", + " ##########################################\n", + " # link phases #\n", + " ##########################################\n", + "\n", + " link_phases(aviary_inputs, prob, traj)\n", + "\n", + " ##########################\n", + " # Add Objective Function #\n", + " ##########################\n", + "\n", + " add_objective(prob)\n", + "\n", + " #######\n", + " # setup\n", + " #######\n", + "\n", + " setup(aviary_inputs, prob)\n", + "\n", + " ###########################################\n", + " # Intial Settings for States and Controls #\n", + " ###########################################\n", + "\n", + " set_initial_guesses(prob, traj)\n", + "\n", + " #####################\n", + " # run aviary problem\n", + " #####################\n", + "\n", + " run_aviary_problem(prob, sim)\n", + "\n", + " print_outputs(prob)\n", + "\n", + "\n", + "def add_driver():\n", + " driver = om.ScipyOptimizeDriver()\n", + " driver.options['optimizer'] = 'SLSQP'\n", + " driver.opt_settings['maxiter'] = 0\n", + " driver.opt_settings['ftol'] = 5.0e-3\n", + " driver.opt_settings['eps'] = 1e-2\n", + "\n", + " return driver\n", + "\n", + "\n", + "def print_outputs(prob):\n", + " times_climb = prob.get_val('traj.climb.timeseries.time', units='s')\n", + " altitudes_climb = prob.get_val(\n", + " 'traj.climb.timeseries.states:altitude', units='m')\n", + " masses_climb = prob.get_val('traj.climb.timeseries.states:mass', units='kg')\n", + " ranges_climb = prob.get_val('traj.climb.timeseries.states:range', units='m')\n", + " velocities_climb = prob.get_val(\n", + " 'traj.climb.timeseries.states:velocity', units='m/s')\n", + " thrusts_climb = prob.get_val('traj.climb.timeseries.thrust_net_total', units='N')\n", + " times_cruise = prob.get_val('traj.cruise.timeseries.time', units='s')\n", + " altitudes_cruise = prob.get_val(\n", + " 'traj.cruise.timeseries.states:altitude', units='m')\n", + " masses_cruise = prob.get_val('traj.cruise.timeseries.states:mass', units='kg')\n", + " ranges_cruise = prob.get_val('traj.cruise.timeseries.states:range', units='m')\n", + " velocities_cruise = prob.get_val(\n", + " 'traj.cruise.timeseries.states:velocity', units='m/s')\n", + " thrusts_cruise = prob.get_val(\n", + " 'traj.cruise.timeseries.thrust_net_total', units='N')\n", + " times_descent = prob.get_val('traj.descent.timeseries.time', units='s')\n", + " altitudes_descent = prob.get_val(\n", + " 'traj.descent.timeseries.states:altitude', units='m')\n", + " masses_descent = prob.get_val('traj.descent.timeseries.states:mass', units='kg')\n", + " ranges_descent = prob.get_val('traj.descent.timeseries.states:range', units='m')\n", + " velocities_descent = prob.get_val(\n", + " 'traj.descent.timeseries.states:velocity', units='m/s')\n", + " thrusts_descent = prob.get_val(\n", + " 'traj.descent.timeseries.thrust_net_total', units='N')\n", + "\n", + " print(\"-------------------------------\")\n", + " print(f\"times_climb: {times_climb[-1]} (s)\")\n", + " print(f\"altitudes_climb: {altitudes_climb[-1]} (m)\")\n", + " print(f\"masses_climb: {masses_climb[-1]} (kg)\")\n", + " print(f\"ranges_climb: {ranges_climb[-1]} (m)\")\n", + " print(f\"velocities_climb: {velocities_climb[-1]} (m/s)\")\n", + " print(f\"thrusts_climb: {thrusts_climb[-1]} (N)\")\n", + " print(f\"times_cruise: {times_cruise[-1]} (s)\")\n", + " print(f\"altitudes_cruise: {altitudes_cruise[-1]} (m)\")\n", + " print(f\"masses_cruise: {masses_cruise[-1]} (kg)\")\n", + " print(f\"ranges_cruise: {ranges_cruise[-1]} (m)\")\n", + " print(f\"velocities_cruise: {velocities_cruise[-1]} (m/s)\")\n", + " print(f\"thrusts_cruise: {thrusts_cruise[-1]} (N)\")\n", + " print(f\"times_descent: {times_descent[-1]} (s)\")\n", + " print(f\"altitudes_descent: {altitudes_descent[-1]} (m)\")\n", + " print(f\"masses_descent: {masses_descent[-1]} (kg)\")\n", + " print(f\"ranges_descent: {ranges_descent[-1]} (m)\")\n", + " print(f\"velocities_descent: {velocities_descent[-1]} (m/s)\")\n", + " print(f\"thrusts_descent: {thrusts_descent[-1]} (N)\")\n", + " print(\"-------------------------------\")\n", + "\n", + "\n", + "run_N3CC_full_mission(sim=False)" + ] + }, + { + "cell_type": "markdown", + "id": "2b43d293", + "metadata": {}, + "source": [ + "You see the same outputs.\n", + "\n", + "This model demonstrates the flexibility of level 3. For example, the `load_inputs` function does not load the aircraft model from a `.csv` file but from a Python file using the `get_flops_inputs()` method.\n", + "\n", + "This function not only reads Aviary and mission variables but also builds the engine. More information can be found in `aviary/models/N3CC/N3CC_data.py`.\n", + "\n", + "Note that we can read large single aisle aircraft inputs this way as well:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52550a27", + "metadata": {}, + "outputs": [], + "source": [ + "aviary_inputs = av.get_flops_inputs('LargeSingleAisle1FLOPS')\n", + "aviary_inputs = av.get_flops_inputs('LargeSingleAisle2FLOPS')\n", + "aviary_inputs = av.get_flops_inputs('LargeSingleAisle2FLOPSdw')\n", + "aviary_inputs = av.get_flops_inputs('LargeSingleAisle2FLOPSalt')" + ] + }, + { + "cell_type": "markdown", + "id": "900b97a0", + "metadata": {}, + "source": [ + "The data files are at:\n", + "```\n", + "aviary/models/large_single_aisle_1/large_single_aisle_1_FLOPS_data.py\n", + "aviary/models/large_single_aisle_2/large_single_aisle_2_FLOPS_data.py\n", + "aviary/models/large_single_aisle_2/large_single_aisle_2_detailwing_FLOPS_data.py\n", + "aviary/models/large_single_aisle_2/large_single_aisle_2_altwt_FLOPS_data.py\n", + "```\n", + "\n", + "respectively." + ] + }, + { + "cell_type": "markdown", + "id": "00c2286b", + "metadata": {}, + "source": [ + "### Discussing this example in more detail\n", + "\n", + "We move all the code blocks on taxi to `add_pre_mission_system` function because it is how it is done in `methods_for_level2.py`. Similarly, all the code blocks on landing are moved to `add_post_mission_systems` function. Be careful! Generally speaking, not all components can be moved around due to the expected order of execution." + ] + }, + { + "cell_type": "markdown", + "id": "c2452c52", + "metadata": {}, + "source": [ + "In `aviary/validation_cases/benchmark_tests` folder, there is another N3CC model `test_FLOPS_based_sizing_N3CC.py`. If we had started from that model, you would need to have an `add_design_variables` function. The last function `print_outputs` is added in our model to verify that we didn't alter the original model. It is not a level 2 function but it is a good idea to have this function anyway." + ] + }, + { + "cell_type": "markdown", + "id": "5dfdadea", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "We have shown in an example that users have total control over every aspect of the model in level 3. There is one big feature that hasn't been covered: adding external subsystems. We will move on to discuss how to run [Aviary External Subsystem](onboarding_ext_subsystem) next." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/getting_started/tools_that_aviary_uses.md b/_sources/getting_started/tools_that_aviary_uses.md new file mode 100644 index 000000000..ce1b71f9f --- /dev/null +++ b/_sources/getting_started/tools_that_aviary_uses.md @@ -0,0 +1,158 @@ +# Tools That Aviary is Built Upon + +Multiple tools are used by Aviary, including OpenMDAO, Dymos, and more. +Additionally, other existing NASA tools have been adapted and converted for use within Aviary, +including FLOPS and GASP. +This doc page details each of these tools, how they're used in Aviary, then goes into more detail about each tool. + +## How and why each tool is used + +At the base of Aviary is [**OpenMDAO**](https://openmdao.org/newdocs/versions/latest/main.html), +an open-source modeling and optimization tool written in Python. +All of Aviary is written within the OpenMDAO framework. +This means that a huge portion of the behind-the-scenes computational processing is handled +by OpenMDAO, including numerical solvers, derivative information passing, and parallel processing. +Additionally, existing tools written in OpenMDAO can easily interface with Aviary + +[**Dymos**](https://openmdao.github.io/dymos/) is an open-source tool for the design of complex +dynamic systems which is especially useful for trajectory optimization. +Dymos is written within the OpenMDAO framework and provides time integration methods, +results postprocessing, and much more to enable Aviary's coupled mission design optimization capabilities. +In addition to Aviary's models being made within the OpenMDAO framework, Aviary uses +the concepts of Dymos' phases and trajectories when constructing mission optimization problems. + +Aviary directly implements equations from earlier NASA aircraft design tools, specifically **FLOPS** and **GASP**. +Calculations from both of these tools were ported directly into Aviary across all parts of the code. +Painting in broad strokes, these tools were used to design conventional aircraft, especially at the commercial scale. + +Now, let's talk about how these tools come together in a general sense. +Here's an image roughly showing the building blocks of Aviary. + +![Aviary's toolstack](images/tool_stack.svg) + +OpenMDAO is at the foundation in this figure because the entire Aviary tool is written in this framework. +Some portions of Aviary, specifically the models (think aerodynamics, weights, propulsion, etc) +are simply OpenMDAO systems. +This is why the lighter blue box for "Aviary: models" rests atop OpenMDAO's block. +Other parts of Aviary, specifically the infrastructure that brings all the models together and performs +the time integration and trajectory optimization, is written using Dymos. +This is why the "Aviary: platform and tool" box is on top of the Aviary models and Dymos blocks. + +Equations and calculations from both FLOPS and GASP exist within Aviary, hence why those tools are shown in transparent boxes within the Aviary models block. +This is because those tools are not _directly_ used in Aviary, but rather they strongly contributed +to the calculations and models that exist within Aviary. + +## OpenMDAO + +[**OpenMDAO**](https://openmdao.org/newdocs/versions/latest/main.html) is the foundational framework for Aviary. +Developed by NASA, it's designed to enable and facilitate multidisciplinary system analysis and optimization. +One of the significant benefits of using OpenMDAO is its built-in tools to enable gradient-based optimization +of complex systems. +This means that Aviary can make use of optimization algorithms efficiently, primarily due to OpenMDAO's +handling of derivative calculation and aggregation. + +Although we say that Aviary is written using OpenMDAO, you can think of it as being written in Python in a +way that OpenMDAO understands. +The models within Aviary are written as OpenMDAO components and groups. +Using OpenMDAO provides a large number of benefits, including [advanced debugging tools](https://openmdao.org/newdocs/versions/latest/features/debugging/debugging.html), +[model visualization](https://openmdao.org/newdocs/versions/latest/features/model_visualization/main.html), +[derivative handling](https://openmdao.org/newdocs/versions/latest/features/core_features/working_with_derivatives/main.html), +and much more. + +OpenMDAO is a widely accepted and used tool within NASA and externally. +Its uses, published research, and industrial applications are too numerous to list here. +In short, OpenMDAO has been used to design aircraft, wind turbine blades, electric motors, spaceflight trajectories, composite structures, and much more. + +## Dymos + +[**Dymos**](https://openmdao.github.io/dymos/) extends the capabilities of OpenMDAO by focusing on the optimization +of dynamic systems, especially over time-based trajectories. +The challenges of designing complex systems with time-dependent performance (like aircraft trajectories or space mission profiles) +are addressed by Dymos. +It provides the ability to define phases of a mission, optimize control profiles over these phases, and ensure that the system's dynamics are correctly integrated over time. + +For Aviary, Dymos brings in the ability to perform mission design optimization. +Its integration with OpenMDAO means that Aviary can optimize both the system's design and its mission simultaneously. +Dymos handles the complexities of time-based integration, allowing Aviary to focus on defining the system dynamics and objectives. + +NASA has used Dymos in various projects, from optimizing the trajectory of space missions to ensuring +efficient electric aircraft flight profiles subject to thermal constraints. +These projects have benefited from Dymos's capabilities and Dymos has in turn grown as a more than capable tool, hence its usage in Aviary. + +## Simupy + +[**Simupy**](https://simupy.readthedocs.io/en/latest/) is a Python package for the simulation of dynamic systems. +It provides a framework for defining and solving differential equations, including the ability to handle +discontinuities and events. +As Aviary is further developed, Simupy will be available to handle the time integration of the system dynamics. +This capability is not currently fully integrated into Aviary. + +## FLOPS + +The following description has been adapted from the FLOPS User's Guide[^FLOPSMAN]. For +more detailed information, please see the documentation that accompanies FLOPS[^FLOPS]. +Not all of the features from FLOPS have been implemented in Aviary. + +The Flight Optimization System (FLOPS) is a multidisciplinary system of computer programs +for conceptual and preliminary design and evaluation of advanced aircraft concepts. It +consists of six primary modules: 1) weights, 2) aerodynamics, 3) propulsion data scaling +and interpolation, 4) mission performance, 5) takeoff and landing, and 6) program +control. + +The weights module uses statistical/empirical equations to predict the weight of each +item in a group weight statement. In addition, a more analytical wing weight estimation +capability is available for use with more complex wing planforms. + +The aerodynamics module provides drag polars for performance calculations. Alternatively, +drag polars may be input and then scaled with variations in wing area and engine +(nacelle) size. + +The propulsion data scaling and interpolation module uses an engine deck that has been +input, fills in any missing data, and uses linear or nonlinear scaling laws to scale the +engine data to the desired thrust. It then provides any propulsion data requested by the +mission performance module or the takeoff and landing module. + +The mission performance module uses the calculated weights, aerodynamics, and propulsion +system data to calculate performance based on energy considerations. Several options +exist for specifying climb, cruise, and decent segments. In addition, acceleration, turn, +refueling, payload release, and hold segments may be specified in any reasonable order. +Reserve calculations can include flight to an alternate airport and a specified hold +segment. Some support is provided for supersonic aircraft. + +The takeoff and landing module computes the all-engine takeoff field length, the balanced +field length including one-engine-out takeoff and aborted takeoff, and the landing field +length. The approach speed is also calculated, and the second segment climb gradient and +the missed approach climb gradient criteria are evaluated. Insofar as possible with the +available data, all FAR Part 25 or MIL-STD-1793 requirements are met. The module also has +the capability to generate a detailed takeoff and climbout profile for use in calculating +noise footprints. + +Through the program control module, FLOPS may be used to analyze a point design, +parametrically vary certain design variables, or optimize a configuration with respect to +these design variables (for minimum gross weight, minimum fuel burned, maximum range, or +minimum NOx emissions) using nonlinear programming techniques. Several input options are +available, including design variables for both aircraft configuration and performance. + +## GASP + +The following description has been taken from the GASP User's Guide[^GASPMAN]: + +NASA's Ames Research Center has developed the General Aviation Synthesis Program, GASP. +This computer program performs tasks generally associated with aircraft preliminary design and allows an analyst the capability of performing parametric studies in a rapid manner. +GASP was originally made to emphasize small fixed-wing aircraft employing propulsion systems varying from a single piston engine with fixed pitch propeller through twin turboprop/turbofan powered business or transport type aircraft. +It now support hybrid wing body, truss-braced wing, and other unconventional configurations. +The program may be operated from a computer terminal in either the "batch" or "interactive graphics" mode. + +The program is comprised of modules representing the various technical disciplines integrated into a computational flow which ensures that the interacting effects of design variables are continuously accounted for in the aircraft sizing procedure. +The model is a useful tool for comparing configurations, assessing aircraft performance and economics, performing tradeoff and sensitivity studies, and assessing the impact of advanced technologies on aircraft performance and economics. By utilizing the computer model the impact of various aircraft requirements and design factors may be studied in a systematic manner with benefits measured in terms of overall aircraft performance and economics. + +[^FLOPS]: Flight Optimization System (FLOPS) Software v.9 (LAR-18934-1). NASA Technology +Transfer Program. URL: https://software.nasa.gov/software/LAR-18934-1 [retrieved +September 22, 2023] + +[^FLOPSMAN]: McCullers, L., FLOPS User’s Guide, NASA Langley Research Center, Hampton, +Virginia, 2011 (available with public distribution of software). + +[^GASPMAN]: Hague, D. S. et al., GASP - General Aviation Synthesis Program, +URL: https://ntrs.nasa.gov/api/citations/19810010562/downloads/19810010562.pdf [retrieved +December 6, 2023] \ No newline at end of file diff --git a/_sources/getting_started/what_aviary_does.md b/_sources/getting_started/what_aviary_does.md new file mode 100644 index 000000000..880887397 --- /dev/null +++ b/_sources/getting_started/what_aviary_does.md @@ -0,0 +1,92 @@ +# What Aviary Does + +"Why make a new aircraft design tool?" is probably a valid question to ask. +We'll keep it short and sweet. + +Aviary is an *open-source* tool that allows users to: + +- design aircraft and optimize trajectories simultaneously +- add their own custom subsystems +- use gradient-based optimization effectively + +While there are other tools that can do some of these things, we've designed Aviary to do *all* of these things in an approachable way. +Aviary is being used in multiple NASA projects across multiple centers and we're excited to share it with the world. + +Let's discuss what Aviary does in more detail. + +```{warning} +Aviary is under active development! +If you're using it, know that we are working to update Aviary to make it more user-friendly and capable. +If you have suggestions or comments please let the Aviary team know by [submitting an issue on GitHub](https://github.com/OpenMDAO/om-Aviary/issues/new/choose). +``` + +## Core functionalities + +### Core subsystems + +The core functionalities of Aviary revolve around preliminary and conceptual-level aircraft design. +Aviary includes a suite of core subsystems that are needed for aircraft design. +These include: + +- aerodynamics +- propulsion +- mass +- geometry +- mission analysis + +For each of these subsystems, Aviary provides a few different models that can be used. +In broad strokes, these include empirical models based on historical data, tabular data from other models or experiments, and some physics-based models. + +The [Theory Guide](../theory_guide/intro) provides much more information on these subsystems. + +### Pre-mission, Mission, and Post-mission + +Aviary problems consist of three sections: pre-mission, mission, and post-mission. +The pre-mission portion is where the aircraft is sized and any necessary pre-computed values needed for the mission are generated. +The mission portion models the aircraft flight through a trajectory, evaluating the performance along the mission at "nodes" (points in time). +The post-mission portion is where the performance metrics are calculated and any postprocessing occurs. + +For more information on these sections, please see the [pre-mission and mission doc page](../user_guide/pre_mission_and_mission). + +### Custom Subsystems + +One of the main goals of Aviary is to allow users to add their own custom subsystems. +The point is to make this as easy as possible while providing enough flexibility for complicated subsystems to be added to Aviary problems. +We have already made quite a few subsystems for projects internal to NASA. +These subsystems include a hybrid-electric propulsion system using [pyCycle](https://github.com/OpenMDAO/pyCycle), an aerostructural wing model using both [TACS](https://github.com/smdogroup/tacs) and [OpenAeroStruct](https://github.com/mdolab/OpenAeroStruct/), economic models to estimate the cost of the aircraft, and many more. + +Please see the [external subsystems doc pages](../user_guide/subsystems) for more information on how to add your own subsystems. + +## Types of aircraft and missions it can design + +Aviary is designed to be flexible enough to design a variety of aircraft. +Although many of the core subsystems were written with transport aircraft in mind, these subsystems can be replaced or augmented to support other types of aircraft. +We have used Aviary to design single- and double-aisle commercial aircraft, regional jets, advanced concepts like truss-braced wings with hybrid-electric propulsion, and more. + +Aviary is also able to optimize a variety of mission types and definitions. +Users are able to freely define the mission definition, including the number of phases, which quantities are controlled by the optimizer, and more. + +The most simplistic realistic missions include takeoff, climb, cruise, descent, and landing. +Aviary can also optimize more complicated missions, including those with multiple climb phases, cruise-climbs, multiple descents, etc. +If you're only interested in a single phase, Aviary can optimize that as well; you don't always have to evaluate a full mission. + +## Benefits and limitations + +There are a bevy of benefits and a few limitations to consider when using Aviary. +We've touched on some of these already, but let's discuss them more. + +### Benefits + +- Open-source: Aviary is open-source and available on [GitHub](https://github.com/OpenMDAO/om-Aviary) +- Flexible: Aviary is intended to be flexible enough to design a variety of aircraft and missions +- Customizable: Aviary allows users to add their own subsystems to the problem +- Optimization: Aviary is designed to be used effectively with gradient-based optimization +- Python: Aviary is written in Python and uses [OpenMDAO](https://openmdao.org/) as the underlying framework + +### Limitations + +- Levels of Fidelity: Aviary is designed for preliminary and conceptual-level aircraft design, not detailed design +- Physics-based Models: Aviary does not have many physics-based models +- Computational Speed: Aviary's focus is not computational speed, as you might've guessed by it being written in Python. Instead, we hope it is more approachable and flexible than other tools. + +For other information on some of the limitations and future work related to those limitations, please see the [Planned Future Features doc page](../misc_resources/planned_future_features). diff --git a/_sources/intro.md b/_sources/intro.md new file mode 100644 index 000000000..f085b0f58 --- /dev/null +++ b/_sources/intro.md @@ -0,0 +1,63 @@ +# Aviary Documentation + +This is the landing page for all of Aviary's documentation, including a user's guide, developer's guide, and theory guide, as well as other resources. Welcome! + +## What Aviary is + +[Aviary](https://github.com/OpenMDAO/om-Aviary) is an aircraft analysis, design, and optimization tool built on top of the Python-based optimization framework [OpenMDAO](https://github.com/OpenMDAO/OpenMDAO). +Aviary provides a flexible and user-friendly optimization platform that allows the beginning aircraft modeler to build a useful model, the intermediate aircraft modeler to build an advanced model, and the advanced aircraft modeler to build any model they can imagine. + +Features of Aviary include: + +- included simple subsystem models for aerodynamics, propulsion, mass, geometry, and mission analysis +- ability to add user-defined subsystems +- gradient-based optimization capability +- analytical gradients for all included subsystems + +## How to Read These Docs + +The Aviary documentation is broken up into several sections, each of which is designed to teach a different aspect of Aviary. +Reading the entirety of the docs is highly recommended for new users, but please read through the Getting Started section at a minimum. + +You can read through the documentation in order or you can jump to the sections that interest you the most. + +```{note} +Use the interactive table of contents on the left side of the page to navigate through the documentation. +``` + +## User Guide + +The [Aviary user interface](user_guide/user_interface.md) is under development and employs a 3-tiered approach that is broken up into 3 separate levels. +The user guide walks through how to use each of these levels in detail. + +The actual finer points of aircraft design and what these input values should be set to are beyond the scope of this documentation. +We refer users to their aircraft design textbooks as well as their experienced coworkers for information in this area. +This user guide is simply designed to teach the basics of using Aviary for aircraft analysis. + +## Examples + +The Aviary code includes a [suite of built-in examples](examples/intro.md) which the Aviary team has developed to demonstrate the capability of the Aviary code. +These examples range in complexity and length from a Level 1 input file of a simple aircraft analysis including only Aviary core subsystems to a Level 3 input script where the user has added several external subsystems and manually controlled what variables are passed where. +The Aviary team recommends that the examples be used as as starting point for building your first few Aviary models until you have built up examples of your own. + +## Theory Guide + +The [theory guide](theory_guide/intro.md) details how the five core subsystems (aerodynamics, propulsion, mass, geometry, and mission analysis) work and how the integration capability combines them together. +The theory guide also gives a much deeper understanding of the equations and modeling assumptions behind Aviary. + +## Developer Guide + +This [developer guide](developer_guide/codebase_overview.md) walks through each aspect of the code from the perspective of a developer who would like to contribute code. + +The Aviary development team is housed out of NASA but welcomes code input and pull requests from the public. +We are developing a formal review process, but at the moment each code contribution will be made as a pull request and reviewed by the development team. + +## Miscellaneous Resources + +There are some features of the Aviary code which are not addressed in the above documentation. +The [miscellaneous resources](misc_resources/FAQ.md) section includes documentation on these additional features, as well as other relevant information. + +## Table of contents + +```{tableofcontents} +``` diff --git a/_sources/misc_resources/FAQ.md b/_sources/misc_resources/FAQ.md new file mode 100644 index 000000000..775860e8e --- /dev/null +++ b/_sources/misc_resources/FAQ.md @@ -0,0 +1,70 @@ +# Frequently Asked Questions + +## What are the goals and objectives of Aviary? + +Aviary is a preliminary design tool for aircraft capable of modeling traditional and novel designs. +This tool is built on top of OpenMDAO and is open-source. +The tool incorporates a number of low-fidelity subsystems and provides streamlined capability for users to integrate their own higher fidelity subsystems or subsystems of additional disciplines. + +## What are the capabilities of Aviary? + +Aviary is an open-source preliminary aircraft design, analysis, and optimization tool capable of performing low-fidelity design, analysis, and optimization of traditional and novel aircraft configurations. +This includes subsystem analysis for aerodynamics, propulsion, weights, trajectory, and geometry. +External subsystems like [NPSS](https://www.swri.org/consortia/numerical-propulsion-system-simulation-npss), [pyCycle](https://github.com/OpenMDAO/pyCycle), [OpenAeroStruct](https://github.com/mdolab/OpenAeroStruct/), [VSPAero](https://openvsp.org/wiki/doku.php?id=vspaerotutorial), [ANOPP](https://software.nasa.gov/software/LAR-19861-1), electrical modeling, etc., can be connected to Aviary for medium- and high-fidelity analysis and optimization. +External subsystems can include disciplines already in Aviary as well as disciplines outside of Aviary. +Aviary can also perform both design and off-design analyses and optimizations. + +## Why is Aviary open-source? + +Aviary is open-source to provide the largest impact possible to the aviation community and to encourage a vibrant ecosystem of students, researchers, and industry practitioners. +One of NASA's guiding mottos is "research and technology for the benefit of all." +Aviary is built and shared with this in mind. + +## What is the fidelity level of Aviary? + +Aviary by itself provides low-fidelity analysis. +For medium- and high-fidelity analysis, users need to create those models themselves and link them to Aviary. +Aviary comes with [multiple examples of external subsystems](../user_guide/using_external_subsystems.md) that can be used to create medium- and high-fidelity models. + +## Are you able to connect high-fidelity analysis to Aviary? + +Yes, either as external subsystems, or by including their outputs in tabular form for supported disciplines. + +## Are you able to connect external toolboxes to Aviary? + +Yes, an external toolbox is called an external subsystem in Aviary, and connecting these is a standard feature. + +## Can Aviary perform analysis or optimization? + +Yes, Aviary can perform either analysis or optimization, depending on what the user chooses. Both capabilities are available. +Aviary uses OpenMDAO and gradient-based methods throughout to enable efficient optimization. + +## How does Aviary perform aircraft design? + +Aviary operates in two modes: design and off-design. (The off-design mode is currently under development and primarily works with the 2-degrees-of-freedom mission analysis method.) +An Aviary problem consists of three parts: pre-mission, mission, and post-mission. +In design mode, these parts pass data back and forth, and all three are involved in designing the aircraft. +In off-design, these modes pass data back and forth, and all three are involved in analyzing and/or optimizing the off-design flight. + +## What is the difference between OpenMDAO and Aviary? + +OpenMDAO is a generic gradient-based analysis and optimization framework for any sort of system (e.g. wind turbines, aircraft, CNC machining). +Aviary uses OpenMDAO for aircraft-specific analysis and has features like data hierarchies and template missions. + +## Is Aviary verified or validated? + +Validation ensures Aviary meets end-user needs whereas verification ensures correct calculations in Aviary. +Aviary has been verified against codes like FLOPS and GASP which have been independently verified and validated. +It contains a suite of unit tests and benchmark tests for verification. +Ongoing discussions with stakeholders ensure Aviary fits their needs, with ongoing work to meet changing features and needs. + +## Who are the Aviary stakeholders? + +Stakeholders include NASA projects, industry partners, academia, and more. +They all need system-level analysis and optimization of aircraft. + +## What can Aviary offer that legacy codes cannot do and how does Aviary compare to legacy codes? + +Aviary can perform analysis and optimization on electrified aircraft, mission optimization, and integrate different discipline tools. +It offers flexibility in modeling various aircraft types, unlike previous tools limited by their equations. +Specifically, Aviary enables coupled aircraft-mission design for complex systems with arbitrarily connected subsystems in a flexible manner. It also provides analytic gradients for all core-subsystems, a feature unique from the legacy codes. diff --git a/_sources/misc_resources/comparison_to_flops.md b/_sources/misc_resources/comparison_to_flops.md new file mode 100644 index 000000000..aada86e3c --- /dev/null +++ b/_sources/misc_resources/comparison_to_flops.md @@ -0,0 +1,216 @@ +# Comparison to FLOPS + +Portions of Aviary are based on the publicly-released version of the Flight +Optimization System ([FLOPS](https://software.nasa.gov/software/LAR-18934-1)). +Many of the features are replicated directly and will produce the same results +whereas others are replicated using similar methods and will produce similar +results but not exactly the same. This section discusses the different features +of the public version of FLOPS that have been replicated in Aviary and how they +compare. Note that additional features existed in non-public versions of FLOPS, +but they are not included in this comparison. + +## Geometry + +Geometry definition in Aviary uses a combination of methods from FLOPS and GASP. +When using either (or both) of the FLOPS-based internal aerodynamics or mass +prediction methods, the geometry is defined using the same quantities used by +FLOPS. + +Since the parametric variation and optimization capabilities of FLOPS are not +implemented in the same way within Aviary (see [Optimization](#Optimization and parametric variation) +below), only the baseline values for geometric quantities are entered. + +## Mass equations + +FLOPS weights equations are replicated very closely, except that in Aviary they +calculate mass in lbm instead of weight in lbf. Currently only the transport +mass equations and alternate mass equations are fully implemented. BWB (blended wing body) mass +equations are partially implemented and there are plans to complete them in the +future. Fighter mass equations are not implemented. + +The detailed wing mass calculation in Aviary is based on the method in FLOPS, +but it was vectorized for efficiency. Note that LEAPS used a modified wing weight +method for very large numbers of wing-mounted engines; this modification is not +implemented in Aviary. + +## Aerodynamics + +Like FLOPS, Aviary allows the user to specify the aerodynamic characteristics of +an aircraft using an internal empirical analysis or table-based user input. +Aviary also allows the user to dynamically link an externally-generated aero +model. These three modes are discussed in the following sections. + +### Empirical + +The internal empirical aerodynamics calculation from FLOPS has been fully +implemented in Aviary and the user can choose to use it or another methodology +based on GASP. The FLOPS-based equations calculate only the drag polars (drag as +a function of Mach number, altitude, and lift coefficient), whereas the +GASP-based equations also calculate lift as a function of angle of attack. + +The empirical aerodynamic analysis in Aviary is based directly on the +methodology from FLOPS, but there are some differences in the numerical +libraries used. The skin-friction analysis in FLOPS uses a two-level fixed-point +iteration for a fixed number of iterations, with no check on convergence; in its +place, Aviary uses Newton's method. Because of this difference, there may be +differences in the computed skin-fraction drag due to a different level of +convergence. In addition, table lookups for all other parts of the empirical +drag methodology use a slightly different interpolation method than FLOPS. This +difference seems to have the largest effect at Mach numbers higher than the +design Mach number. The data being interpolated show a discontinuity that the +methodology captures with just a few points, so the results will be dependent on +the change in interpolation method. + +### Tabular input + +Aviary has the option to use tabular input for aerodynamics using the same +format as FLOPS (zero-lift drag is given as a function of Mach number and +altitude, while lift-dependent drag is given as a function of Mach number and +lift coefficient). Currently there is not a method for reading in +FLOPS-formatted block-style aero tables; instead the TabularAeroBuilder is used +to build an equivalent table. There are tentative plans to add the ability to +read the FLOPS-formatted aero table directly from a file. + +As with the empirical aerodynamics, the interpolation method used in Aviary may +differ from the built-in linear interpolation used by FLOPS, so interpolated +values may differ, even for the same tabular values. + +### External model + +In addition to the two previous methods for defining the aero characteristics, +Aviary also has the ability to dynamically link an external aerodynamics +analysis using the AeroBuilderBase class. This external analysis can be +implemented as a metamodel, or even as an on-the-fly analysis. The interface +between the mission analysis and aerodynamics is configurable, so in addition to +the traditional relationship between the flight condition and lift and drag, the +aerodynamics can be a function of any number of variable such as throttle +setting. This integration represents an improvement over FLOPS in the ability to +analyze aircraft with tightly-integrated aerodynamics and propulsion, or other +advanced configurations for which the aerodynamic characteristics are more +complex than for a traditional tube-and-wing configuration. + +## Propulsion + +FLOPS allows for the input of a maximum of two engine types, each with its own +engine deck, whereas in Aviary an unlimited number of engine types may be +defined. Aviary retains many of the relations used by FLOPS to scale engine mass and +performance as a function of change in target thrust. Aviary introduces the +capability to define these scaling relations on a per-engine-type basis, instead +of using the same scaling relations for all engine types. + +### Engine deck input + +Aviary uses a custom format for engine decks which is similar to FLOPS, but more +flexible than the fixed-column FLOPS format, but this means that FLOPS-formatted +engine decks cannot be used directly. Once the FLOPS engine deck is converted to +an Aviary-compatible format, however, the deck can be used to define the engine +performance in the same way. Instead of using power code to represent specific +engine throttle conditions like in FLOPS, Aviary's throttle is a continuous +engine control parameter (typically defined as a percentage of maximum net +thrust/power). + +Aviary currently does not have the ability to fill in missing data points like +FLOPS does, but generation of flight idle points through extrapolation is +handled similarly. + +In FLOPS, engine decks are interpolated linearly. Aviary allows the user to +specify the type of interpolation to use for the engine deck; one option is to +use linear interpolation, but other interpolation types are also available. If a +different method is used, the interpolated engine performance may be different +than in FLOPS, even for the exact same tabular data. + +### Dynamic engine models + +In addition to the traditional engine deck, Aviary also allows a pyCycle model +to be integrated directly into the analysis. This integration allows for the +optimization of both airframe and propulsion design variables simultaneously, +which is a capability not available in FLOPS. This direct integration can also +be combined with a more complex aerodynamics model to improve the ability to +optimize aircraft with tightly-integrated aerodynamics and propulsion. + +## Mission + +### Main mission segments + +FLOPS uses a single type of mission analysis: height-energy, with an explicit +integration scheme. When full developed, Aviary will offer this type of +analysis, as well as a variety of other mission analysis types. + +Currently there are two options for the equations of motion used: two degree of +freedom, and height-energy. The height-energy equations are the same as those +used in FLOPS, although the integration scheme is different. Prescribed mission +equations are also being planned. + +Currently, integration of the equations of motion is done using a collocation +method. Implementation of an analytic shooting method is underway. Eventually +Aviary will also offer a simple explicit integration, similar to FLOPS. The +combination of the height-energy equations with the explicit integration should +give similar results to FLOPS, but they will not be exactly the same because of +differing numerical methods used to achieve convergence. + +### Reserve mission + +Reserve mission segments can be simulated in the same manner as is done in +FLOPS. Currently this would require manually setting up additional mission +segments and linking the starting conditions. In the future this will be handled +in a more automated fashion. + +### Takeoff and landing + +Aviary includes the ability to calculate takeoff and landing field lengths using +either type of method used by FLOPS (simple, or detailed), as well as a method +based on GASP. + +The simple takeoff and landing equations from FLOPS are replicated in Aviary, +and should produce nearly identical results. + +The detailed takeoff and landing analysis methods from FLOPS are also replicated +using the same equations of motion, but instead of a built-in explicit +integration scheme like that used by FLOPS, Aviary can use any number of +integration schemes (currently, only a collocation scheme is used). Not all of +the relevant performance requirements from FAR 25 are implemented, and in the +collocation scheme they are enforced indirectly. Because the OpenMDAO +collocation scheme is very different than the FLOPS integration, it is almost +certain that there will be differences in the results, but in general the +results should be similar. Both the detailed takeoff and landing capabilities +are still works in progress, and as they are improved they will likely produce +results that are closer to those from FLOPS. + +Since the detailed takeoff and landing trajectories are built up from modular +sequences of phases, they are more flexible than the fixed sequence defined in +FLOPS and can be used to model more complex operations. For example, a +higher-fidelity aerodynamic model can be used, or rotation can be controlled +using thrust vectoring. + +Aviary also includes the ability to calculate extended takeoff and landing +profiles for use in noise analysis. This capability exists within the same set +of components as the performance calculations and merely requires extending the +performance calculation with additional trajectory segments. + +### Off-design missions + +Off-design, or economic, missions (defined in FLOPS using the $RERUN namelist) +are possible by manually setting up additional mission segments and linking the +starting conditions to the results of the design mission analysis. This process +will become more automated in the future, including the ability to assemble +payload-range diagrams. + +### Optimization and parametric variation + +Optimization of Aviary models is handled differently. FLOPS features a built-in +optimizer that allows users to optimize the model based on a hard-coded set of +output variables that can be used to build an objective function, and using a +hard-coded set of design variables. Aviary is built in the OpenMDAO framework +and models can be optimized by drawing on all of the optimization capabilities +inherent to that framework. Any input variable can be designated as a design +variable in the optimization, and any set of output variables can be used to +build a custom objective function. Almost all of Aviary's components use +analytic derivatives to greatly enhance gradient-based optimization schemes. + +## FLOPS features not included + +### Sonic boom + +FLOPS features an approximate method for calculating sonic-boom overpressures +directly underneath the flight path. This feature is not implemented in Aviary +and there are currently no plans to include it. diff --git a/_sources/misc_resources/externally_supported_subsystems.md b/_sources/misc_resources/externally_supported_subsystems.md new file mode 100644 index 000000000..e3aae8425 --- /dev/null +++ b/_sources/misc_resources/externally_supported_subsystems.md @@ -0,0 +1,4 @@ +# Externally Supported Subsystems + +Aviary supports any generic subsystem that a user adds. +We include some examples within the Aviary repo within the `aviary/examples/external_subsystems` folder. \ No newline at end of file diff --git a/_sources/misc_resources/feature_comparison.md b/_sources/misc_resources/feature_comparison.md new file mode 100644 index 000000000..8251af7a4 --- /dev/null +++ b/_sources/misc_resources/feature_comparison.md @@ -0,0 +1,5 @@ +# Feature Comparison with Legacy Codes + +```{note} +This section is under development. +``` diff --git a/_sources/misc_resources/glossary.md b/_sources/misc_resources/glossary.md new file mode 100644 index 000000000..24f939a3d --- /dev/null +++ b/_sources/misc_resources/glossary.md @@ -0,0 +1,78 @@ +# Glossary + +This is an incomplete glossary of terms that used in Aviary and this documentation. +The goal is to have this be a one-stop-shop for defining words and jargon. + +Some of these words have a particular meaning within Aviary but might mean something else outside the tool, even in a technical setting. +One example is within these docs an "optimizer" is a distinct idea from a "solver," but other resources might use those words interchangeably. + +```{glossary} + +angle of attack (AoA) + The angle between the oncoming air or relative wind and a reference line on the airplane or wing. It is a crucial parameter in determining the lift generated by a wing. + More details can be found at [NASA's Basic Aerodynamics page](https://www1.grc.nasa.gov/beginners-guide-to-aeronautics/center-of-pressure/#angle-of-attack). + +collocation integration methods + A method of integrating a set of differential equations by approximating the solution as a polynomial over each segment of the integration. + The polynomial is then integrated analytically. + The collocation methods used for trajectory optimization in Aviary are provided by Dymos. + The Dymos doc pages have [much more info on these methods](https://openmdao.github.io/dymos/getting_started/transcriptions.html). + +control + A time-varying variable that is passed from the optimizer to the model for the mission. + Controls are used to represent quantities that vary throughout the mission, such as the throttle setting or angle of attack. + +design variable + A variable that is passed from the optimizer to the model. + Usually a design variable affects a system in the pre-mission group, though mission systems can also be affected. + +[Dymos](https://openmdao.github.io/dymos/) + A Python package for solving optimal control problems. + Dymos is built on top of OpenMDAO and uses collocation integration methods to solve optimal control problems. + Aviary can use Dymos to solve the mission analysis problem. + +[external subsystem](../user_guide/using_external_subsystems.md) + A subsystem that is not included in the Aviary core subsystems. + External subsystems are added to the Aviary model by the user. + External subsystems are often used to add more complex models to the Aviary model. + +flight envelope + The limits of speed, altitude, and load factor that an aircraft can safely operate within. Understanding the flight envelope is critical for aircraft design and operation. + +mission analysis + The process of determining the trajectory of an aircraft. + This includes determining the aircraft's flight path, velocity, and acceleration as a function of time. + Points along the trajectory are called analysis points and are often referred to as "nodes" in the context of trajectory optimization. + +multidisciplinary optimization (MDO) + Using optimization methods to solve design problems that incorporate a number of disciplines. Common in systems engineering. In Aviary, MDO is a fundamental concept for integrated aircraft design. + +optimizer + A tool that is used to solve an optimization problem. + Aviary uses OpenMDAO to provide optimizers. + [Scipy's SLSQP](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize) method is included automatically. + [IPOPT](https://coin-or.github.io/Ipopt/) and [SNOPT](https://ccom.ucsd.edu/~optimizers/solvers/snopt/) can be installed by the user through [pyOptSparse](https://github.com/mdolab/pyoptsparse) and used within Aviary. + +[OpenMDAO](https://openmdao.org/newdocs/versions/latest/main.html) + A Python package for solving multidisciplinary design and optimization (MDO) problems. + Aviary is built on top of OpenMDAO. + +parameter + A variable that is passed from optimizer or user to the model. + Parameters do not vary across the mission but may be allowed to vary during the optimization process. + Examples of parameters include wing area, engine efficiency, number of passengers, etc. + +pre-mission system + A system that is run before the mission analysis. + Examples include aircraft geometry, masses of aircraft components, any pre-computed quantities needed for mission systems. + Any quantities computed within the pre-mission systems are assumed to be constant throughout the mission. + +state + A variable that is tracked during the mission analysis. + States are often used to represent the velocity or mass of the aircraft. + When using collocation integration methods, states are design variables exposed to the optimizer. + +trajectory optimization + The process of determining the optimal trajectory of an aircraft. + This includes determining the aircraft's flight path, velocity, and acceleration as a function of time. +``` diff --git a/_sources/misc_resources/planned_future_features.md b/_sources/misc_resources/planned_future_features.md new file mode 100644 index 000000000..e2660c776 --- /dev/null +++ b/_sources/misc_resources/planned_future_features.md @@ -0,0 +1,19 @@ +# Planned Future Features + +Aviary is under active development and new features are being added regularly. +The following is a non-exhaustive list of planned features that are not yet implemented. (The Aviary team reserves the right to remove features from this list if the need arises. This list is provided for informational purposes only and is not a commitment to perform work.) + +- The ability to run off-design missions to develop payload-range diagrams +- The full capabilities of FLOPS and GASP to model medium and large sized commercial aircraft, with a few exceptions that have been determined unnecessary +- The tested ability to have different types of engines on the same aircraft +- The ability to accept propeller maps for modeling propeller-driven aircraft +- A converter to convert a table of mach/altitude combinations into a phase_info file. This capability exists in the simple mission GUI, but it will be tweaked to allow for the direct input of tabular data as an alternative to the GUI +- Natively supported builders for certain high-interest external subsystem tools. Some potential tools to support are: NPSS, pyCycle, OpenVSP, VSPaero, OpenAeroStruct, etc. The Aviary team develops these builders as the need arises, and the development or lack of it for a certain tool does not indicate endorsement of the tool. +- Improved cleanliness of the code +- Improved ease-of-use for the user interface +- Improved Fortran-to-Aviary converter which requires no human intervention or checking +- Support for relevant FAA regulations governing aircraft design and operation +- Capability to fly reserve missions using the same mission analysis techniques as the main mission (right now reserve estimates are fixed values or fixed percentages of mission fuel) +- Improved model re-run capability +- Full test suite that tests the code format, including testing for docstrings on all functions and classes +- Fully tested code blocks in the documentation \ No newline at end of file diff --git a/_sources/misc_resources/resources.md b/_sources/misc_resources/resources.md new file mode 100644 index 000000000..89a836b4d --- /dev/null +++ b/_sources/misc_resources/resources.md @@ -0,0 +1,18 @@ +# Resources + +```{note} +This page is under development. +``` + +## Links to FLOPS docs + +[Here](https://software.nasa.gov/software/LAR-18934-1) is where you can read more about FLOPS. + +## Links to GASP docs + +[This is the first publication about GASP](https://ntrs.nasa.gov/api/citations/19810010562/downloads/19810010562.pdf) and there are multiple follow-on publications. +The GASP code is not publicly available, but the publications are a good resource for understanding the theory behind GASP. + +## Publications List + +As we develop and use the Aviary code we will add publications here. diff --git a/_sources/misc_resources/using_XDSM.md b/_sources/misc_resources/using_XDSM.md new file mode 100644 index 000000000..189004772 --- /dev/null +++ b/_sources/misc_resources/using_XDSM.md @@ -0,0 +1,55 @@ +# Using XDSM + +Aviary has two ways to visualize its structures. One way is the OpenMDAO [N2 Diagram](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_details/n2_details.html). Another is the [XDSM](https://mdolab-pyxdsm.readthedocs-hosted.com/) from MDO Lab. In this page, we explain how XDSM diagrams are organized in Aviary. + +## What is XDSM? + +The [Practical MDO](https://openmdao.github.io/PracticalMDO/) website has a [fantastic post on understanding XDSM diagrams](https://openmdao.github.io/PracticalMDO/Notebooks/ModelConstruction/understanding_xdsm_diagrams.html). This lesson also includes a [helpful video](https://www.youtube.com/watch?v=yutKRwIL3BA). + +## Creation of all XDSM diagrams + +All the XDSM files reside in `xdsm` directory. And all of their names end with `_xdsm.py`: + +```bash +...... +descent1_xdsm.py +descent2_xdsm.py +design_load_xdsm.py +empennage_size_xdsm.py +...... +``` + +There is a particular python file `run_all.py` in `xdsm` folder. Using `run_all.py` in your Aviary environment, you can generate all the XDSM diagrams: + +```bash +python run_all.py +``` + +If everything runs correctly, you will see a list of `.pdf` files (e.g. `accel_xdsm.pdf`) and some `sub-folders` (e.g. `accel_specs`). Those sub-folders are created for [unit testing](https://docs.python.org/3/library/unit test.html). + +## The Aviary rules + +Readers should read about basic XDSM from MDO Lab [website](https://mdolab-pyxdsm.readthedocs-hosted.com/). Besides those, Aviary has its own rules. Let's take a look at a sample XDSM diagram: + +![Sample Aviary XDSM](images/sample_aviary_xdsm.PNG) + +Let us use the above example to discuss how Aviary uses XDSMs: + +1. All XDSM diagram files end with `_xdsm.py` in `xdsm` folder. +2. Some XDSM diagrams are coupled with sub-folders with names ending with `_specs`. They correspond to related Aviary unit tests. Search keyword [assert_match_spec](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/utils/test_utils/IO_test_util.py) for a specific unit test. +3. Single components have rectangular shape (e.g. `MyComp1`). +4. Groups of components have rectangular shape with chopped corners (e.g. `MyGroup`). +5. System input on the top-left corner is shown as a group (e.g. `Group Object (Input)`). This is a special symbol for the whole diagram (which is a group). +6. The components linked to unit tests are in bold. A `_specs` folder contains the data to be validated. +7. Components with feedback variables are shown in pink red background (e.g. `MyComp2` with feedback variable `var_feedback`). In this case, components are not run only sequentially, but in a loop. Usually, a nonlinear solver is required for the coupled subsystem. +8. Conditional variables, components, and groups are grayed out (e.g. `opt_Input_value`). Sometimes, a component or a component group can be left off. They are shown using gray color indicating they are conditional. Users can configure the appropriate Python file to hide them in the diagram. +9. Array of components and groups are shown as stacks (e.g. `MyComps`). A stack of components is a set of systems that are not connected to each other. Usually they can be run in parallel. +10. "InputValues" represents a list of input variables if the user set `simplified = True` when an XDSM diagram is generated. Otherwise, a complete list of variables are shown. Sometimes this list can be too long. We give an option for users to simplify the display of input variables. +11. Variables like "aircraft:wing:\*" are lists of some variables in `Aircraft.Wing` class. We display them this way to make the XDSM diagram easy to read. Sometimes, these lists can be very long and it is impractical to show all of them. If "aircraft:wing:\*" is an input to a group, it is possible that this group has its own XDSM diagram. +12. In the source code of some of the XDSM diagrams, there are boolean variables to control the inputs/outputs of variables, components, and groups (e.g. `simplified` or `show_outputs`). Users can set them themselves and regenerate those diagrams with different appearances. The next section shows how to regenerate a single diagram instead of all. + +## Unit Testing + +All XDSM diagrams within Aviary are tested against the actual Aviary code. +This means that all of the inputs and outputs for each component and group are checked against the XDSM diagram. +If you modify Aviary, you should run the unit tests to ensure that the XDSM diagrams are still valid and update the XDSM diagrams if necessary. diff --git a/_sources/misc_resources/variable_list.ipynb b/_sources/misc_resources/variable_list.ipynb new file mode 100644 index 000000000..a86761747 --- /dev/null +++ b/_sources/misc_resources/variable_list.ipynb @@ -0,0 +1,70 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "editorial-gilbert", + "metadata": {}, + "source": [ + "# List of Aviary Variables\n", + "\n", + "Below is a table that shows the metadata for all the variables in the Aviary-core variable hierarchies. The historical variable names of these variables in FLOPS and GASP have not been reprinted but they are available in the metadata. If you would like to know the historical variable name of a specific variable you can access it with the call `print(av.CoreMetaData[]['historical_name']`.\n", + "The descriptions associated with the *Description* column of the table below are descriptions of that variable's function. Similarity, the *Option* column lists whether or not the variable is an option (a value of `True` indicates that it is an option), the *Default Value* column states the variable's default value if it has one, and the *Possible Types* column states all the data types that variable is restricted to, if there are any restrictions imposed. (Note that most variables do not have restricted types and are assumed to be numerical.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "discrete-south", + "metadata": { + "tags": [ + "remove-input", + "no-stderr" + ] + }, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import tabulate\n", + "import aviary.api as av\n", + "\n", + "titles = ['Variable Name', 'Units', 'Description', 'Option', 'Default Value', 'Possible Types']\n", + "mylist = []\n", + "for key in av.CoreMetaData.keys():\n", + " shortlist = []\n", + " shortlist.append(key)\n", + " for inner_key in av.CoreMetaData[key].keys():\n", + " if inner_key != 'historical_name':\n", + " shortlist.append(av.CoreMetaData[key][inner_key])\n", + " mylist.append(shortlist.copy())\n", + "\n", + "table = tabulate.tabulate(mylist, headers=titles, tablefmt='html')\n", + "table" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/theory_guide/aerodynamics.md b/_sources/theory_guide/aerodynamics.md new file mode 100644 index 000000000..5c8d5e524 --- /dev/null +++ b/_sources/theory_guide/aerodynamics.md @@ -0,0 +1,8 @@ +# Core Aerodynamics Subsystem + +The core aerodynamics subsystem is responsible for calculating the aerodynamic forces (lift and drag) acting on the aircraft. +Aviary can use empirically calculated aerodynamic properties or tabular data from user-provided sources. + +```{note} +This section is under further development. +``` diff --git a/_sources/theory_guide/assumptions.md b/_sources/theory_guide/assumptions.md new file mode 100644 index 000000000..c2406cf97 --- /dev/null +++ b/_sources/theory_guide/assumptions.md @@ -0,0 +1,5 @@ +# Assumptions + +```{note} +This section is under development. +``` \ No newline at end of file diff --git a/_sources/theory_guide/building_metadata_syntax.ipynb b/_sources/theory_guide/building_metadata_syntax.ipynb new file mode 100644 index 000000000..cfa972381 --- /dev/null +++ b/_sources/theory_guide/building_metadata_syntax.ipynb @@ -0,0 +1,68 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input", + "active-ipynb", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "try:\n", + " from openmdao.utils.notebook_utils import notebook_mode\n", + "except ImportError:\n", + " !python -m pip install openmdao[notebooks]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Building Metadata\n", + "\n", + "When working with Aviary models, sometimes it is necessary to extend the Aviary-core variable hierarchy or update existing metadata. The syntax for `add_meta_data` and `update_meta_data` can be found below. For a more detailed explanation of metadata please visit [this link](../user_guide/variable_metadata.md).\n", + "\n", + "```{eval-rst}\n", + ".. autofunction:: aviary.utils.develop_metadata.add_meta_data\n", + " :noindex:\n", + "\n", + ".. autofunction:: aviary.utils.develop_metadata.update_meta_data\n", + " :noindex:\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "interpreter": { + "hash": "e6c7471802ed76737b16357fb02af5587f3a4cbee5ea7658f3f9a6981469039b" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/_sources/theory_guide/geometry.md b/_sources/theory_guide/geometry.md new file mode 100644 index 000000000..78519a9f0 --- /dev/null +++ b/_sources/theory_guide/geometry.md @@ -0,0 +1,8 @@ +# Core Geometry Subsystem + +The core geometry subsystem is responsible for calculating the geometric properties of the aircraft. +This includes the wing area, wing span, fuselage length, tail properties, passenger and cargo capacity, and other geometric properties. + +```{note} +This section is under further development. +``` diff --git a/_sources/theory_guide/intro.md b/_sources/theory_guide/intro.md new file mode 100644 index 000000000..1c894a8db --- /dev/null +++ b/_sources/theory_guide/intro.md @@ -0,0 +1,39 @@ +# Overview of Aviary Functionality + +The Aviary code is in part based on two legacy NASA aircraft analysis codes, GASP (General Aviation Synthesis Program) and FLOPS (Flight Optimization System). (Note: FLOPS also had a successor named LEAPS which implemented the same equations in python instead of Fortran. References for LEAPS will be substituted where references for FLOPS are sparse.) These two codes provided the equations for the empirical weight, geometry, and aerodynamic estimating relationships in the Aviary core subsystems, as well as a few equations for the mission and propulsion subsystems. The bottom of this page has several references to theory and user's manuals for GASP and FLOPS/LEAPS. These two legacy codes were and still are widely used at NASA and beyond. However, the Aviary code far outpaces them in flexibility, model integration capability, and optimization potential. + +There are two different aspects to Aviary. The first aspect is computational: Aviary contains OpenMDAO models of several basic subsystems, and these subsystems can be combined in various fashions to build purely Aviary-based aircraft models. An example of a purely Aviary-based models is available [here](../examples/simple_mission_example). Below are the five subsystems which Aviary inherently provides. + +## Geometry +The [geometry](./geometry) calculations that Aviary provides are made up of empirical equations and the basic equations of aircraft design. The empirical estimations in these equations are based on the conventional tube-and-wing aircraft design, and are well suited to this conventional configuration. For more novel aircraft configurations the Aviary team recommends implementing an external subsystem. + +## Aerodynamics +The [aerodynamic](./aerodynamics) calculations that Aviary provides are also made up of empirical equations and are also based on the conventional tube-and-wing aircraft design. However, Aviary also provides the ability to read in tabular aerodynamic data in the form of a drag polar, lift curve, etc. + +## Propulsion +The [propulsion](./propulsion) calculations that Aviary provides require an input engine deck. Aviary does not have the inherent ability to model a gas turbine engine cycle, and relies on outside data. The propulsion subsystem has the capability to interpolate and use this data, and also includes some basic calculations and checks, but it does not actually build its own engine model. + +## Mass +The [mass](./mass) calculations that Aviary provides are similar to the geometry calculations. They use empirical equations based on the traditional tube-and-wing aircraft design, and work well for this case but break down in the case of unconventional configurations. For more novel aircraft configurations the Aviary team recommends implementing an external subsystem. + +## Mission Analysis +The [mission analysis](./mission) calculations that Aviary provides are broader in scope than the other disciplines. Aviary provides two different types of equations of motion (2DOF and height energy), and also provides two different ways to integrate these EOMs (collocation and analytic shooting). The intended capability is that either EOM can be used with either integration technique. + + +The second aspect of Aviary, instead of being computational like the first, is about subsystem integration. In addition to the capability to build purely Aviary-based aircraft models, Aviary provides the ability to build mixed-origin aircraft models, which are aircraft models consisting partially or entirely of external user-provided subsystems. In the case of a mixed-origin model, instead of just selecting existing Aviary subsystems and combining them into an aircraft model, the user also provides the Aviary code with their own subsystems (these could be pre-existing codes such as [pyCycle](https://github.com/OpenMDAO/pyCycle), or they could be new subsystems the user has built themselves). An example of a mixed-origin model is the [OpenAeroStruct example case](../examples/OAS_subsystem.md). In this example, the built-in Aviary subsystem for mass is partially replaced by external subsystems. + +### FLOPS/LEAPS References +1. [Here](https://ntrs.nasa.gov/api/citations/20190000442/downloads/20190000442.pdf) is an overview of the LEAPS code development. +2. [Here](https://ntrs.nasa.gov/api/citations/20200001143/downloads/20200001143.pdf) is an overview of performing aircraft analysis using LEAPS. +3. [Here](https://ntrs.nasa.gov/api/citations/20190000427/downloads/20190000427.pdf) is a detailed description of the mission analysis method used in LEAPS/FLOPS. +4. [Here](https://ntrs.nasa.gov/api/citations/20170005851/downloads/20170005851.pdf) is a detailed description of the aircraft weight calculating method used in LEAPS/FLOPS. +5. [Here](https://ntrs.nasa.gov/api/citations/20190000431/downloads/20190000431.pdf) is a comparison of the LEAPS/FLOPS weight calculating method to other similar weight calculating methods. + +### GASP References +1. [Here](https://ntrs.nasa.gov/api/citations/19810010562/downloads/19810010562.pdf) is documentation on the theoretical development of the main program of GASP. +2. [Here](https://ntrs.nasa.gov/api/citations/19810010563/downloads/19810010563.pdf) is documentation on the theoretical development of the aircraft geometry calculating methods in GASP. +3. [Here](https://ntrs.nasa.gov/api/citations/19810010564/downloads/19810010564.pdf) is documentation on the theoretical development of the aerodynamics calculating methods in GASP. +4. [Here](https://ntrs.nasa.gov/api/citations/19810010565/downloads/19810010565.pdf) is documentation on the theoretical development of the propulsion calculation methods in GASP. +5. [Here](https://ntrs.nasa.gov/api/citations/19810010566/downloads/19810010566.pdf) is documentation on the theoretical development of the weight calculation methods in GASP. +6. [Here](https://ntrs.nasa.gov/api/citations/19810010567/downloads/19810010567.pdf) is documentation on the theoretical development of the performance calculation methods in GASP. +7. [Here](https://ntrs.nasa.gov/api/citations/19810010568/downloads/19810010568.pdf) is documentation on the theoretical development of the economic calculation methods in GASP. (Note, the economics calculations from GASP have not yet been implemented in Aviary.) \ No newline at end of file diff --git a/_sources/theory_guide/mass.md b/_sources/theory_guide/mass.md new file mode 100644 index 000000000..91f121116 --- /dev/null +++ b/_sources/theory_guide/mass.md @@ -0,0 +1,8 @@ +# Core Mass Subsystem + +The core mass subsystem is responsible for calculating the mass properties of the aircraft. +This includes the empty weight, fuel weight, payload weight, and other mass properties. + +```{note} +This section is under further development. +``` diff --git a/_sources/theory_guide/merging_syntax.ipynb b/_sources/theory_guide/merging_syntax.ipynb new file mode 100644 index 000000000..84837c324 --- /dev/null +++ b/_sources/theory_guide/merging_syntax.ipynb @@ -0,0 +1,67 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input", + "active-ipynb", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "try:\n", + " from openmdao.utils.notebook_utils import notebook_mode\n", + "except ImportError:\n", + " !python -m pip install openmdao[notebooks]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Merging Variable Info\n", + "\n", + "When working with multiple external subsystems for Aviary, sometimes it is helpful to merge together variable hierarchies and metadata. The syntax for those merging functions can be found below. For more detailed descriptions of how to merge [metadata](../user_guide/variable_metadata.md) and [hierarchies](../user_guide/variable_hierarchy.md) visit the included links.\n", + "\n", + "```{eval-rst}\n", + " .. autofunction:: aviary.utils.merge_hierarchies.merge_hierarchies\n", + " :noindex:\n", + "\n", + " .. autofunction:: aviary.utils.merge_variable_metadata.merge_meta_data\n", + " :noindex:\n", + "```" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "interpreter": { + "hash": "e6c7471802ed76737b16357fb02af5587f3a4cbee5ea7658f3f9a6981469039b" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/_sources/theory_guide/mission.md b/_sources/theory_guide/mission.md new file mode 100644 index 000000000..c5dddccca --- /dev/null +++ b/_sources/theory_guide/mission.md @@ -0,0 +1,88 @@ +# Mission Analysis + +This page will detail all of the mission implementation and theory details for different ODEs, including HeightEnergy and 2DOF. + +## What is a mission in Aviary? + +In the simplest terms, the mission in Aviary is the trajectory that the aircraft flies. +Usually this is from takeoff to landing and includes everything in between, depending on the aircraft you're modeling. +For a commercial airliner the mission profile is generally straightforward, featuring climb, cruise, and descent phases. +For military craft or non-conventional flight profiles, these missions might also include acceleration, dash, hover, or other phases. +A "mission" can also mean a subpart of a more complete mission if you're studying a portion of the complete flight profile, e.g. focusing on the design of the climb portion of a full mission. + +Within Aviary, missions are made up of "phases". +These phases help separate different subparts of the mission into meaningful sections. +For example, you might have a climb phase, a cruise phase, and a descent phase. +If you wanted to climb first at a specific rate-of-climb, then after that climb to a specific altitude at some fixed Mach number, those would be two separate phases within the mission. +An extremely simple mission, showing its climb, cruise, and descent phases, is shown below. + +![simple mission](images/mission_simple.png) + +Breaking the mission down into phases allows us to have more control over the control schemes, constraints, and modeling options for each of the flight phases. +For example, the climb portion of the flight might feature a nonlinear optimal flight path, whereas the cruise phase is simpler because you might be flying at a constant altitude. +By having separate phases for these mission subparts, we can dedicate more care and computational resources to the more "interesting" portions of the flight. + +## Types of mission models + +There are a few different types of mission modeling methods available in Aviary. +At the heart of each mission is the "ODE" (ordinary differential equations) which include the "EOM" (equations of motion). +These EOMs describe how the aircraft moves through the air based on the forces the aircraft is experiencing. + +Here, I want to be very careful about terminology. +I'll discuss different EOMs and what they mean for the aircraft modeling assumptions. +You can use any type of EOM to model any arbitrary mission; the mission profile does not have to follow a certain shape or path. +When we discuss "mission modeling," we are more talking about the assumptions that go into how forces on the aircraft are balanced. + +In this section I'll discuss `states`, `controls`, and a few other specialized terms from trajectory modeling and optimization. +There are many resources where these definitions are discussed, but I suggest looking at the [Dymos docs](https://openmdao.github.io/dymos/getting_started/optimal_control.html) which has some very clear explanations for these terms. +Having a basic understanding of some control theory lingo will be helpful for understanding Aviary's mission formulations. + +(energy-method)= +### Energy-state approximation + +The energy-state approximation is a method of describing an aircraft's energy state based on its combined kinetic and potential energy. +This is a relatively simple EOM model for an aircraft because it does not consider the aircraft's flight path angle (using small-angle approximations), and treats the aircraft as a point mass without rotational degrees of freedom. +Instead, we only care about the aircraft's current speed and current altitude, as that is all we need to calculate its combined energy. +The aircraft is then modeled in such a way that this energy can be instantaneously transferred between the kinetic and potential realms. +This is, of course, not exactly physically accurate, but allows us to model the aircraft's mission in a less computationally expensive manner. + +Here is the equation relating altitude $h$ to energy $E$ and velocity $V$, along with the gravitational constant $g$: + +$$ + h = (E - \frac{1}{2}V^2) / g +$$ + +Through this approximation, the only state variable is the energy $E$ and $V$ can be considered a control variable. + +An excellent introduction to this type of aircraft modeling is [Rutowski's 1953 "Energy Approach to the General Aircraft Performance Problem"](https://arc.aiaa.org/doi/pdf/10.2514/8.2956). + +### Two degree-of-freedom + +The 2DOF EOM is a bit more detailed than the energy-state approximation as it considers the x-y movement of the aircraft. +This means that we need some notion of the aircraft's flight path heading and speed to obtain its change in the x- and y-directions. +The 2DOF model is easily visualized as a force balance on the aircraft, where the acceleration in any direction is calculated by the forces acting on the aircraft and its current mass. +This allows us to find the acceleration (change in velocities) in both the x- and y-directions, which we then integrate through the mission to obtain the x-y flight profile. + +The unsteady aircraft equations of motion for 2D planar flight are: + +$$ + m \dot V = T \cos \alpha - D - W \sin \gamma +$$ + +$$ + m V \dot \gamma = L + T \sin \alpha - W \cos \gamma +$$ + +$$ + \dot h = V \sin \gamma +$$ + +$$ + \dot x = V \cos \gamma +$$ + +where $L$, $D$, $T$, and $W$ are the forces of lift, drag, thrust, and weight respectively, $m$ is the mass of the aircraft, $V$ is the aircraft velocity, $\gamma$ is the flight-path angle, $h$ is the altitude, $x$ is the horizontal distance, and $\alpha$ is the angle of attack. + +The following figure shows how these forces are oriented relative to an aircraft in flight. + +![aircraft force diagram](images/aircraft_force_diagram.png) \ No newline at end of file diff --git a/_sources/theory_guide/optimization_algorithms.md b/_sources/theory_guide/optimization_algorithms.md new file mode 100644 index 000000000..2d4cc2df0 --- /dev/null +++ b/_sources/theory_guide/optimization_algorithms.md @@ -0,0 +1,38 @@ +# Optimization Algorithms + +Optimizers are what numerically solve the aircraft design problem that we pose to Aviary. +Within the context of Aviary and broader OpenMDAO, optimizers are a type of driver that repeatedly query the aircraft and trajectory models. + +When we say "optimizer", this is a distinct idea from a "solver" in the context of OpenMDAO. +A solver is a component that numerically solves a system of equations, e.g. a Newton solver or a linear solver. +An optimizer is a driver that finds the optimal values of the design variables that minimize or maximize the objective function. + +For more information on OpenMDAO optimization drivers, see the [OpenMDAO documentation](https://openmdao.org/newdocs/versions/latest/features/building_blocks/drivers/index.html). +For a basic introduction to what an optimization problem is and how it is solved, see the [Practical MDO page on "Basic optimization problem](https://openmdao.github.io/PracticalMDO/Notebooks/Optimization/basic_opt_problem_formulation.html). + +## Available Algorithms that work with Aviary + +Aviary is designed to work well with gradient-based optimizers. +This means that they require the gradient of the objective function and constraints with respect to the design variables. +Gradient-free optimizers are available through OpenMDAO and pyOptSparse, but they are not recommended for use with Aviary due to the optimization problem complexity. + +SNOPT is the recommended optimizer for use with Aviary but is not available for free commercial use. +IPOPT and SLSQP are open-source optimizers that are available for commercial use. + +### SNOPT + +[SNOPT](https://ccom.ucsd.edu/~optimizers/solvers/snopt/) is a sequential quadratic programming (SQP) algorithm that is available in OpenMDAO through [pyOptSparse](https://github.com/mdolab/pyoptsparse). +SNOPT is a commercial software package and has a high cost for commercial use but it is available for free for academic use. +For more information on SNOPT, see the [SNOPT documentation](https://web.stanford.edu/group/SOL/guides/sndoc7.pdf). + +### IPOPT + +IPOPT is an interior point optimizer that is available in OpenMDAO through [pyOptSparse](https://github.com/mdolab/pyoptsparse). +IPOPT is an open-source software package and will be installed automatically when you install pyOptSparse when using the `conda` [package manager as detailed here](https://mdolab-pyoptsparse.readthedocs-hosted.com/en/latest/install.html#conda). +For more information on IPOPT, see the [IPOPT documentation](https://coin-or.github.io/Ipopt/). + +### SLSQP + +[SLSQP](https://docs.scipy.org/doc/scipy/reference/optimize.minimize-slsqp.html) is a sequential least squares programming algorithm that is available in OpenMDAO through Scipy. +SLSQP is an open-source software package and is bundled with Scipy so it requires no additional packages. +For more information on SLSQP, see the [SLSQP documentation](https://docs.scipy.org/doc/scipy/reference/optimize.minimize-slsqp.html). \ No newline at end of file diff --git a/_sources/theory_guide/propulsion.md b/_sources/theory_guide/propulsion.md new file mode 100644 index 000000000..d9716b6a3 --- /dev/null +++ b/_sources/theory_guide/propulsion.md @@ -0,0 +1,36 @@ +# Core Propulsion Subsystem + +Propulsion is unique among the core Aviary subsystems for its level of flexibility and compatibility with custom and external code. Aviary supports an arbitrary number of engines on a vehicle which can be modeled using the built-in method (engine decks) alongside any user-provided models. + +Aviary propulsion can be thought of as having two levels: system-level propulsion and individual engines. The top-level propulsion subsystem is model-agnostic and exists to organize engines and sum relevant outputs into system-level totals that other subsystems can use. Modeling of each type of engine on the aircraft is handled with `EngineModels`. + +This page details how the core propulsion subsystem works when using `EngineDecks`. External propulsion subsystems (when wrapped by an `EngineModel`) are treated the same way by Aviary, but the details of what is computed and where will differ by model. + +## Preprocessing + +Before analysis is performed, Aviary's propulsion preprocessor function is used to ensure input consistency. These consistency checks serve two functions. +First, the inputs and options used to initialize individual `EngineModels` and the vehicle-level variable hierarchy need to match. The vehicle-level hierarchy's engine-related inputs must be vectorized to include information for all individual engines being modeled. +Second, a select number of inputs are checked for physical consistency with each other. For example, the sum of wing- and fuselage-mounted engines must match the total number of engines on the vehicle. + +Because engine-related variables are expected to be vectorized with a value for each unique `EngineModel`, if a variable is defined for one engine, it must also be defined for all others so a vector of consistent size can be created. The propulsion preprocessor handles this automatically. Values of variables defined in an `EngineModel` are given highest priority and always used if available. Otherwise, if a value for that variable is present in the vehicle-level variable hierarchy, it is treated as a 'user-provided default' value to assign to any engine that doesn't explicitly define it. Finally, if neither of these values can be found, the default value pulled from Aviary variable metadata is used. + +`EngineModels` objects have input preprocessing steps performed during initialization to handle internal consistency of inputs and options within that individual engine. + +## Pre-Mission Analysis + +Aviary propulsion organizes all pre-mission analysis into a propulsion group that is added to the 'pre_mission_analysis' group. Pre-mission propulsion calls the pre-mission builders for each provided `EngineModel`, adding each created subsystem to the propulsion group. Aviary also includes a component which calculates system-level SLS (sea-level static) thrust and another component which calculates distributed propulsion factors based on total thrust and total number of engines. These distributed factors are used by some Aviary core mass estimation components. + +The `EngineDeck` pre-mission builder includes a `EngineScaling` component that calculates a performance scaling factor based on the percent difference in desired target thrust versus the unscaled SLS thrust present in the data file. + +## Mission Analysis + +Similar to pre-mission, during mission analysis Aviary propulsion creates a group that calls the mission builder for each `EngineModel`. Engine performance data is [muxed](https://openmdao.org/newdocs/versions/latest/features/building_blocks/components/mux_comp.html) together and then summed into vehicle-level totals using an additional component. Both single engine and vehicle-level propulsion performance is promoted within the propulsion group although only vehicle-level totals are used by other Aviary core subsystems. + +`EngineDeck` mission builders produce a more complicated group that interpolates and scales performance values based on flight condition. To provide maximum thrust conditions (as needed by the [energy-state approximation](energy-method)), a duplicate set of interpolation components are created and run at max throttle setting to always produce max thrust for a given flight condition. This performance data is then scaled with an additional component. Only the scaled data is exposed to the greater propulsion group. Unscaled engine data is not promoted outside that `EngineDeck's` mission group, and is therefore generally unavailable to other Aviary components. + +## Post-Mission Analysis + +Aviary currently does not support post-mission propulsion analysis. A future update will include a propulsion-level group that iteratively calls `EngineModel` post-mission builders similar to how pre-mission is performed. + +## External Subsystems +Because the actual computation of propulsion-related variables is done within `EngineModels`, in most cases the propulsion subsystem builder does not need to be replaced when adding new propulsion analysis to Aviary. \ No newline at end of file diff --git a/_sources/theory_guide/underlying_concepts.md b/_sources/theory_guide/underlying_concepts.md new file mode 100644 index 000000000..8be9732dc --- /dev/null +++ b/_sources/theory_guide/underlying_concepts.md @@ -0,0 +1,55 @@ +# Underlying Concepts + +```{note} +Much of this doc page has not been developed yet. +``` + +## Aircraft Design Theory + +Aviary is a tool for aircraft design that is largely based on prior NASA-developed tools such as FLOPS and GASP. +Most of the underlying models and methods draw from textbook-based conceptual and preliminary design concepts. + +Aviary allows aircraft design through many different design variables, including wing, fuselage, and tail sizing, propulsion system sizing, and weight analysis. +We will not go into great detail here on the theory behind these models as later doc pages will cover these topics in more detail. + +## Mission Optimization Theory + +Mission optimization in aircraft design plays a pivotal role in enhancing the overall performance and capabilities of aircraft. +It involves the intricate balancing of numerous variables and constraints to achieve optimal flight trajectories and mission outcomes. + +Notably, mission optimization is not just about the literal path an aircraft takes, but encompasses a broader range of state histories. +These include short-term effects like battery state of charge, component temperatures, and propulsion system states. +Therefore, mission optimization necessitates a comprehensive approach that considers these dynamic aspects. + +In this context, we introduce several key terms: states, controls, design parameters, and constraints. +States refer to values tracked over time, like fuel levels or component temperatures. +Controls are values varied over time to influence the system, such as throttle settings or control surface deflections. +Design parameters, or static controls, are fixed variables like wingspan or engine size. +Constraints are system values we aim to limit at certain times, like maximum Mach speeds, altitude constraints, or battery charge constraints. + +The complexity of mission optimization increases with the flexibility required to optimize these variables. +For a robust optimization, it's crucial to consider an aircraft's performance across its entire mission trajectory. +This approach allows for the tracking of path-dependent states, thereby offering a more accurate performance evaluation. +However, this typically requires numerous model evaluations, underscoring the complexity of the task. + +Previous studies in trajectory analysis and optimization, particularly those incorporating physics-based analyses, are crucial in this field. +NASA Glenn researcher Rob Falck has published several papers on mission optimization, especially in the context of systems design and multidisciplinary design optimization. +His [2019 paper on Optimal Control within the Context of Multidisciplinary Design, Analysis, and Optimization](https://ntrs.nasa.gov/api/citations/20190002793/downloads/20190002793.pdf) is a great and digestible introduction to a lot of the mission optimization concepts contained within Aviary. +For a more specific example of mission optimization for a specific aircraft platform, his paper on [Trajectory Optimization of Electric Aircraft Subject to Subsystem Thermal Constraints](https://ntrs.nasa.gov/api/citations/20170009148/downloads/20170009148.pdf) is a great read. +Lastly, although the author of this doc page is slightly biased, [John Jasa's dissertation](https://deepblue.lib.umich.edu/bitstream/handle/2027.42/155269/johnjasa_1.pdf?sequence=1&isAllowed=y) also has a great overview of mission optimization concepts, particularly for path-dependent optimization problems. +Sections 1.2, 2.1, and 2.2 are especially relevant if you want to dig more into the history behind mission optimization and other related topics. + +Although these studies offer a foundation, it's important to acknowledge the real-world constraints and regulations that might affect aircraft operation. +These practical considerations sometimes differ from theoretical models and must be taken into account for realistic mission planning. +Aviary has some built-in constraints to account for these factors, though many FAA or FAR regulations are not necessarily considered. + +In summary, mission optimization in aircraft design is a multifaceted challenge that demands a thorough understanding of the system-to-system interactions on board an aircraft. +Aviary aims to provide a robust platform for constructing and solving coupled aircraft-mission design problems. + +## Design in Aviary + +This section is under development. + +## Design vs. Off Design + +This section is under development. diff --git a/_sources/theory_guide/validation.md b/_sources/theory_guide/validation.md new file mode 100644 index 000000000..3ab332347 --- /dev/null +++ b/_sources/theory_guide/validation.md @@ -0,0 +1,7 @@ +# Validation + +This section is under further development. + +## Comparison with Other Tools + +We will compare Aviary with tools like GASP and FLOPS. \ No newline at end of file diff --git a/_sources/user_guide/FLOPS_based_detailed_takeoff_and_landing.ipynb b/_sources/user_guide/FLOPS_based_detailed_takeoff_and_landing.ipynb new file mode 100644 index 000000000..c032c68dd --- /dev/null +++ b/_sources/user_guide/FLOPS_based_detailed_takeoff_and_landing.ipynb @@ -0,0 +1,598 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "01c83833", + "metadata": {}, + "source": [ + "# FLOPS Based Detailed Takeoff and Landing\n", + "Aviary support of FLOPS based detailed takeoff and landing is implemented in terms of\n", + "user options, initial guesses, and different types of builders. User options and initial guesses are often collected in `AviaryValues` objects, which are then used to setup different builders. Builders are used to create analysis components. The builders for takeoff and landing can be separated into three general categories: aerodynamics, phases, and trajectories. The following sections describe which builders are associated with takeoff and landing and how to generally use them.\n", + "\n", + "The following code excerpts were copied from Aviary validation data and benchmarks. For a\n", + "more complete working example, with appropriate support for drivers, see the following\n", + "files:\n", + "- [N3CC data set](https://github.com/OpenMDAO/Aviary/tree/main/aviary/models/N3CC/N3CC_data.py)\n", + "- [Balanced Field Length benchmark](https://github.com/OpenMDAO/Aviary/tree/main/aviary/validation_cases/benchmark_tests/test_FLOPS_balanced_field_length.py)\n", + "- [Detailed Landing benchmark](https://github.com/OpenMDAO/Aviary/tree/main/aviary/validation_cases/benchmark_tests/test_FLOPS_detailed_landing.py)\n", + "- [Detailed Takeoff benchmark](https://github.com/OpenMDAO/Aviary/tree/main/aviary/validation_cases/benchmark_tests/test_FLOPS_detailed_takeoff.py)\n", + "\n", + "## Takeoff\n", + "\n", + "### Aerodynamics Builder\n", + "Both takeoff and landing are designed to use the FLOPS-derived `low_speed` aerodynamics method defined in the `CoreAerodynamicsBuilder`. The builder supports several options specified in a `subsystem_options` dictionary provided to the phase builder. The most important subsystem options are the three required sequences: `angles_of_attack`, `lift_coefficients`, and `drag_coefficients`. At least two values must be specified in `angles_of_attack`. For each value in `angles_of_attack`, there must be one dependent value at the corresponding index in each of `lift_coefficients` and `drag_coefficients`.\n", + "\n", + "Once a `CoreAerodynamicsBuilder` object is created, it can be used to create a phase builder.\n", + "The phase builder will pass the aerodynamics builder down to where it is needed to\n", + "create appropriate aerodynamics analysis components. A single `CoreAerodynamicsBuilder` object\n", + "can be shared with different phase builders. Subsystem options can also often be shared by different phase builders. In most cases, values like `angles_of_attack`, `lift_coefficients`, `drag_coefficients`, and a few others are identical across all phases of takeoff/landing trajectory, even if other option values vary by phase." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5fe75e1d", + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.api import Dynamic, Mission\n", + "\n", + "import aviary.api as av\n", + "\n", + "from aviary.models.N3CC.N3CC_data import inputs\n", + "\n", + "# This builder can be used for both takeoff and landing phases\n", + "aero_builder = av.CoreAerodynamicsBuilder(\n", + " name='low_speed_aero',\n", + " code_origin=av.LegacyCode.FLOPS\n", + ")\n", + "\n", + "takeoff_subsystem_options = {'low_speed_aero': {\n", + " 'method': 'low_speed',\n", + " 'ground_altitude': 0., # units='m'\n", + " 'angles_of_attack': [\n", + " 0.0, 1.0, 2.0, 3.0, 4.0, 5.0,\n", + " 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,\n", + " 12.0, 13.0, 14.0, 15.0], # units='deg'\n", + " 'lift_coefficients': [\n", + " 0.5178, 0.6, 0.75, 0.85, 0.95, 1.05,\n", + " 1.15, 1.25, 1.35, 1.5, 1.6, 1.7,\n", + " 1.8, 1.85, 1.9, 1.95],\n", + " 'drag_coefficients': [\n", + " 0.0674, 0.065, 0.065, 0.07, 0.072, 0.076,\n", + " 0.084, 0.09, 0.10, 0.11, 0.12, 0.13,\n", + " 0.15, 0.16, 0.18, 0.20],\n", + " 'lift_coefficient_factor': 1.,\n", + " 'drag_coefficient_factor': 1.}}\n", + "\n", + "# when using spoilers, add a few more options\n", + "takeoff_spoiler_subsystem_options = {'low_speed_aero': {\n", + " **takeoff_subsystem_options['low_speed_aero'],\n", + " 'use_spoilers': True,\n", + " 'spoiler_drag_coefficient': inputs.get_val(Mission.Takeoff.SPOILER_DRAG_COEFFICIENT),\n", + " 'spoiler_lift_coefficient': inputs.get_val(Mission.Takeoff.SPOILER_LIFT_COEFFICIENT)}}\n", + "\n", + "# We also need propulsion analysis for takeoff and landing. No additional configuration\n", + "# is needed for this builder\n", + "prop_builder = av.CorePropulsionBuilder()" + ] + }, + { + "cell_type": "markdown", + "id": "294cdced", + "metadata": {}, + "source": [ + "### Phase Builders\n", + "There are eleven types of phase builders for takeoff. In general, the following phase\n", + "builders are always required:\n", + "- `TakeoffBrakeReleaseToDecisionSpeed` : a phase builder for the first phase of takeoff,\n", + " from brake release to decision speed, the maximum speed at which takeoff can be safely\n", + " brought to full stop using zero thrust while braking;\n", + "- `TakeoffDecisionSpeedToRotate` : a phase builder for the second phase of takeoff, from\n", + " decision speed to rotation;\n", + "- `TakeoffRotateToLiftoff` : a phase builder for the third phase of takeoff, from\n", + " rotation to liftoff;\n", + "- `TakeoffLiftoffToObstacle` : a phase builder for the fourth phase of takeoff, from\n", + " liftoff to clearing the required obstacle.\n", + "\n", + "The following phase builders are only required if acoustic calculations are required:\n", + "- `TakeoffObstacleToMicP2` : a phase builder for the fifth phase of takeoff, from\n", + " clearing the required obstacle to the P2 mic location;\n", + "- `TakeoffMicP2ToEngineCutback` : a phase builder for the sixth phase of takeoff, from\n", + " the P2 mic location to engine cutback;\n", + "- `TakeoffEngineCutback` : a phase builder for the seventh phase of takeoff, from start\n", + " to finish of engine cutback;\n", + "- `TakeoffEngineCutbackToMicP1` : a phase builder for the eighth phase of takeoff, from\n", + " engine cutback to the P1 mic location;\n", + "- `TakeoffMicP1ToClimb` : a phase builder for the ninth phase of takeoff, from P1 mic\n", + " location to climb.\n", + "\n", + "The following phase builders are only required if balanced field length calculations are\n", + "required:\n", + "- `TakeoffDecisionSpeedBrakeDelay` : a phase builder for the second phase of aborted\n", + " takeoff, from decision speed to brake application;\n", + "- `TakeoffBrakeToAbort` : a phase builder for the last phase of aborted takeoff, from\n", + " brake application to full stop.\n", + "\n", + "When creating any of these phase builders, the following data should first be collected\n", + "and passed to the builder during creation: subsystem builders, subsystem options, user options, and initial guesses. The subsystem builders and options are created as described in the previous\n", + "section. User options are collected in an `AviaryValues` object. Each type of phase\n", + "builder supports its own set of user options, with associated default values. Initial\n", + "guesses are collected in an `AviaryValues` object separate from the user options. Each\n", + "type of phase builder supports its own set of initial guesses; initial guesses have no\n", + "default values and are required.\n", + "\n", + "Once the required phase builders are created, they can be used to create a trajectory\n", + "builder. The trajectory builder will then use the phase builders to create phase analysis\n", + "components as required to be added to a trajectory analysis component." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad5dbc6d", + "metadata": {}, + "outputs": [], + "source": [ + "takeoff_brake_release_user_options = av.AviaryValues()\n", + "\n", + "takeoff_brake_release_user_options.set_val('max_duration', val=60.0, units='s')\n", + "takeoff_brake_release_user_options.set_val('duration_ref', val=60.0, units='s')\n", + "takeoff_brake_release_user_options.set_val('max_range', val=7500.0, units='ft')\n", + "takeoff_brake_release_user_options.set_val('max_velocity', val=167.85, units='kn')\n", + "\n", + "takeoff_brake_release_initial_guesses = av.AviaryValues()\n", + "\n", + "takeoff_brake_release_initial_guesses.set_val('times', [0., 30.], 's')\n", + "takeoff_brake_release_initial_guesses.set_val('range', [0., 4100.], 'ft')\n", + "takeoff_brake_release_initial_guesses.set_val('velocity', [0.01, 150.], 'kn')\n", + "\n", + "gross_mass_units = 'lbm'\n", + "gross_mass = inputs.get_val(Mission.Design.GROSS_MASS, gross_mass_units)\n", + "takeoff_brake_release_initial_guesses.set_val('mass', gross_mass, gross_mass_units)\n", + "\n", + "takeoff_brake_release_initial_guesses.set_val('throttle', 1.)\n", + "takeoff_brake_release_initial_guesses.set_val('angle_of_attack', 0., 'deg')\n", + "\n", + "takeoff_brake_release_builder = av.DetailedTakeoffBrakeReleaseToDecisionSpeedPhaseBuilder(\n", + " 'takeoff_brake_release',\n", + " core_subsystems=[aero_builder, prop_builder],\n", + " subsystem_options=takeoff_subsystem_options,\n", + " user_options=takeoff_brake_release_user_options,\n", + " initial_guesses=takeoff_brake_release_initial_guesses)" + ] + }, + { + "cell_type": "markdown", + "id": "38b3b96f", + "metadata": {}, + "source": [ + "### Trajectory Builder\n", + "Objects of the trajectory builder type `TakeoffTrajectory` can be used to collect the\n", + "required phases for either general takeoff analysis or balanced field length analysis.\n", + "The builder has setters for each of the following generally required phase builders:\n", + "- `set_brake_release_to_decision_speed()` : assign a phase builder, typically of type\n", + " `TakeoffBrakeReleaseToDecisionSpeed`, for the beginning of takeoff to the time when the\n", + " pilot must choose either to liftoff or halt the aircraft;\n", + "- `set_decision_speed_to_rotate()` : assign a phase builder, typically of type\n", + " `TakeoffDecisionSpeedToRotate`, for the short distance between achieving decision speed\n", + " and beginning the rotation phase;\n", + "- `set_rotate_to_liftoff()` : assign a phase builder, typically of type\n", + " `TakeoffRotateToLiftoff`, for the short distance required to rotate the aircraft to\n", + " achieve liftoff;\n", + "- `set_liftoff_to_obstacle()` : assign a phase builder, typically of type\n", + " `TakeoffLiftoffToObstacle`, for the short period between liftoff and clearing the\n", + " required obstacle.\n", + "\n", + "The builder has setters for the following phase builders, which are only required if\n", + "acoustic calculations are required:\n", + "- `set_obstacle_to_mic_p2()` : assign a phase builder, typically of type\n", + " `TakeoffObstacleToMicP2`, for the fifth phase of takeoff, from clearing the required\n", + " obstacle to the p2 mic loation;\n", + "- `set_mic_p2_to_engine_cutback()` : a phase builder, typically of type\n", + " `TakeoffMicP2ToEngineCutback`, for the sixth phase of takeoff, from the p2 mic location\n", + " to engine cutback;\n", + "- `set_engine_cutback()` : a phase builder, typically of type `TakeoffEngineCutback`, for\n", + " the seventh phase of takeoff, from start to finish of engine cutback;\n", + "- `set_engine_cutback_to_mic_p1()` : a phase builder, typically of type\n", + " `TakeoffEngineCutbackToMicP1`, for the eighth phase of takeoff, engine cutback to the\n", + " P1 mic location;\n", + "- `set_mic_p1_to_climb()` : a phase builder, typically of type `TakeoffMicP1ToClimb`, for\n", + " the ninth phase of takeoff, from P1 mic location to climb.\n", + "\n", + "The builder also has setters for the following phase builders, which are only required if\n", + "balanced field length calculations are required:\n", + "- `set_decision_speed_to_brake()` : assign a phase builder, typically of type\n", + " `TakeoffDecisionSpeedBrakeDelay`, for delayed braking when the engine fails;\n", + "- `set_brake_to_abort()` : assign a phase builder, typically of type\n", + " `TakeoffBrakeToAbort`, for braking to fullstop after engine failure.\n", + "\n", + "After all required phase builders have been assigned, the `build_trajectory()` method can\n", + "be called on the builder, which requires an `AviaryValues` object for Aviary level\n", + "analysis options, and which optionally accepts a model (an OpenMDAO `Group`) and a\n", + "trajectory. If specified, the model is used in handling trajectory parameter setup;\n", + "otherwise, trajectory parameter setup must be handled by client code. If specified, the\n", + "trajectory is updated with phase analysis components created from the phase builders;\n", + "otherwise, a new trajectory is created, updated with these components, and returned.\n", + "Calling `build_trajectory()` adds phase analysis components to the trajectory, and then\n", + "links those phases appropriately. Note, externally created trajectories can be added to\n", + "the problem model either before or after the call to `build_trajectory()`.\n", + "\n", + "Once `build_trajectory()` is called on the builder, client code can optionally retrieve\n", + "named phase analysis components from the builder with the `get_phase()` method. Client\n", + "code can then add objectives and constraints to these components to satisfy application\n", + "specific requirements.\n", + "\n", + "Before running the problem, the `apply_initial_guesses()` method should be called on the\n", + "trajectory builder with the problem and the name of the trajectory. For each created\n", + "phase, this method calls the `apply_initial_guesses()` method on the associated phase\n", + "builder. Any initial guesses not applied are returned in a dictionary, where the name of\n", + "the phase maps to the list of initial guesses not applied. Once the problem is built up\n", + "and set up, the problem can be run for trajectory analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88cfe726", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "\n", + "import dymos as dm\n", + "\n", + "import openmdao.api as om\n", + "\n", + "from aviary.models.N3CC.N3CC_data import (\n", + " takeoff_decision_speed_builder, takeoff_rotate_builder, takeoff_liftoff_builder,\n", + " takeoff_mic_p2_builder, takeoff_mic_p2_to_engine_cutback_builder,\n", + " takeoff_engine_cutback_builder, takeoff_engine_cutback_to_mic_p1_builder,\n", + " takeoff_mic_p1_to_climb_builder, takeoff_liftoff_user_options)\n", + "\n", + "\n", + "aviary_options = inputs.deepcopy()\n", + "\n", + "takeoff_trajectory_builder = av.DetailedTakeoffTrajectoryBuilder('detailed_takeoff')\n", + "\n", + "takeoff_trajectory_builder.set_brake_release_to_decision_speed(\n", + " takeoff_brake_release_builder)\n", + "\n", + "takeoff_trajectory_builder.set_decision_speed_to_rotate(takeoff_decision_speed_builder)\n", + "\n", + "takeoff_trajectory_builder.set_rotate_to_liftoff(takeoff_rotate_builder)\n", + "\n", + "takeoff_trajectory_builder.set_liftoff_to_obstacle(takeoff_liftoff_builder)\n", + "\n", + "takeoff_trajectory_builder.set_obstacle_to_mic_p2(takeoff_mic_p2_builder)\n", + "\n", + "takeoff_trajectory_builder.set_mic_p2_to_engine_cutback(\n", + " takeoff_mic_p2_to_engine_cutback_builder)\n", + "\n", + "takeoff_trajectory_builder.set_engine_cutback(takeoff_engine_cutback_builder)\n", + "\n", + "takeoff_trajectory_builder.set_engine_cutback_to_mic_p1(\n", + " takeoff_engine_cutback_to_mic_p1_builder)\n", + "\n", + "takeoff_trajectory_builder.set_mic_p1_to_climb(takeoff_mic_p1_to_climb_builder)\n", + "\n", + "takeoff = om.Problem()\n", + "\n", + "# Upstream pre-mission analysis for aero\n", + "takeoff.model.add_subsystem(\n", + " 'core_subsystems',\n", + " av.CorePreMission(\n", + " aviary_options=aviary_options,\n", + " subsystems=av.default_premission_subsystems,\n", + " ),\n", + " promotes_inputs=['*'],\n", + " promotes_outputs=['*'])\n", + "\n", + "# Instantiate the trajectory and add the phases\n", + "traj = dm.Trajectory()\n", + "takeoff.model.add_subsystem('traj', traj)\n", + "\n", + "takeoff_trajectory_builder.build_trajectory(\n", + " aviary_options=aviary_options, model=takeoff.model, traj=traj)\n", + "\n", + "max_range, units = takeoff_liftoff_user_options.get_item('max_range')\n", + "liftoff = takeoff_trajectory_builder.get_phase('takeoff_liftoff')\n", + "\n", + "liftoff.add_objective(\n", + " Dynamic.Mission.RANGE, loc='final', ref=max_range, units=units)\n", + "\n", + "# Insert a constraint for a fake decision speed, until abort is added.\n", + "takeoff.model.add_constraint(\n", + " 'traj.takeoff_brake_release.states:velocity',\n", + " equals=149.47, units='kn', ref=150.0, indices=[-1])\n", + "\n", + "takeoff.model.add_constraint(\n", + " 'traj.takeoff_decision_speed.states:velocity',\n", + " equals=155.36, units='kn', ref=159.0, indices=[-1])\n", + "\n", + "takeoff.model.add_subsystem(\n", + " 'input_sink',\n", + " av.VariablesIn(aviary_options=aviary_options),\n", + " promotes_inputs=['*'],\n", + " promotes_outputs=['*']\n", + ")\n", + " \n", + "# suppress warnings:\n", + "# \"input variable '...' promoted using '*' was already promoted using 'aircraft:*'\n", + "with warnings.catch_warnings():\n", + " # Set initial default values for all aircraft variables.\n", + " av.set_aviary_initial_values(takeoff.model, aviary_options)\n", + "\n", + " warnings.simplefilter(\"ignore\", om.PromotionWarning)\n", + " takeoff.setup(check=True)\n", + "\n", + "takeoff_trajectory_builder.apply_initial_guesses(takeoff, 'traj')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "da3a4c5d", + "metadata": {}, + "source": [ + "## Landing\n", + "\n", + "### Aerodynamics Builder\n", + "\n", + "Aerodynamics analysis is added to landing phases identically to takeoff. See the \"Aerodynamics Builder\" subsection in the \"Takeoff\" section above for a description." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf90ff9f", + "metadata": {}, + "outputs": [], + "source": [ + "landing_subsystem_options = {'low_speed_aero': {\n", + " 'method': 'low_speed',\n", + " 'ground_altitude': 0., # units='m'\n", + " 'angles_of_attack': [\n", + " 0.0, 1.0, 2.0, 3.0, 4.0, 5.0,\n", + " 6.0, 7.0, 8.0, 9.0, 10.0, 11.0,\n", + " 12.0, 13.0, 14.0, 15.0], # units='deg'\n", + " 'lift_coefficients': [\n", + " 0.7, 0.9, 1.05, 1.15, 1.25, 1.4,\n", + " 1.5, 1.60, 1.7, 1.8, 1.9, 2.0,\n", + " 2.1, 2.2, 2.3, 2.40],\n", + " 'drag_coefficients': [\n", + " 0.1, 0.1, 0.12, 0.13, 0.14, 0.15,\n", + " 0.16, 0.17, 0.18, 0.20, 0.22, 0.24,\n", + " 0.26, 0.3, 0.32, 0.34],\n", + " 'lift_coefficient_factor': 1.,\n", + " 'drag_coefficient_factor': 1.}}\n", + "\n", + "# when using spoilers, add a few more options\n", + "landing_spoiler_subsystem_options = {'low_speed_aero': {\n", + " **landing_subsystem_options['low_speed_aero'],\n", + " 'use_spoilers': True,\n", + " 'spoiler_lift_coefficient': -0.81,\n", + " 'spoiler_drag_coefficient': 0.085}}" + ] + }, + { + "cell_type": "markdown", + "id": "ead2ef44", + "metadata": {}, + "source": [ + "### Phase Builders\n", + "There are six types of phase builders for landing. In general, the following phase\n", + "builders are always required:\n", + "- `LandingObstacleToFlare` : a phase builder for moving from the start of the runway,\n", + " just above the required clearance height, to the start of a maneuver to help soften the\n", + " impact of touchdown;\n", + "- `LandingFlareToTouchdown` : a phase builder for moving through a maneuver to help\n", + " soften the impact of touchdown;\n", + "- `LandingTouchdownToNoseDown` : a phase builder for rotating the nose down after\n", + " touchdown;\n", + "- `LandingNoseDownToStop` : a phase builder for the final phase of landing, from nose\n", + " down to full stop.\n", + "\n", + "The following phase builders are only required if acoustic calculations are required:\n", + "- `LandingApproachToMicP3` : a phase builder for moving from descent to the mic location\n", + " P3;\n", + "- `LandingMicP3ToObstacle` : a phase builder for moving from the mic location P3 to the\n", + " start of the runway, just above the required clearance height.\n", + "\n", + "The general procedure for creating and using phase builders for landing is the same as\n", + "that for phase buiders for takeoff. See the \"Phase Builders\" subsection in the \"Takeoff\"\n", + "section above for a description.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ab8b519", + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.api import DetailedLandingApproachToMicP3PhaseBuilder as LandingApproachToMicP3\n", + "\n", + "\n", + "# NOTE FLOPS output is based on \"constant\" landing mass - assume reserves weight\n", + "# - currently neglecting taxi\n", + "detailed_landing_mass = 106292. # units='lbm'\n", + "\n", + "# Flops variable APRANG\n", + "apr_angle = -3.0 # deg\n", + "apr_angle_ref = abs(apr_angle)\n", + "\n", + "# From FLOPS output data.\n", + "# throttle position should be (roughly) thrust / max thrust\n", + "throttle = 7233.0 / 44000\n", + "\n", + "landing_approach_to_mic_p3_user_options = av.AviaryValues()\n", + "\n", + "landing_approach_to_mic_p3_user_options.set_val('max_duration', val=50., units='s')\n", + "landing_approach_to_mic_p3_user_options.set_val('duration_ref', val=50., units='s')\n", + "landing_approach_to_mic_p3_user_options.set_val('initial_ref', val=50.0, units='s')\n", + "landing_approach_to_mic_p3_user_options.set_val('max_range', val=10000., units='ft')\n", + "landing_approach_to_mic_p3_user_options.set_val('max_velocity', val=140., units='kn')\n", + "landing_approach_to_mic_p3_user_options.set_val('altitude_ref', val=800., units='ft')\n", + "\n", + "landing_approach_to_mic_p3_user_options.set_val(\n", + " 'lower_angle_of_attack', val=0., units='deg')\n", + "\n", + "landing_approach_to_mic_p3_user_options.set_val(\n", + " 'upper_angle_of_attack', val=12., units='deg')\n", + "\n", + "landing_approach_to_mic_p3_user_options.set_val(\n", + " 'angle_of_attack_ref', val=12., units='deg')\n", + "\n", + "landing_approach_to_mic_p3_user_options.set_val('initial_height', val=600., units='ft')\n", + "\n", + "landing_approach_to_mic_p3_initial_guesses = av.AviaryValues()\n", + "\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('times', [-42., 15.], 's')\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('range', [-4000., -2000.], 'ft')\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('velocity', 140., 'kn')\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('mass', detailed_landing_mass, 'lbm')\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('throttle', throttle)\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('altitude', [600., 394.], 'ft')\n", + "\n", + "landing_approach_to_mic_p3_initial_guesses.set_val(\n", + " Dynamic.Mission.FLIGHT_PATH_ANGLE, [apr_angle, apr_angle], 'deg')\n", + "\n", + "landing_approach_to_mic_p3_initial_guesses.set_val('angle_of_attack', 5.25, 'deg')\n", + "\n", + "landing_approach_to_mic_p3_builder = LandingApproachToMicP3(\n", + " 'landing_approach_to_mic_p3',\n", + " core_subsystems=[aero_builder, prop_builder],\n", + " subsystem_options=landing_subsystem_options,\n", + " user_options=landing_approach_to_mic_p3_user_options,\n", + " initial_guesses=landing_approach_to_mic_p3_initial_guesses)" + ] + }, + { + "cell_type": "markdown", + "id": "1042f200", + "metadata": {}, + "source": [ + "### Trajectory Builder\n", + "Objects of the trajectory builder type `LandingTrajectory` can be used to collect the\n", + "required phases for general landing analysis. The builder has setters for each of the\n", + "following generally required phase builders:\n", + "- `set_obstacle_to_flare()` : assign a phase builder, typically of type\n", + " `LandingObstacleToFlare`, for moving from the start of the runway, just above the\n", + " required clearance height, to the start of a maneuver to help soften the impact of\n", + " touchdown;\n", + "- `set_flare_to_touchdown()` : assign a phase builder, typically of type\n", + " `LandingFlareToTouchdown`, for moving through a maneuver to help soften the impact of\n", + " touchdown;\n", + "- `set_touchdown_to_nose_down()` : assign a phase builder, typically of type\n", + " `LandingTouchdownToNoseDown`, for rotating the nose down after touchdown;\n", + "- `set_nose_down_to_stop()` : assign a phase builder, typically of type\n", + " `LandingNoseDownToStop`, for the final phase of landing, from nose down to full stop.\n", + "\n", + "The builder also has setters for each of the following phase builders, which are only\n", + "required if acoustic calculations are required:\n", + "- `set_approach_to_mic_p3()` : assign a phase builder, typically of type\n", + " `LandingApproachToMicP3`, for moving from the end of descent to the mic location P3;\n", + "- `set_mic_p3_to_obstacle()` : assign a phase builder, typically of type\n", + " `LandingMicP3ToObstacle`, for moving from the mic location P3 to the start of the\n", + " runway, just above the required clearance height.\n", + "\n", + "After all required phase builders have been assigned, the general procedure for using the\n", + "`build_trajectory()`, `get_phase()`, and `apply_initial_guesses()` methods of the\n", + "trajectory builder is the same for landing as that for takeoff. See the \"Trajectory\n", + "Builder\" subsection in the \"Takeoff\" section above for a description." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2dfb836", + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.models.N3CC.N3CC_data import (\n", + " landing_mic_p3_to_obstacle_builder, landing_obstacle_builder, landing_flare_builder,\n", + " landing_touchdown_builder, landing_fullstop_builder, landing_fullstop_user_options)\n", + "\n", + "\n", + "landing_trajectory_builder = av.DetailedLandingTrajectoryBuilder('detailed_landing')\n", + "\n", + "landing_trajectory_builder.set_approach_to_mic_p3(landing_approach_to_mic_p3_builder)\n", + "\n", + "landing_trajectory_builder.set_mic_p3_to_obstacle(landing_mic_p3_to_obstacle_builder)\n", + "\n", + "landing_trajectory_builder.set_obstacle_to_flare(landing_obstacle_builder)\n", + "\n", + "landing_trajectory_builder.set_flare_to_touchdown(landing_flare_builder)\n", + "\n", + "landing_trajectory_builder.set_touchdown_to_nose_down(landing_touchdown_builder)\n", + "\n", + "landing_trajectory_builder.set_nose_down_to_stop(landing_fullstop_builder)\n", + "\n", + "landing = om.Problem()\n", + "\n", + "# Upstream pre-mission analysis for aero\n", + "landing.model.add_subsystem(\n", + " 'core_subsystems',\n", + " av.CorePreMission(\n", + " aviary_options=aviary_options,\n", + " subsystems=av.default_premission_subsystems,\n", + " ),\n", + " promotes_inputs=['*'],\n", + " promotes_outputs=['*'])\n", + "\n", + "# Instantiate the trajectory and add the phases\n", + "traj = dm.Trajectory()\n", + "landing.model.add_subsystem('traj', traj)\n", + "\n", + "landing_trajectory_builder.build_trajectory(\n", + " aviary_options=aviary_options, model=landing.model, traj=traj)\n", + "\n", + "max_range, units = landing_fullstop_user_options.get_item('max_range')\n", + "fullstop = landing_trajectory_builder.get_phase('landing_fullstop')\n", + "\n", + "fullstop.add_objective(Dynamic.Mission.RANGE, loc='final', ref=max_range, units=units)\n", + "\n", + "landing.model.add_subsystem(\n", + " 'input_sink',\n", + " av.VariablesIn(aviary_options=aviary_options),\n", + " promotes_inputs=['*'],\n", + " promotes_outputs=['*']\n", + ")\n", + "\n", + "# suppress warnings:\n", + "# \"input variable '...' promoted using '*' was already promoted using 'aircraft:*'\n", + "with warnings.catch_warnings():\n", + " # Set initial default values for all aircraft variables.\n", + " av.set_aviary_initial_values(landing.model, aviary_options)\n", + "\n", + " warnings.simplefilter(\"ignore\", om.PromotionWarning)\n", + " landing.setup(check=True)\n", + "\n", + "landing_trajectory_builder.apply_initial_guesses(landing, 'traj')\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/user_guide/UI_Levels.md b/_sources/user_guide/UI_Levels.md new file mode 100644 index 000000000..c73ba9268 --- /dev/null +++ b/_sources/user_guide/UI_Levels.md @@ -0,0 +1,86 @@ +# User Interface Levels + +The user interface for Aviary is divided into three tiers, depending on the level of control a user needs over a particular analysis. +Level 1 is the most similar to the legacy codes Aviary is derived from and requires the least amount of user interaction. +Level 3 offers users complete control over all aspects of the aircraft, mission, external subsystems, and solvers, but requires detailed knowledge of OpenMDAO. + +## Level 1 + +Level 1 serves as the starting point for users who only need basic functionality of Aviary. +It offers a straightforward and accessible approach to aircraft analysis and optimization. +Users at this level can use Aviary's expected way to define an aircraft and specify the desired mission through a csv file. +While Level 1 requires no Python coding, it incorporates methods and functionalities from Level 2 to enhance the analysis capabilities and to help ease the user's transition between levels. + +Working with Aviary at Level 1 means you access it through a command line interface (CLI) or with a call to a singular Python function. +You do not have to keep track of multi-line Python scripts when using Level 1. +Level 1 is the simplest way to use Aviary, but it is also the most limited. +This interface level uses a [text-based input file](input_files) to define aircraft and mission properties. + +## Level 2 + +Level 2 introduces users to a more flexible and customizable approach. +It allows users to have greater control over the mission definition and introduces basic Python programming for logic and changes in the analysis process. +Users at this level can leverage Aviary's abstracted methods and functionalities, which are built upon the capabilities of Level 3. +By incorporating methods from Level 3, Level 2 empowers users to define and manipulate their aircraft models more extensively. + +Level 2 is where you can integrate user-defined external subsystems, which is one of the main features of the Aviary tool. +The idea is that a user who wants to incorporate a new subsystem doesn't necessarily need to understand all the Python and OpenMDAO methods that Aviary uses, but instead only needs to create a builder class for their subsystem following an expected format. +[Other docs go into much more detail about how to create and use external subsystems within Aviary.](subsystems) + +## Level 3 + +Level 3 represents the highest level of control and customization in Aviary's user interface. +At this level, users have full access to the Python and OpenMDAO methods that Aviary calls. +They can use the complete set of Aviary's methods, functionalities, and classes to construct and fine-tune their aircraft models. +Level 3 enables users to have supreme control over every aspect of the model, including subsystems, connections, and advanced optimization techniques. + +Level 3 is the most complex but specific methods defined at this level are used in levels 1 and 2, hopefully reducing user activation energy when learning more about Aviary. +This progressive approach helps users gradually enhance their analysis capabilities and adapt to more complex modeling requirements as they gain proficiency and experience. + +## How these levels work together + +If you're a visual person, the following figure might be helpful to describe how users are expected to interface with Aviary and how that data is fed in to the tool. +This figure is only nominal; many of the details aren't included in this view. + +![the API levels feed into Aviary](images/more_levels.png) + +## Explain how to define an aircraft and mission + +Detail about the .csv and phase_info dict. + +## Capabilities + +The capabilities of each level of the interface are summarized here; users can find information about what is expected from them and what they will have control of. +Also included is an estimate of the amount of time required for someone with aircraft design experience to transition to Aviary. + +| | **Level 1** | **Level 2** | **Level 3** | +|---------------------------------------------------|:---------------------------------------:|:----------------------------------------------------------------------:|:------------------------------------------:| +| **Expected Time to Learn Aviary** | ~1 week | ~6 weeks | ~4-6 months | +| **Input File Format** | Aircraft and Mission files only (csv) | Aircraft and Mission files, possibly additional files (csv/python) | Custom input files (csv/python/OpenMDAO) | +| **Phase/ODE Customization** | Predefined Phases | Add states/controls/enhance subsystem wrapping/augment existing ODEs | Fully modify ODEs/EOMs/etc | +| **Design Variable Scaling** | Automatic only | Automatic or custom | Automatic or custom | +| **Mission Definition**
(See below for details) | Minimally-customizable missions | Add pre-defined mission phases | Add custom phases | + +## Accessible Mission Controls + +All of the controls available for level 1 can be set with command line arguments and variables in the input csv, no code necessary. +Levels 2 and 3 will require code to control the more detailed aspects of the analysis, but are also capable of using a lower level interface as a starting point. + +| **Level 1** | **Level 2** | **Level 3** | +|:--------------------------------------------:|:---------------------------------:|:----------------------:| +| Mission Type (Sizing, Fallout) | All Level 1 Controls | All Level 2 Controls | +| Integration Method (Collocation, Shooting) | Specify phase order and options | Custom ODEs and EOMs | +| Optimizer (IPOPT, SNOPT) | | | +| Mission Description (Altitude, Mach, etc) | | | + +## User Interaction with Code + +The following table describes the ways that users are able to interact with the analyses. +Users should provide the contents described, but can divide them into multiple files as appropriate. + +| **Level 1** | **Level 2** | **Level 3** | +|:-----------------------------------------------------------:|:--------------------------------------------------------------------------------:|:-----------------------------------------------------:| +| csv that defines the aircraft and minimal mission options | Python that creates an AviaryValues object that contains aircraft information | Python/OpenMDAO that creates an AviaryValues object | +| | csv files can be used to initialize this AviaryValues | Python/OpenMDAO to define mission and trajectory | +| | Python that calls run_aviary | Python/OpenMDAO to create and run a problem | +| | Optional additional files for external subsystems | Optional additional files for external subsystems | diff --git a/_sources/user_guide/aerodynamics.ipynb b/_sources/user_guide/aerodynamics.ipynb new file mode 100644 index 000000000..8cc0b5929 --- /dev/null +++ b/_sources/user_guide/aerodynamics.ipynb @@ -0,0 +1,132 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Aerodynamics Subsystem\n", + "\n", + "The built-in aerodynamics subsystem in Aviary offers multiple options for computing drag. Users can select from methods based on the FLOPS or GASP legacy codes. Choice of which legacy code's routines to use is determined by the `code_origin` option provided when initializing a `CoreAerodynamicsBuilder`. When using Aviary's [Level 1 interface](../getting_started/onboarding_level1.ipynb), the code origin for aerodynamics is automatically set to match with the mission method (height-energy is paired with FLOPS, and 2-degree-of-freedom is paired with GASP). Future updates to Aviary will allow for the user to specify aerodynamics code origin directly in the input file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.api import CoreAerodynamicsBuilder, LegacyCode\n", + "\n", + "aero_builder = CoreAerodynamicsBuilder(name='aero_example', code_origin=LegacyCode.FLOPS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both FLOPS and GASP methods have only a single option for pre-mission components, so there are no user-configurable options when calling `CoreAerodynamicsBuilder.build_pre_mission()`.\n", + "\n", + "For mission analysis, a variety of methods are available to both legacy codes, each with unique options. This can be configured per-mission segment in a `phase_info` file, with relevant aerodynamics configurations placed inside `['core_subsystems']`. The following example would instruct Aviary to send the defined options to a subsystem named 'aero_example' when building the mission, if the dictionary is properly added to `phase_info`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.api import AviaryValues\n", + "\n", + "# If you are using Aviary's interface to run analysis, this example dictionary must be\n", + "# place in phase_info, under the phase you want the arguments applied, like this:\n", + "# ([] = aerodynamic_args).\n", + "\n", + "# The aerodynamics subsystem name must match what you provide here\n", + "aerodynamic_args = {'aero_example': {'method': 'computed', 'gamma': 1.35}}\n", + "\n", + "# If you are manually building your subsystems, you can instead directly pass the\n", + "# arguments to the builder\n", + "input_variables = AviaryValues() # include your aircraft inputs here\n", + "mission_comp = aero_builder.build_mission(num_nodes=1,\n", + " aviary_inputs=input_variables,\n", + " kwargs=aerodynamic_args['aero_example'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## FLOPS Based\n", + "\n", + "The choice of using FLOPS based aerodynamics behavior is user specified per mission. Note, detailed wing weight input variables do not impact aerodynamic calculations.\n", + "\n", + "The FLOPS aerodynamics pre-mission component performs calculations to determine the design Mach and lift coefficient of the aircraft.\n", + "\n", + "\n", + "The following input variables are required for the pre-mission calculations:\n", + "- `Aircraft.Wing.MAX_CAMBER_AT_70_SEMISPAN` : Maximum camber at 70 percent semi-span, percent of local chord\n", + "- `Aircraft.Design.BASE_AREA` : Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)\n", + "- `Aircraft.Wing.AIRFOIL_TECHNOLOGY` : Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing\n", + "\n", + "\n", + "For mission analysis, FLOPS-based aerodynamics has several choices of method to determine the total lift and drag on the vehicle, listed below. The default is `computed`. If another method is desired, it should be specified in `phase_info` for each individual mission segment.\n", + "- `computed`: uses regression-based techniques to estimate lift and drag\n", + "- `low_speed`: for use in detailed takeoff analysis, and includes high-lift devices and considers angle-of-attack\n", + "- `tabular`: allows the user to substitute the lift and drag coefficient calculations in `computed` with data tables\n", + "\n", + "### Computed Aerodynamics\n", + "The FLOPS based aerodynamics subsystem uses a modified version of algorithms from the EDET (Empirical Drag Estimation Technique) program [^edet] to internally compute drag polars. FLOPS improvements to EDET as implemented in Aviary include smoothing of drag polars, more accurate Reynolds number calculations, and use of the Sommer and Short T' method [^tprime] for skin friction calculations.\n", + "\n", + "### Low Speed Aerodynamics\n", + "This aerodynamics routine is designed for use with the height-energy detailed takeoff phase, which includes use of high-lift devices. This aerodynamics method uses angle of attack, which is a special case not present in other height-energy phases.\n", + "\n", + "### User Specified Tabular Drag Polars\n", + "Third party drag polars can be specified by the user, either via a data file in [Aviary data format](./input_files.ipynb) or a NamedValues object. Two tables are required, one for lift-dependent drag, and another for zero-lift drag.\n", + "- The lift-dependent drag coefficient table must include Mach number and lift coefficient as independent variables.\n", + "- The zero-lift drag coefficient table must include altitude and Mach number as independent variables.\n", + "\n", + "Tabular aerodynamics uses Aviary's [data_interpolator_builder](../_srcdocs/packages/utils/data_interpolator_builder.md) interface. This component is unique as it requires two data tables to be provided. All configuration options, such as the choice to use a structured metamodel or training data, are applied to both tables.\n", + "\n", + "## GASP Based\n", + "### Using GASP Aerodynamics with the Height-Energy Equations of Motion (FLOPS Mission)\n", + "\n", + "You can also use GASP-based aero with the height-energy mission by using the `solved_alpha` method.\n", + "\n", + "Gasp-based drag polars have 3 inputs: altitude, mach number, and angle of attack. Since the height-energy equations of motion do not incorporate angle of attack, `solved_alpha` creates an computational group with a solver that varies the angle of attack until the interpolated lift matches the weight force on the aircraft. The format for the table in the file is the same as for GASP-based aerodynamics used with the 2-DOF mission.\n", + "\n", + "## Externally Computed Polars\n", + "\n", + "Both FLOPS and GASP methods that use data tables support the use of training data, where the values for interpolation are provided by another openMDAO component via connections. An example problem using this method can be found [here](./external_aero.ipynb).\n", + "\n", + "[^edet]: Feagin, Richard C. and Morrison, William D., Jr. \"Delta Method, An Empirical\n", + "Drag Buildup Technique.\" NASA CR-151971, December 1978.\n", + "\n", + "[^tprime]: Sommer, Simon C. and Short, Barbara J. \"Free-Flight Measurements of\n", + "Turbulent-Boundary-Layer Skin Friction in the Presence of Severe Aerodynamic Heating at\n", + "Mach Numbers from 2.8 to 7.9.\" NASA TN-3391, 1955." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aviary", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/user_guide/aviary_commands.ipynb b/_sources/user_guide/aviary_commands.ipynb new file mode 100644 index 000000000..87d179dd8 --- /dev/null +++ b/_sources/user_guide/aviary_commands.ipynb @@ -0,0 +1,199 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Command Line Tools\n", + "\n", + "Aviary has a number of command line tools that are available via the `aviary`\n", + "command.\n", + "\n", + "```{note}\n", + "When using a command line tool on a script that takes its own command line arguments, those\n", + "arguments must be placed after a `--` on the command line. Anything to the right of the\n", + "`--` will be ignored by the Aviary command line parser and passed on to the user script.\n", + "For example: `Aviary sub_command -o foo.html myscript.py -- -x --myarg=bar` would pass\n", + "`-x` and `--myarg=bar` as args to `myscript.py`.\n", + "```\n", + "\n", + "All available `aviary` sub-commands can be shown using the following command:" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "aviary -h\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "!aviary -h" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get further info on any sub-command, follow the command with a *-h*. For example:" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "aviary run_mission -h\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "!aviary run_mission -h" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Available Commands and Their Usage\n", + "\n", + "\n", + "(aviary-run_mission-command)=\n", + "### aviary run_mission\n", + "\n", + "`run_mission` is a command line interface that will run an analysis on a given csv input file.\n", + "\n", + "To use small_single_aisle_GwGm.csv run the command `aviary run_mission --mission_method GASP --mass_origin GASP models/small_single_aisle/small_single_aisle_GwGm.csv`
\n", + "\n", + "SNOPT is the default optimizer, but IPOPT is available as well." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "aviary run_mission -h\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "!aviary run_mission -h" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(aviary-fortran_to_aviary-command)=\n", + "### aviary fortran_to_aviary\n", + "\n", + "The `aviary fortran_to_aviary` command will convert a Fortran input deck to an Aviary csv.\n", + "\n", + "The only required input is the filepath to the input deck.\n", + "Optionally, a deck of default values can be specified, this is useful if an input deck assumes certain values for any unspecified variables.\n", + "If an invalid filepath is given, pre-packaged resources will be checked for input decks with a matching name.\n", + "\n", + "Notes for input decks:\n", + "- FLOPS, GASP, or Aviary names can be used for variables (Ex WG or Mission:Design:GROSS_MASS)\n", + "- When specifying variables from FORTRAN, they should be in the appropriate NAMELIST.\n", + "- Aviary variable names should be specified outside any NAMELISTS.\n", + "- Names are not case-sensitive.\n", + "- Units can be specified using any of the openMDAO valid units.\n", + "- Comments can be added using !\n", + "- Lists can be entered by separating values with commas.\n", + "- Individual list elements can be specified by adding an index after the variable name.\n", + "- (NOTE: 1 indexing is used inside NAMELISTS, while 0 indexing is used outside NAMELISTS)\n", + "\n", + "Example inputs:\n", + "```\n", + "aircraft:fuselage:pressure_differential = .5, atm !DELP in GASP, but using atmospheres instead of psi\n", + "ARNGE(1) = 3600 !target range in nautical miles\n", + "pyc_phases = taxi, groundroll, rotation, landing\n", + "debug_mode = True\n", + "```\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "aviary fortran_to_aviary -h\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "!aviary fortran_to_aviary -h" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/_sources/user_guide/battery_subsystem_example.ipynb b/_sources/user_guide/battery_subsystem_example.ipynb new file mode 100644 index 000000000..8b4732435 --- /dev/null +++ b/_sources/user_guide/battery_subsystem_example.ipynb @@ -0,0 +1,503 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# In-depth look at the battery subsystem as an example\n", + "\n", + "## Examining the battery as an example case\n", + "\n", + "Let's take a look at how to integrate an external subsystem into Aviary using the example of a battery model.\n", + "This battery model and builder are provided in the `aviary/examples/external_subsystems` folder.\n", + "\n", + "We'll show you how to define the builder object, how to specify the pre-mission and mission models, and how to implement the interface methods.\n", + "In each of these methods, we've removed the initial docstring to increase readability on this page.\n", + "The [`battery_builder.py`](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/examples/external_subsystems/battery/battery_builder.py) file contains the original methods and docstrings.\n", + "Please see that file if you want to examine this example builder in its entirety as one file.\n", + "\n", + "You can define these methods in any order you want within your subsystem builder and Aviary will use them at the appropriate times during analysis and optimization.\n", + "All of these methods must be defined by the subsystem builder creator, if that's you or one of your collaborators.\n", + "\n", + "This battery example is just that -- a singular example of the types of external subsystems that Aviary can include.\n", + "We don't expect the full complexity of all disciplines' systems to be reflected in this example, so please keep that in mind when viewing these example methods." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the builder object\n", + "\n", + "The first step is to define a builder object for your external subsystem.\n", + "This class extends the `SubsystemBuilderBase` class and provides implementations for all of the interface methods that Aviary requires.\n", + "\n", + "```{note}\n", + "Throughout this doc page we add methods to the builder class in different sections.\n", + "This is just for readability on this page and you could easily define all of these methods in one place in your builder class.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "from aviary.examples.external_subsystems.battery.model.battery_premission import BatteryPreMission\n", + "from aviary.examples.external_subsystems.battery.model.battery_mission import BatteryMission\n", + "from aviary.examples.external_subsystems.battery.battery_variables import Aircraft, Mission\n", + "from aviary.examples.external_subsystems.battery.battery_variable_meta_data import ExtendedMetaData\n", + "\n", + "\n", + "class BatteryBuilder(av.SubsystemBuilderBase):\n", + " def __init__(self, name='battery', include_constraints=True):\n", + " self.include_constraints = include_constraints\n", + " super().__init__(name, meta_data=ExtendedMetaData)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the variables of interest: states, controls, constraints, etc\n", + "\n", + "First, we'll cover how to tell Aviary which variables are states that you want to integrate throughout the mission.\n", + "The battery subsystem has two states: SOC (state of charge) and Thevenin voltage.\n", + "Both of these states are described below using their variable hierarchy name, then a dictionary that tells Aviary any arguments that are passed to the Dymos `add_state` command.\n", + "You can use any arguments that the `add_state` command accepts here, including `ref`s, `bound`s, `solve_segments`, and more.\n", + "Please see the [Dymos docs for states](https://openmdao.github.io/dymos/features/phases/variables.html#states) for a table of all the available input args." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def get_states(self):\n", + " states_dict = {\n", + " Mission.Battery.STATE_OF_CHARGE: {\n", + " 'rate_source': Mission.Battery.STATE_OF_CHARGE_RATE,\n", + " 'fix_initial': True,\n", + " },\n", + " Mission.Battery.VOLTAGE_THEVENIN: {\n", + " 'units': 'V',\n", + " 'rate_source': Mission.Battery.VOLTAGE_THEVENIN_RATE,\n", + " 'defect_ref': 1.e5,\n", + " 'ref': 1.e5,\n", + " },\n", + " }\n", + "\n", + " return states_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have similar methods for each of constraints, parameters, and design variables.\n", + "\n", + "For the constraints, you provide the name of the variable you want to constrain as the key in a dictionary.\n", + "Then the values for each one of these keys is a dictionary of kwargs that can be passed to the [Dymos `add_constraint()` method](https://openmdao.github.io/dymos/features/phases/constraints.html#constraints).\n", + "The example for the battery shows that we have a final boundary constraint on the state of charge being above 0.2 as well as a path constraint on the Thevenin voltage.\n", + "\n", + "```{note}\n", + "The constraint dicts used in Aviary require one additional kwarg on top of those needed by Dymos: the `type` argument. You must specify your constraint as either a `boundary` or `path` constraint.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def get_constraints(self):\n", + " if self.include_constraints:\n", + " constraints = {\n", + " Mission.Battery.STATE_OF_CHARGE: {\n", + " 'lower': 0.2,\n", + " 'type': 'boundary',\n", + " 'loc': 'final',\n", + " },\n", + " Mission.Battery.VOLTAGE_THEVENIN: {\n", + " 'lower': 0,\n", + " 'type': 'path',\n", + " },\n", + " }\n", + " else:\n", + " constraints = {}\n", + "\n", + " return constraints" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next up we have any parameters added to the phase from the external subsystem.\n", + "[Parameters in the Dymos sense](https://openmdao.github.io/dymos/features/phases/variables.html#parameters) are non-time-varying inputs since they typically involve fixed-value variables within a phase which define a system.\n", + "These are fixed across a phase or trajectory, but can be controlled by the optimizer.\n", + "For the simple battery case here we're setting the operating temperature of the battery to be fixed at a certain value." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def get_parameters(self):\n", + " parameters_dict = {\n", + " Mission.Battery.TEMPERATURE: {'val': 25.0, 'units': 'degC'},\n", + " Mission.Battery.CURRENT: {'val': 3.25, 'units': 'A'}\n", + " }\n", + "\n", + " return parameters_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to add high-level design variables to your external subsystem that are not exposed at the phase level, you can do so by creating a method that describes your desired design variables.\n", + "This method is called `get_design_vars`.\n", + "There might be calculations at the pre-mission level that necessitate using this method to allow the optimizer to control high-level sizing variables.\n", + "In the simple battery case, we allow the optimizer to control the energy capacity of the battery, effectively sizing it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def get_design_vars(self):\n", + " DVs = {\n", + " Aircraft.Battery.Cell.DISCHARGE_RATE: {\n", + " 'units': 'A',\n", + " 'lower': 0.0,\n", + " 'upper': 1.0,\n", + " },\n", + " }\n", + "\n", + " return DVs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining the OpenMDAO systems needed\n", + "\n", + "Next up, we have the two methods for getting the mission and pre-mission models, `get_mission` and `get_pre_mission`, respectively.\n", + "When you define these methods they should return OpenMDAO Systems ([groups](https://openmdao.org/newdocs/versions/latest/_srcdocs/packages/core/group.html) or [components](https://openmdao.org/newdocs/versions/latest/_srcdocs/packages/core/component.html)) that represent the mission and pre-mission subsystems of the external model.\n", + "Please see the [OpenMDAO docs on creating a simple component](https://openmdao.org/newdocs/versions/latest/basic_user_guide/single_disciplinary_optimization/first_analysis.html) for more information on how to create OpenMDAO systems.\n", + "In short, an OpenMDAO System takes in input variables, does some calculations, and returns output variables.\n", + "If you have an analysis or design code, you can wrap it in an OpenMDAO System even if it's not Python-based; [this doc page](https://openmdao.org/newdocs/versions/latest/other_useful_docs/file_wrap.html) goes into more detail about that. \n", + "\n", + "In the case of the battery model, the pre-mission System is very simple -- it's just a single component with no special setup or arguments.\n", + "As such, the method definition looks like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def build_pre_mission(self, aviary_inputs):\n", + " return BatteryPreMission()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's pretty straightforward.\n", + "The `build_pre_mission` method requires the `aviary_inputs` object (an instantiation of an `AviaryValues` object).\n", + "This battery example does not use any information from `aviary_inputs`.\n", + "The pre-mission builder can then use the data and options within the `aviary_inputs` object to construct the OpenMDAO System using user-specified logic.\n", + "\n", + "Now we'll discuss arguably the most important method needed when making external subsystems (though they're all important): `build_mission`.\n", + "This method returns an OpenMDAO System that provides all computations needed during the mission.\n", + "This includes computing state rates so that the mission integration code can compute the state values and obtain the corresponding performance of the aircraft.\n", + "\n", + "For the battery case, we have a nicely packaged `BatteryMission` System, so our method looks like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def build_mission(self, num_nodes, aviary_inputs):\n", + " return BatteryMission(num_nodes=num_nodes, aviary_inputs=aviary_inputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `build_mission` requires both `num_nodes` and `aviary_inputs` as arguments.\n", + "`num_nodes` is needed to correctly set up all the vectors within your mission subsystem, whereas `aviary_inputs` helps provide necessary options for the subsystem." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining helper methods, like preprocessing, initial guessing, and linking\n", + "\n", + "Next up we have some helper methods that allow us to preprocess the user-provided inputs, link different phases' variables, and provide initial guesses.\n", + "\n", + "Let's talk about preprocessing your inputs.\n", + "You might want to have some logic that sets different values in your problem based on user-provided options.\n", + "`preprocess_inputs` allows you to do this.\n", + "It occurs between `load_inputs` and `build_pre_mission` in the Aviary stack, so after the initial data inputs are loaded but before they're used to instantiate any OpenMDAO models.\n", + "This is a great place to set any values you need for variables within your subsystem.\n", + "\n", + "```{note}\n", + "For both users and developers: `preprocess_inputs` happens **once** per analysis or optimization run, just like loading the inputs. It does not occur as part of an OpenMDAO system, so it does not get iterated over during the optimization process.\n", + "```\n", + "\n", + "You can have calculations or checks you need in this method based on user inputs.\n", + "\n", + "Now you may want to link some variables between phases.\n", + "States, for example, are usually great candidates for linking.\n", + "In the case of the battery example, if we have a climb and then a cruise phase, we'd want to connect the state-of-charge and voltage states so the end of climb is equal to the beginning of cruise.\n", + "Thus, our `get_linked_variables` method looks like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def get_linked_variables(self):\n", + " '''\n", + " Return the list of linked variables for the battery subsystem; in this case\n", + " it's our two state variables.\n", + " '''\n", + " return [Mission.Battery.VOLTAGE_THEVENIN, Mission.Battery.STATE_OF_CHARGE]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last method we'll discuss here is `get_initial_guesses`.\n", + "This method allows you to return info for any variable you want to provide an initial guess for.\n", + "Depending on the integration method you're using, initial guesses may greatly help convergence of your optimization problem.\n", + "Collocation methods especially benefit from good initial guesses.\n", + "\n", + "For this battery example we simply define some initial guesses for the state variables.\n", + "If we wanted to give other initial guesses we could specify their `type` in the dictionary accordingly.\n", + "These values apply to all nodes across the mission, e.g. each node gets the same value guess. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def get_initial_guesses(self):\n", + " initial_guess_dict = {\n", + " Mission.Battery.STATE_OF_CHARGE: {\n", + " 'val': 1.0,\n", + " 'type': 'state',\n", + " },\n", + " Mission.Battery.VOLTAGE_THEVENIN: {\n", + " 'val': 5.0,\n", + " 'units': 'V',\n", + " 'type': 'state',\n", + " },\n", + " }\n", + "\n", + " return initial_guess_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extending the variable hierarchy\n", + "\n", + "You might've noticed throughout this battery example that we've extended the core variable hierarchy included in Aviary to add variables needed for the battery system.\n", + "To handle additional variables not already defined in Aviary, you can define an extension to the available variables.\n", + "By following the same naming convention present through Aviary, specifically that variables start with `aircraft` and `mission`, these can be correctly handled by the Aviary tool.\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing your implementation\n", + "\n", + "Once you have written your external subsystem code and built your own subsystem class, you can test your implementation using a built-in tool.\n", + "We provide a set of unit tests that accept a user-defined subsystem and check that the outputs from the methods match what Aviary expects.\n", + "If the user-defined methods do not return the correct form of the data, the test raises appropriate exceptions and explains which arguments are missing.\n", + "\n", + "By running these tests on their own subsystem, users can ensure that their code meets the requirements and standards set by the aviary package.\n", + "Specifically, the tests can help users check that their subsystem's inputs and outputs are correct and consistent with the expected format, even before running an Aviary mission.\n", + "\n", + "This test works by inheriting from a base class that loops through each of the methods and tests the outputs.\n", + "All you'd have to do is provide your builder object as well as the `aviary_inputs` object needed to for the methods in the builder object.\n", + "\n", + "Here's an example of the full code that you would write to test the battery builder.\n", + "Although there are no unit tests explicitly shown in this file, they are contained in the `TestSubsystemBuilderBase` class, so you only need these few lines to test your subsystem." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import unittest\n", + "\n", + "\n", + "class TestBattery(av.TestSubsystemBuilderBase):\n", + "\n", + " def setUp(self):\n", + " self.subsystem_builder = BatteryBuilder()\n", + " self.aviary_values = av.AviaryValues()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For instance, if you saved this class in a file called `test_battery.py`, you could then run `testflo test_battery.py` to verify that all the methods do what Aviary expects.\n", + "If everything is good with your model you'll see output in your terminal like this:\n", + "\n", + "```bash\n", + "(dev) $ testflo test_battery.py\n", + "......................................\n", + "\n", + "OK\n", + "\n", + "Passed: 40\n", + "Failed: 0\n", + "Skipped: 0\n", + "\n", + "\n", + "Ran 40 tests using 192 processes\n", + "Wall clock time: 00:00:15.20\n", + "```\n", + "\n", + "If you just want to run the code in this notebook, you can run the following:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "unittest.main(argv=[''], verbosity=2, exit=False)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If something's wrong with your builder, this test should tell you which method is out of spec and how you can fix it.\n", + "For example, here I've purposefully made the battery builder have some incorrect behavior and reran the test." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class BatteryBuilder(BatteryBuilder):\n", + " def get_constraints(self):\n", + " if self.include_constraints:\n", + " constraints = {\n", + " Mission.Battery.STATE_OF_CHARGE: {\n", + " 'lower': 0.2,\n", + " 'loc': 'final',\n", + " },\n", + " Mission.Battery.VOLTAGE_THEVENIN: {\n", + " 'lower': 0,\n", + " 'type': 'path',\n", + " },\n", + " }\n", + " else:\n", + " constraints = {}\n", + "\n", + " return constraints\n", + " \n", + "class BatteryBuilder(BatteryBuilder):\n", + " def get_states(self):\n", + " states_dict = {\n", + " Mission.Battery.STATE_OF_CHARGE: {\n", + " 'rate_source': Mission.Battery.STATE_OF_CHARGE_RATE,\n", + " 'fix_initial': True,\n", + " },\n", + " 'amps' : 6,\n", + " }\n", + "\n", + " return states_dict\n", + " \n", + "class TestBattery(av.TestSubsystemBuilderBase):\n", + "\n", + " def setUp(self):\n", + " self.subsystem_builder = BatteryBuilder()\n", + " self.aviary_values = av.AviaryValues()\n", + "\n", + "unittest.main(argv=[''], exit=False)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The output is a bit verbose, but tells you which methods are incorrect and why.\n", + "For example, here the `get_states` method returned a dict that included a key (`'amps'`) with a value of 6 instead of being a dictionary as expected.\n", + "In the `get_constraints` method, a constraint was added to the dictionary but did not include a `type` key, which is required as stated by the error message.\n", + "\n", + "If you encounter an error when using your subsystem, but the test here did not find it, please let the Aviary dev team know!\n", + "We'd love to hear from you on the [GitHub issues page](https://github.com/OpenMDAO/om-Aviary/issues) so we can help everyone write great external subsystems." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/user_guide/drawing_and_running_simple_missions.md b/_sources/user_guide/drawing_and_running_simple_missions.md new file mode 100644 index 000000000..e23eea8c8 --- /dev/null +++ b/_sources/user_guide/drawing_and_running_simple_missions.md @@ -0,0 +1,81 @@ +# Drawing and running simple missions + +## Overview + +Aviary comes with a simple built-in graphical interface for defining missions. +This tool can be accessed via the command line and provides an interactive way to define flight phases, including altitude, Mach number, and optimization parameters. + +It is specifically made to only be used with the `"simple"` mission method. +You could use the results from the GUI to run a mission with a different method, but it would require manually changing the generated `phase_info` dict. + +![Graphical user interface for drawing missions](images/gui.png) + +## Getting Started + +To launch the Flight Profile Utility, use the following command in your terminal: + +```bash +aviary draw_mission +``` + +This command will open a graphical interface where you can interactively design a flight profile. + +## Graphical Interface Usage + +### Main Components + +1. **Altitude Plot**: Graphically represents the altitude profile over time. Users can add and drag points to adjust the altitude at different mission times. + +2. **Mach Plot**: Similar to the Altitude Plot but for the Mach number profile. + +3. **Control Panel**: Contains various options and controls for customizing the flight profile and running simulations. + +### Interactive Features + +- **Adding Points**: Click on either the Altitude or Mach plot area to add a new point. Points on the Altitude plot represent altitude (in feet) at a specific time (in minutes), whereas points on the Mach plot represent the Mach number at specific times. + +- **Dragging Points**: Points on both plots can be dragged vertically to adjust values. This allows for fine-tuning of the flight profile. + +- **Removing Points**: Currently, the utility does not support direct removal of points. Adjust the profile by dragging or adding new points. + +### Input Fields and Options + +1. **Optimize Mach**: Toggles optimization for Mach number during each phase of the flight. + +2. **Optimize Altitude**: Toggles optimization for altitude during each phase. + +3. **Constrain Range**: If checked, imposes constraints on the flight range. + +4. **Solve for Range**: Calculates the total flight range based on the profile. + +5. **Polynomial Control Order**: Sets the polynomial order for control optimization. This is for all phases. You can modify behavior on a per-phase basis by editing the outputted `phase_info` dict. + +6. **Number of Segments**: Defines the number of segments for the mission profile. This is for all phases. You can modify behavior on a per-phase basis by editing the outputted `phase_info` dict. + +7. **Inputting Altitude and Mach values**: In these text fields you can directly input values for altitude and Mach number. These will directly update the plots. + +8. **Phase-specific Optimization**: Each phase (line in the plots) has two checkboxes for 'Optimize Mach' and 'Optimize Altitude', allowing for phase-specific optimization settings. + +### Output + +Upon completion, the tool outputs a Python script named `outputted_phase_info.py` in the current working directory. +This tool overwrites any existing file called `outputted_phase_info.py` in the current working directory. +This outputted file contains the `phase_info` dictionary, which holds the flight profile data structured for use in mission simulations. + +## Running a Mission Simulation + +After generating the flight profile, use the `run_mission` command to simulate the mission. +This command utilizes the `phase_info` from `outputted_phase_info.py` and simulates the mission based on the defined parameters. +You can use the `--phase_info` flag to specify the path to the `outputted_phase_info.py` file. +Here we use a benchmark case as the inputted .csv file, though you can use any Aviary .csv here that defines an aircraft. + +```bash +aviary run_mission --phase_info outputted_phase_info.py validation_cases/benchmark_tests/test_aircraft/aircraft_for_bench_FwFm.csv +``` + +You can also supply an optimizer, otherwise the default (SLSQP) will be used. +Here is how you'd run the mission with the IPOPT optimizer: + +```bash +aviary run_mission --optimizer IPOPT --phase_info outputted_phase_info.py validation_cases/benchmark_tests/test_aircraft/aircraft_for_bench_FwFm.csv +``` \ No newline at end of file diff --git a/_sources/user_guide/examples_of_the_same_mission_at_different_UI_levels.ipynb b/_sources/user_guide/examples_of_the_same_mission_at_different_UI_levels.ipynb new file mode 100644 index 000000000..f76118110 --- /dev/null +++ b/_sources/user_guide/examples_of_the_same_mission_at_different_UI_levels.ipynb @@ -0,0 +1,633 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Examples of the same mission at different UI levels\n", + "\n", + "Here we present a sort of [Rosetta Stone](https://en.wikipedia.org/wiki/Rosetta_Stone) for the same mission at different UI levels.\n", + "This is to show the code used to make and solve similar mission optimization problems at different UI levels.\n", + "\n", + "In each of these cases we'll set the maximum iterations to 0 to save execution time.\n", + "If you wanted to actually solve these problems, you'd need to set the maximum iterations to a larger number, like 50.\n", + "\n", + "```{note}\n", + "Because we're setting the max iter to 0, we see an \"Optimization FAILED\" output, but do not be concerned, this is expected as we're simply showing the different levels here, not actually solving the problems.\n", + "```\n", + "\n", + "## Level 1\n", + "\n", + "This is the most basic level of the UI.\n", + "There's a command-line interface (CLI) for Level 1, or you can use the Python API shown below.\n", + "If you want to make minor modifications to `phase_info`, you can do so here, but Level 1 largely assumes you're using the default setup." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "prob = av.run_aviary('models/test_aircraft/aircraft_for_bench_FwFm.csv',\n", + " av.default_height_energy_phase_info,\n", + " max_iter=0, optimizer=\"SLSQP\", make_plots=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Level 2\n", + "\n", + "This level grants more flexibility both in defining the `phase_info` object but also in calling the individual methods of `AviaryProblem` when setting up and running your model.\n", + "You can modify the methods you call, what they do, and what info they're given here.\n", + "This is much more verbose than Level 1.\n", + "In the absence of additional arguments to the methods, much of the default behavior here is the same as Level 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.api import Dynamic\n", + "import aviary.api as av\n", + "\n", + "phase_info = {\n", + " 'pre_mission': {\n", + " 'include_takeoff': True,\n", + " 'optimize_mass': True,\n", + " },\n", + " 'climb': {\n", + " 'subsystem_options': {\n", + " 'core_aerodynamics': {'method': 'computed'}\n", + " },\n", + " 'user_options': {\n", + " 'fix_initial': {Dynamic.Mission.MASS: False, Dynamic.Mission.RANGE: False},\n", + " 'fix_initial_time': True,\n", + " 'fix_duration': False,\n", + " 'num_segments': 6,\n", + " 'order': 3,\n", + " 'initial_altitude': (0., 'ft'),\n", + " 'initial_ref': (1., 's'),\n", + " 'initial_bounds': ((0., 500.), 's'),\n", + " 'duration_ref': (1452., 's'),\n", + " 'duration_bounds': ((726., 2904.), 's'),\n", + " 'final_altitude': (10668, 'm'),\n", + " 'input_initial': True,\n", + " 'no_descent': False,\n", + " 'initial_mach': 0.1,\n", + " 'final_mach': 0.79,\n", + " 'fix_range': False,\n", + " 'add_initial_mass_constraint': False,\n", + " },\n", + " 'initial_guesses': {\n", + " 'times': ([2., 24.2], 'min'),\n", + " 'altitude': ([0., 35.e3], 'ft'),\n", + " 'velocity': ([220., 455.49], 'kn'),\n", + " 'mass': ([170.e3, 165.e3], 'lbm'),\n", + " 'range': ([0., 160.3], 'nmi'),\n", + " 'velocity_rate': ([0.25, 0.05], 'm/s**2'),\n", + " 'throttle': ([0.5, 0.5], 'unitless'),\n", + " }\n", + " },\n", + " 'cruise': {\n", + " 'subsystem_options': {\n", + " 'core_aerodynamics': {'method': 'computed'}\n", + " },\n", + " 'user_options': {\n", + " 'fix_initial': False,\n", + " 'fix_final': False,\n", + " 'fix_duration': False,\n", + " 'num_segments': 1,\n", + " 'order': 3,\n", + " 'initial_ref': (1., 's'),\n", + " 'initial_bounds': ((500., 4000.), 's'),\n", + " 'duration_ref': (24370.8, 's'),\n", + " 'duration_bounds': ((726., 48741.6), 's'),\n", + " 'min_altitude': (10.668e3, 'm'),\n", + " 'max_altitude': (10.668e3, 'm'),\n", + " 'min_mach': 0.79,\n", + " 'max_mach': 0.79,\n", + " 'required_available_climb_rate': (1.524, 'm/s'),\n", + " 'mass_f_cruise': (1.e4, 'kg'),\n", + " 'range_f_cruise': (1.e6, 'm'),\n", + " },\n", + " 'initial_guesses': {\n", + " 'times': ([26.2, 406.18], 'min'),\n", + " 'altitude': ([35.e3, 35.e3], 'ft'),\n", + " 'velocity': ([455.49, 455.49], 'kn'),\n", + " 'mass': ([165.e3, 140.e3], 'lbm'),\n", + " 'range': ([160.3, 3243.9], 'nmi'),\n", + " 'velocity_rate': ([0., 0.], 'm/s**2'),\n", + " 'throttle': ([0.95, 0.9], 'unitless'),\n", + " }\n", + " },\n", + " 'descent': {\n", + " 'subsystem_options': {\n", + " 'core_aerodynamics': {'method': 'computed'}\n", + " },\n", + " 'user_options': {\n", + " 'fix_initial': False,\n", + " 'fix_range': True,\n", + " 'fix_duration': False,\n", + " 'num_segments': 5,\n", + " 'order': 3,\n", + " 'initial_ref': (1., 's'),\n", + " 'initial_bounds': ((10.e3, 30.e3), 's'),\n", + " 'duration_ref': (1754.4, 's'),\n", + " 'duration_bounds': ((726., 3508.8), 's'),\n", + " 'initial_altitude': (10.668e3, 'm'),\n", + " 'final_altitude': (10.668, 'm'),\n", + " 'initial_mach': 0.79,\n", + " 'final_mach': 0.3,\n", + " 'no_climb': False,\n", + " },\n", + " 'initial_guesses': {\n", + " 'times': ([432.38, 29.24], 'min'),\n", + " 'altitude': ([35.e3, 35.], 'ft'),\n", + " 'velocity': ([455.49, 198.44], 'kn'),\n", + " 'mass': ([120.e3, 115.e3], 'lbm'),\n", + " 'range': ([3243.9, 3378.7], 'nmi'),\n", + " 'velocity_rate': ([-0.25, 0.0], 'm/s**2'),\n", + " 'throttle': ([0., 0.], 'unitless'),\n", + " }\n", + " },\n", + " 'post_mission': {\n", + " 'include_landing': True,\n", + " },\n", + "}\n", + "\n", + "csv_path = \"models/test_aircraft/aircraft_for_bench_FwFm.csv\"\n", + "\n", + "prob = av.AviaryProblem()\n", + "\n", + "# Load aircraft and options data from user\n", + "# Allow for user overrides here\n", + "prob.load_inputs(csv_path, phase_info)\n", + "\n", + + "prob.check_and_preprocess_inputs()\n", + "\n", + "prob.add_pre_mission_systems()\n", + "\n", + "prob.add_phases()\n", + "\n", + "prob.add_post_mission_systems()\n", + "\n", + "# Link phases and variables\n", + "prob.link_phases()\n", + "\n", + "prob.add_driver(\"SLSQP\", max_iter=0)\n", + "\n", + "prob.add_design_variables()\n", + "\n", + "prob.add_objective(objective_type=\"mass\", ref=-1e5)\n", + "\n", + "prob.setup()\n", + "\n", + "prob.set_initial_guesses()\n", + "\n", + "prob.run_aviary_problem(record_filename='level2_example.db', suppress_solver_print=True, make_plots=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Level 3\n", + "\n", + "This level is the most flexible and the code will be the most verbose.\n", + "This directly calls the OpenMDAO and Dymos methods used to set up and run the model.\n", + "You have supreme control over every part of the model and mission definition, but that flexibility results in much more code." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import dymos as dm\n", + "import openmdao.api as om\n", + "import scipy.constants as _units\n", + "from packaging import version\n", + "\n", + "from aviary.api import HeightEnergyLandingPhaseBuilder as Landing\n", + "from aviary.api import HeightEnergyTakeoffPhaseBuilder as Takeoff\n", + "from aviary.api import HeightEnergyClimbPhaseBuilder as Climb\n", + "from aviary.api import HeightEnergyCruisePhaseBuilder as Cruise\n", + "from aviary.api import HeightEnergyDescentPhaseBuilder as Descent\n", + "\n", + "from aviary.api import Aircraft, Dynamic, Mission\n", + "\n", + "import aviary.api as av\n", + "\n", + "\n", + "use_new_dymos_syntax = version.parse(dm.__version__) > version.parse(\"1.8.0\")\n", + "\n", + "prob = om.Problem()\n", + "\n", + "driver = prob.driver = om.ScipyOptimizeDriver()\n", + "opt_settings = prob.driver.opt_settings\n", + "\n", + "driver.options['optimizer'] = 'SLSQP'\n", + "opt_settings['maxiter'] = 0\n", + "opt_settings['ftol'] = 5.0e-3\n", + "opt_settings['eps'] = 1e-2\n", + "\n", + "##########################################\n", + "# Aircraft Input Variables and Options #\n", + "##########################################\n", + "\n", + "aviary_inputs = av.get_flops_inputs('LargeSingleAisle1FLOPS')\n", + "aviary_outputs = av.get_flops_outputs('LargeSingleAisle1FLOPS')\n", + "\n", + "av.preprocess_options(aviary_inputs)\n", + "\n", + "alt_airport = 0 # ft\n", + "\n", + "alt_i_climb = 0*_units.foot # m\n", + "alt_f_climb = 35000.0*_units.foot # m\n", + "mass_i_climb = 180623*_units.lb # kg\n", + "mass_f_climb = 176765*_units.lb # kg\n", + "v_i_climb = 198.44*_units.knot # m/s\n", + "v_f_climb = 455.49*_units.knot # m/s\n", + "# initial mach set to lower value so it can intersect with takeoff end mach\n", + "# mach_i_climb = 0.3\n", + "mach_i_climb = 0.2\n", + "mach_f_climb = 0.79\n", + "range_i_climb = 0*_units.nautical_mile # m\n", + "range_f_climb = 160.3*_units.nautical_mile # m\n", + "t_i_climb = 2 * _units.minute # sec\n", + "t_f_climb = 26.20*_units.minute # sec\n", + "t_duration_climb = t_f_climb - t_i_climb\n", + "\n", + "alt_i_cruise = 35000*_units.foot # m\n", + "alt_f_cruise = 35000*_units.foot # m\n", + "alt_min_cruise = 35000*_units.foot # m\n", + "alt_max_cruise = 35000*_units.foot # m\n", + "mass_i_cruise = 176765*_units.lb # kg\n", + "mass_f_cruise = 143521*_units.lb # kg\n", + "v_i_cruise = 455.49*_units.knot # m/s\n", + "v_f_cruise = 455.49*_units.knot # m/s\n", + "# mach_i_cruise = 0.79\n", + "# mach_f_cruise = 0.79\n", + "mach_min_cruise = 0.79\n", + "mach_max_cruise = 0.79\n", + "range_i_cruise = 160.3*_units.nautical_mile # m\n", + "range_f_cruise = 3243.9*_units.nautical_mile # m\n", + "t_i_cruise = 26.20*_units.minute # sec\n", + "t_f_cruise = 432.38*_units.minute # sec\n", + "t_duration_cruise = t_f_cruise - t_i_cruise\n", + "\n", + "alt_i_descent = 35000*_units.foot\n", + "# final altitude set to 35 to ensure landing is feasible point\n", + "# alt_f_descent = 0*_units.foot\n", + "alt_f_descent = 35*_units.foot\n", + "v_i_descent = 455.49*_units.knot\n", + "v_f_descent = 198.44*_units.knot\n", + "mach_i_descent = 0.79\n", + "mach_f_descent = 0.3\n", + "mass_i_descent = 143521*_units.pound\n", + "mass_f_descent = 143035*_units.pound\n", + "range_i_descent = 3243.9*_units.nautical_mile\n", + "range_f_descent = 3378.7*_units.nautical_mile\n", + "t_i_descent = 432.38*_units.minute\n", + "t_f_descent = 461.62*_units.minute\n", + "t_duration_descent = t_f_descent - t_i_descent\n", + "\n", + "##################\n", + "# Define Phases #\n", + "##################\n", + "\n", + "num_segments_climb = 6\n", + "num_segments_cruise = 1\n", + "num_segments_descent = 5\n", + "\n", + "climb_seg_ends, _ = dm.utils.lgl.lgl(num_segments_climb + 1)\n", + "descent_seg_ends, _ = dm.utils.lgl.lgl(num_segments_descent + 1)\n", + "\n", + "transcription_climb = dm.Radau(\n", + " num_segments=num_segments_climb, order=3, compressed=True,\n", + " segment_ends=climb_seg_ends)\n", + "transcription_cruise = dm.Radau(\n", + " num_segments=num_segments_cruise, order=3, compressed=True)\n", + "transcription_descent = dm.Radau(\n", + " num_segments=num_segments_descent, order=3, compressed=True,\n", + " segment_ends=descent_seg_ends)\n", + "\n", + "takeoff_options = Takeoff(\n", + " airport_altitude=alt_airport, # ft\n", + " num_engines=aviary_inputs.get_val(Aircraft.Engine.NUM_ENGINES)\n", + ")\n", + "\n", + "climb_options = Climb(\n", + " 'test_climb',\n", + " user_options=av.AviaryValues({\n", + " 'initial_altitude': (alt_i_climb, 'm'),\n", + " 'final_altitude': (alt_f_climb, 'm'),\n", + " 'initial_mach': (mach_i_climb, 'unitless'),\n", + " 'final_mach': (mach_f_climb, 'unitless'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_range': (False, 'unitless'),\n", + " 'input_initial': (True, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_climb,\n", + ")\n", + "\n", + "cruise_options = Cruise(\n", + " 'test_cruise',\n", + " user_options=av.AviaryValues({\n", + " 'min_altitude': (alt_min_cruise, 'm'),\n", + " 'max_altitude': (alt_max_cruise, 'm'),\n", + " 'min_mach': (mach_min_cruise, 'unitless'),\n", + " 'max_mach': (mach_max_cruise, 'unitless'),\n", + " 'required_available_climb_rate': (300, 'ft/min'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_final': (False, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_cruise,\n", + ")\n", + "\n", + "descent_options = Descent(\n", + " 'test_descent',\n", + " user_options=av.AviaryValues({\n", + " 'final_altitude': (alt_f_descent, 'm'),\n", + " 'initial_altitude': (alt_i_descent, 'm'),\n", + " 'initial_mach': (mach_i_descent, 'unitless'),\n", + " 'final_mach': (mach_f_descent, 'unitless'),\n", + " 'fix_initial': (False, 'unitless'),\n", + " 'fix_range': (True, 'unitless'),\n", + " }),\n", + " core_subsystems=av.default_mission_subsystems,\n", + " subsystem_options={'core_aerodynamics': {'method': 'computed'}},\n", + " transcription=transcription_descent,\n", + ")\n", + "\n", + "landing_options = Landing(\n", + " ref_wing_area=aviary_inputs.get_val(Aircraft.Wing.AREA, 'ft**2'),\n", + " Cl_max_ldg=aviary_inputs.get_val(Mission.Landing.LIFT_COEFFICIENT_MAX)\n", + ")\n", + "\n", + "# Upstream static analysis for aero\n", + "prob.model.add_subsystem(\n", + " 'pre_mission',\n", + " av.CorePreMission(aviary_options=aviary_inputs,\n", + " subsystems=av.default_premission_subsystems),\n", + " promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['aircraft:*', 'mission:*'])\n", + "\n", + "# directly connect phases (strong_couple = True), or use linkage constraints (weak\n", + "# coupling / strong_couple=False)\n", + "strong_couple = False\n", + "\n", + "takeoff = takeoff_options.build_phase(False)\n", + "\n", + "climb = climb_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + "cruise = cruise_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + "descent = descent_options.build_phase(aviary_options=aviary_inputs)\n", + "\n", + "landing = landing_options.build_phase(False)\n", + "\n", + "prob.model.add_subsystem(\n", + " 'takeoff', takeoff, promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['mission:*'])\n", + "\n", + "traj = prob.model.add_subsystem('traj', dm.Trajectory())\n", + "\n", + "# if fix_initial is false, can we always set input_initial to be true for\n", + "# necessary states, and then ignore if we use a linkage?\n", + "climb.set_time_options(\n", + " fix_initial=True, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_climb*2), duration_ref=t_duration_climb)\n", + "cruise.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_cruise*2), duration_ref=t_duration_cruise)\n", + "descent.set_time_options(\n", + " fix_initial=False, fix_duration=False, units='s',\n", + " duration_bounds=(1, t_duration_descent*2), duration_ref=t_duration_descent)\n", + "\n", + "traj.add_phase('climb', climb)\n", + "\n", + "traj.add_phase('cruise', cruise)\n", + "\n", + "traj.add_phase('descent', descent)\n", + "\n", + "if use_new_dymos_syntax:\n", + " climb.timeseries_options['use_prefix'] = True\n", + " cruise.timeseries_options['use_prefix'] = True\n", + " descent.timeseries_options['use_prefix'] = True\n", + "\n", + "prob.model.add_subsystem(\n", + " 'landing', landing, promotes_inputs=['aircraft:*', 'mission:*'],\n", + " promotes_outputs=['mission:*'])\n", + "\n", + "traj.link_phases([\"climb\", \"cruise\"], [\"time\", Dynamic.Mission.ALTITUDE,\n", + " Dynamic.Mission.VELOCITY, Dynamic.Mission.MASS, Dynamic.Mission.RANGE], connected=strong_couple)\n", + "traj.link_phases([\"cruise\", \"descent\"], [\"time\", Dynamic.Mission.ALTITUDE,\n", + " Dynamic.Mission.VELOCITY, Dynamic.Mission.MASS, Dynamic.Mission.RANGE], connected=strong_couple)\n", + "\n", + "traj = av.setup_trajectory_params(prob.model, traj, aviary_inputs)\n", + "\n", + "##################################\n", + "# Connect in Takeoff and Landing #\n", + "##################################\n", + "\n", + "prob.model.add_subsystem(\n", + " \"takeoff_constraints\",\n", + " om.ExecComp(\n", + " [\n", + " \"takeoff_mass_con=takeoff_mass-climb_start_mass\",\n", + " \"takeoff_range_con=takeoff_range-climb_start_range\",\n", + " \"takeoff_vel_con=takeoff_vel-climb_start_vel\",\n", + " \"takeoff_alt_con=takeoff_alt-climb_start_alt\"\n", + " ],\n", + " takeoff_mass_con={'units': 'lbm'}, takeoff_mass={'units': 'lbm'},\n", + " climb_start_mass={'units': 'lbm'},\n", + " takeoff_range_con={'units': 'ft'}, takeoff_range={'units': 'ft'},\n", + " climb_start_range={'units': 'ft'},\n", + " takeoff_vel_con={'units': 'm/s'}, takeoff_vel={'units': 'm/s'},\n", + " climb_start_vel={'units': 'm/s'},\n", + " takeoff_alt_con={'units': 'ft'}, takeoff_alt={'units': 'ft'},\n", + " climb_start_alt={'units': 'ft'}\n", + " ),\n", + " promotes_inputs=[\n", + " (\"takeoff_mass\", Mission.Takeoff.FINAL_MASS),\n", + " (\"takeoff_range\", Mission.Takeoff.GROUND_DISTANCE),\n", + " (\"takeoff_vel\", Mission.Takeoff.FINAL_VELOCITY),\n", + " (\"takeoff_alt\", Mission.Takeoff.FINAL_ALTITUDE),\n", + " ],\n", + " promotes_outputs=[\"takeoff_mass_con\", \"takeoff_range_con\",\n", + " \"takeoff_vel_con\", \"takeoff_alt_con\"],\n", + ")\n", + "\n", + "prob.model.connect('traj.climb.states:mass',\n", + " 'takeoff_constraints.climb_start_mass', src_indices=[0])\n", + "prob.model.connect('traj.climb.states:range',\n", + " 'takeoff_constraints.climb_start_range', src_indices=[0])\n", + "prob.model.connect('traj.climb.states:velocity',\n", + " 'takeoff_constraints.climb_start_vel', src_indices=[0])\n", + "prob.model.connect('traj.climb.states:altitude',\n", + " 'takeoff_constraints.climb_start_alt', src_indices=[0])\n", + "\n", + "prob.model.connect(Mission.Takeoff.FINAL_MASS,\n", + " 'traj.climb.initial_states:mass')\n", + "prob.model.connect(Mission.Takeoff.GROUND_DISTANCE,\n", + " 'traj.climb.initial_states:range')\n", + "prob.model.connect(Mission.Takeoff.FINAL_VELOCITY,\n", + " 'traj.climb.initial_states:velocity')\n", + "prob.model.connect(Mission.Takeoff.FINAL_ALTITUDE,\n", + " 'traj.climb.initial_states:altitude')\n", + "\n", + "prob.model.connect('traj.descent.states:mass',\n", + " Mission.Landing.TOUCHDOWN_MASS, src_indices=[-1])\n", + "prob.model.connect('traj.descent.states:altitude', Mission.Landing.INITIAL_ALTITUDE,\n", + " src_indices=[-1])\n", + "\n", + "##########################\n", + "# Add Objective Function #\n", + "##########################\n", + "\n", + "# This is an example of a overall mission objective\n", + "# create a compound objective that minimizes climb time and maximizes final mass\n", + "# we are maxing final mass b/c we don't have an independent value for fuel_mass yet\n", + "# we are going to normalize these (makign each of the sub-objectives approx = 1 )\n", + "prob.model.add_subsystem(\n", + " \"regularization\",\n", + " om.ExecComp(\n", + " # TODO: change the scaling on climb_duration\n", + " \"reg_objective = - descent_mass_final/60000\",\n", + " reg_objective=0.0,\n", + " descent_mass_final={\"units\": \"kg\", \"shape\": 1},\n", + " ),\n", + " promotes_outputs=['reg_objective']\n", + ")\n", + "# connect the final mass from cruise into the objective\n", + "prob.model.connect(\"traj.descent.states:mass\",\n", + " \"regularization.descent_mass_final\", src_indices=[-1])\n", + "\n", + "prob.model.add_objective('reg_objective', ref=1)\n", + "\n", + "# Set initial default values for all aircraft variables.\n", + "av.set_aviary_initial_values(prob.model, aviary_inputs)\n", + "\n", + "# TODO: Why is this in outputs and not inputs?\n", + "key = Aircraft.Engine.THRUST_REVERSERS_MASS\n", + "val, units = aviary_outputs.get_item(key)\n", + "prob.model.set_input_defaults(key, val, units)\n", + "\n", + "prob.model.add_subsystem(\n", + " 'input_sink',\n", + " av.VariablesIn(aviary_options=aviary_inputs),\n", + " promotes_inputs=['*'],\n", + " promotes_outputs=['*']\n", + ")\n", + "\n", + "prob.setup()\n", + "\n", + "###########################################\n", + "# Intial Settings for States and Controls #\n", + "###########################################\n", + "\n", + "prob.set_val('traj.climb.t_initial', t_i_climb, units='s')\n", + "prob.set_val('traj.climb.t_duration', t_duration_climb, units='s')\n", + "\n", + "prob.set_val('traj.climb.states:altitude', climb.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_climb, alt_f_climb]), units='m')\n", + "# prob.set_val(\n", + "# 'traj.climb.states:velocity', climb.interp(Dynamic.Mission.VELOCITY, ys=[170, v_f_climb]),\n", + "# units='m/s')\n", + "prob.set_val('traj.climb.states:velocity', climb.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_climb, v_f_climb]), units='m/s')\n", + "prob.set_val('traj.climb.states:mass', climb.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_climb, mass_f_climb]), units='kg')\n", + "prob.set_val('traj.climb.states:range', climb.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_climb, range_f_climb]), units='m') # nmi\n", + "\n", + "prob.set_val('traj.climb.controls:velocity_rate',\n", + " climb.interp(Dynamic.Mission.VELOCITY_RATE, ys=[0.25, 0.0]),\n", + " units='m/s**2')\n", + "prob.set_val('traj.climb.controls:throttle',\n", + " climb.interp(Dynamic.Mission.THROTTLE, ys=[0.5, 0.5]),\n", + " units='unitless')\n", + "\n", + "prob.set_val('traj.cruise.t_initial', t_i_cruise, units='s')\n", + "prob.set_val('traj.cruise.t_duration', t_duration_cruise, units='s')\n", + "\n", + "prob.set_val('traj.cruise.states:altitude', cruise.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_cruise, alt_f_cruise]), units='m')\n", + "prob.set_val('traj.cruise.states:velocity', cruise.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_cruise, v_f_cruise]), units='m/s')\n", + "prob.set_val('traj.cruise.states:mass', cruise.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_cruise, mass_f_cruise]), units='kg')\n", + "prob.set_val('traj.cruise.states:range', cruise.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_cruise, range_f_cruise]), units='m') # nmi\n", + "\n", + "prob.set_val('traj.cruise.controls:velocity_rate',\n", + " cruise.interp(Dynamic.Mission.VELOCITY_RATE, ys=[0.0, 0.0]),\n", + " units='m/s**2')\n", + "prob.set_val('traj.cruise.controls:throttle',\n", + " cruise.interp(Dynamic.Mission.THROTTLE, ys=[0.5, 0.5]),\n", + " units='unitless')\n", + "\n", + "prob.set_val('traj.descent.t_initial', t_i_descent, units='s')\n", + "prob.set_val('traj.descent.t_duration', t_duration_descent, units='s')\n", + "\n", + "prob.set_val('traj.descent.states:altitude', descent.interp(\n", + " Dynamic.Mission.ALTITUDE, ys=[alt_i_descent, alt_f_descent]), units='m')\n", + "prob.set_val('traj.descent.states:velocity', descent.interp(\n", + " Dynamic.Mission.VELOCITY, ys=[v_i_descent, v_f_descent]), units='m/s')\n", + "prob.set_val('traj.descent.states:mass', descent.interp(\n", + " Dynamic.Mission.MASS, ys=[mass_i_descent, mass_f_descent]), units='kg')\n", + "prob.set_val('traj.descent.states:range', descent.interp(\n", + " Dynamic.Mission.RANGE, ys=[range_i_descent, range_f_descent]), units='m')\n", + "\n", + "prob.set_val('traj.descent.controls:velocity_rate',\n", + " descent.interp(Dynamic.Mission.VELOCITY_RATE, ys=[-0.25, 0.0]),\n", + " units='m/s**2')\n", + "prob.set_val('traj.descent.controls:throttle',\n", + " descent.interp(Dynamic.Mission.THROTTLE, ys=[0.0, 0.0]),\n", + " units='unitless')\n", + "\n", + "# Turn off solver printing so that the SNOPT output is readable.\n", + "prob.set_solver_print(level=0)\n", + "\n", + "dm.run_problem(prob, simulate=False, make_plots=False, simulate_kwargs={\n", + " 'times_per_seg': 100, 'atol': 1e-9, 'rtol': 1e-9},\n", + " solution_record_file='large_single_aisle_1_solution.db')\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/user_guide/external_aero.ipynb b/_sources/user_guide/external_aero.ipynb new file mode 100644 index 000000000..ff514ac63 --- /dev/null +++ b/_sources/user_guide/external_aero.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "indian-capability", + "metadata": {}, + "source": [ + "# Externally Computed Polars\n", + "\n", + "This example shows how to build, using the level-2 interface, an aviary model that includes an external susbsystem that computes a lift and drag polar and passes them into the mission aerodynamics for a 3-phase mission (climb, cruise, descent). During the mission, Aviary will interpolate on the computed polars to compute actual lift and drag for a given flight condition.\n", + "\n", + "We start with the assumption that we have an external component called `ExternalAero` that can compute the lift and drag at any given altitude, mach number, and angle of attack. The details of such a component may be highly complicated and not important for the purposes of this example. We will be using a structured grid, which assumes the data table is regularly spaced in all dimensions. We want to compute lift and drag over a grid of altitudes (in 'ft'), mach numbers, and angles of attack given by:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "photographic-excerpt", + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "# This hidden cell just creates a component that produces the lift and drag polar. \n", + "# The implementation details are uninportant to the example.\n", + "import openmdao.api as om\n", + "import numpy as np\n", + "\n", + "from aviary.api import Aircraft\n", + "import aviary.api as av\n", + "\n", + "# The drag-polar-generating component reads this in, instead of computing the polars.\n", + "polar_file = \"subsystems/aerodynamics/gasp_based/data/large_single_aisle_1_aero_free_reduced_alpha.txt\"\n", + "\n", + "aero_data = av.read_data_file(polar_file, aliases = {'altitude': 'altitude',\n", + " 'mach': 'mach',\n", + " 'angle_of_attack': 'angle_of_attack',\n", + " 'lift_coefficient': 'cl',\n", + " 'drag_coefficient': 'cd'})\n", + "\n", + "altitude = np.unique(aero_data.get_val('altitude', 'ft'))\n", + "mach = np.unique(aero_data.get_val('mach', 'unitless'))\n", + "angle_of_attack = np.unique(aero_data.get_val('angle_of_attack', 'deg'))\n", + "\n", + "shape = (altitude.size, mach.size, angle_of_attack.size)\n", + "CL = aero_data.get_val('lift_coefficient').reshape(shape)\n", + "CD = aero_data.get_val('drag_coefficient').reshape(shape)\n", + "\n", + "\n", + "class ExternalAero(om.ExplicitComponent):\n", + " \"\"\"\n", + " This component is a stand-in for an externally computed lift/drag table\n", + " calculation. It does nothing but read in the pre-computed table. A real\n", + " component would actually computed the values at all requested points.\n", + " \"\"\"\n", + " def initialize(self):\n", + " \"\"\"\n", + " Declare options.\n", + " \"\"\"\n", + " self.options.declare(\"altitude\", default=None, allow_none=True,\n", + " desc=\"List of altitudes in ascending order.\")\n", + " self.options.declare(\"mach\", default=None, allow_none=True,\n", + " desc=\"List of mach numbers in ascending order.\")\n", + " self.options.declare(\"angle_of_attack\", default=None, allow_none=True,\n", + " desc=\"List of angles of attack in ascending order.\")\n", + "\n", + " def setup(self):\n", + " altitude = self.options['altitude']\n", + " mach = self.options['mach']\n", + " angle_of_attack = self.options['angle_of_attack']\n", + "\n", + " self.add_input(Aircraft.Wing.AREA, 1.0, units='ft**2')\n", + " self.add_input(Aircraft.Wing.SPAN, 1.0, units='ft')\n", + "\n", + " shape = (len(altitude), len(mach), len(angle_of_attack))\n", + "\n", + " self.add_output('drag_table', shape=shape, units='unitless')\n", + " self.add_output('lift_table', shape=shape, units='unitless')\n", + "\n", + " def compute(self, inputs, outputs):\n", + " \"\"\"\n", + " This component doesn't do anything, except set the drag and lift\n", + " polars from the file we read in.\n", + " \"\"\"\n", + " outputs['drag_table'] = CD\n", + " outputs['lift_table'] = CL\n", + " \n", + "print('Altitude (ft)', altitude)\n", + "print('Mach', mach)\n", + "print('Angle of Attack (deg)', angle_of_attack)" + ] + }, + { + "cell_type": "markdown", + "id": "elder-kinase", + "metadata": {}, + "source": [ + "In a structured grid, interpolation data must be present for every combination of inputs. In other words, our `ExternalAero` component must run a full factorial of points spanning those 3 variables. The Aviary variable hierarchy includes two variables for the polars: `Aircraft.Design.LIFT_POLAR`, and `Aircraft.Design.DRAG_POLAR`. The data in each of these polars should be a `n` x `m` x `k` numpy array, where `n` is the number of altitudes, `m` is the number of mach numbers, and `k` is the number of angles of attack. The `ExternalAero` will need to compute these values and place them into an array of this shape.\n", + "\n", + "If use of a structured grid is not desirable, then the data does not need to meet these formatting requirements. In that case, the data table does not have to be regularly spaced, and each variable (`Altitude`, `Mach`, `angle_of_attack`, `LIFT_POLAR`, and `DRAG_POLAR`) must be 1-dimensional numpy arrays of equal length.\n", + "\n", + "Using the level-2 interface, we create a builder for our external `ExternalAero` subsystem. In this example, the component produces outputs `drag_table` and `lift_table`, but we can specify an alias to `Aircraft.Design.DRAG_POLAR` and `Aircraft.Design.LIFT_POLAR` respectively. It is important that we inherit from the `AerodynamicsBuilderBase` to let Aviary know this is builder produces aerodynamics components. Some mission analysis methods require special handling of aerodynamics components that will not occur if we skip this step." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "roman-direction", + "metadata": {}, + "outputs": [], + "source": [ + "class ExternalAeroBuilder(av.AerodynamicsBuilderBase):\n", + " \"\"\"\n", + " An example subsystem builder that adds an external aerodynamics component\n", + "\n", + " Parameters\n", + " ----------\n", + " aero_data : NamedValues\n", + " Altitude, Mach number, and angle of attack data, all in ascending order.\n", + " \"\"\"\n", + "\n", + " def __init__(self, name='aero', altitude=None, mach=None,\n", + " angle_of_attack=None):\n", + " super().__init__(name)\n", + " self.altitude = altitude\n", + " self.mach = mach\n", + " self.angle_of_attack = angle_of_attack\n", + " \n", + " def build_pre_mission(self, aviary_inputs):\n", + " \"\"\"\n", + " Build an OpenMDAO system for the pre-mission computations of the subsystem.\n", + "\n", + " Returns\n", + " -------\n", + " pre_mission_sys : openmdao.core.Group\n", + " An OpenMDAO group containing all computations that need to happen in\n", + " the pre-mission part of the Aviary problem. This includes sizing, design,\n", + " and other non-mission parameters.\n", + " \"\"\"\n", + "\n", + " return ExternalAero(altitude=self.altitude, mach=self.mach, angle_of_attack=self.angle_of_attack)\n", + "\n", + " def mission_outputs(self):\n", + " return [('drag_table', Aircraft.Design.DRAG_POLAR),\n", + " ('lift_table', Aircraft.Design.LIFT_POLAR)]" + ] + }, + { + "cell_type": "markdown", + "id": "extreme-green", + "metadata": {}, + "source": [ + "Notice that we have passed the altitude, Mach, and angle of attack arrays into the builder so that the ExternalAero component can use them as instantiation arguments.\n", + "\n", + "Next, we add the builder to our phase_info as usual. We are using a single-aisle commercial transport aircraft and mission." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "coral-beijing", + "metadata": {}, + "outputs": [], + "source": [ + "phase_info = av.default_height_energy_phase_info.copy()\n", + "\n", + "external_aero = ExternalAeroBuilder(name='external_aero',\n", + " altitude=altitude, mach=mach, angle_of_attack=angle_of_attack)\n", + "\n", + "phase_info['pre_mission']['external_subsystems'] = [external_aero]" + ] + }, + { + "cell_type": "markdown", + "id": "technological-compatibility", + "metadata": {}, + "source": [ + "Next, the existing mission phases need to be given the information they need to set up our aerodynamics analysis using `phase_info`. We use the `solved_alpha` method of Aviary's included aerodynamics for this, which can accept the input passed from our external subsystem. Since we are using Aviary's built-in aerodynamics methods, we use the default name \"core_aerodynamics\". Don't forget to update the `subsystem_options` for each phase. We must specify the `method`, the `aero_data` that contains our altitude, Mach, and angle of attack data, as well as the `training_data` flag to denote we are passing our drag polars via openMDAO connections." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "phantom-showcase", + "metadata": {}, + "outputs": [], + "source": [ + "subsystem_options = {'method': 'solved_alpha',\n", + " 'aero_data': aero_data,\n", + " 'training_data': True}\n", + "\n", + "phase_info['climb']['subsystem_options'] = {'core_aerodynamics': subsystem_options}\n", + "phase_info['cruise']['subsystem_options'] = {'core_aerodynamics': subsystem_options}\n", + "phase_info['descent']['subsystem_options'] = {'core_aerodynamics': subsystem_options}\n" + ] + }, + { + "cell_type": "markdown", + "id": "equivalent-lawsuit", + "metadata": {}, + "source": [ + "Finally, we can instantiate the AviaryProblem like normal. However, we need to tell Aviary the size of our lift and drag polars so that it can allocate the right shape for the connection." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "quick-report", + "metadata": {}, + "outputs": [], + "source": [ + "import pkg_resources\n", + "\n", + "from aviary.api import AviaryProblem\n", + "\n", + "input_file = pkg_resources.resource_filename(\n", + " \"aviary\", \"models/test_aircraft/aircraft_for_bench_GwFm.csv\")\n", + "\n", + "prob = av.AviaryProblem()\n", + "prob.load_inputs(input_file, phase_info)\n", + "\n", + "# Add correctly-sized polar to aviary_inputs so that input components are sized correctly.\n", + "shape = (altitude.size, mach.size, angle_of_attack.size)\n", + "\n", + "prob.aviary_inputs.set_val(Aircraft.Design.LIFT_POLAR, np.zeros(shape), units='unitless')\n", + "prob.aviary_inputs.set_val(Aircraft.Design.DRAG_POLAR, np.zeros(shape), units='unitless')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "weird-space", + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "# get through setup for the problem\n", + "prob.add_pre_mission_systems()\n", + "prob.add_phases()\n", + "prob.add_post_mission_systems()\n", + "prob.link_phases()\n", + "prob.add_driver(\"SLSQP\")\n", + "prob.add_design_variables()\n", + "prob.add_objective(objective_type=\"mass\", ref=-1e5)\n", + "prob.setup()" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/user_guide/features/overriding.ipynb b/_sources/user_guide/features/overriding.ipynb new file mode 100644 index 000000000..e7f81401d --- /dev/null +++ b/_sources/user_guide/features/overriding.ipynb @@ -0,0 +1,174 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "approved-school", + "metadata": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "try:\n", + " from openmdao.utils.notebook_utils import notebook_mode\n", + "except ImportError:\n", + " !python -m pip install openmdao[notebooks]" + ] + }, + { + "cell_type": "markdown", + "id": "editorial-gilbert", + "metadata": {}, + "source": [ + "# Overriding Variables\n", + "\n", + "Aviary allows you to replace certain internally computed quantities with a custom value, which can either be a constant or a value computed by some custom component through a capability called `Overriding`. The motivation for this capability comes from FLOPS, which allowed the user to override certain variables with pre-computed values from other more accurate sources. Aviary expands this feature to allow direct override of any intermediate calculation except for dynamic mission variables that are controlled by Dymos.\n", + "\n", + "Throughout an Aviary model, all inputs and outputs that begin with \"aircraft:\" or \"mission:\" are promoted to the top level. When an output and an input have the same name, they are implicitly connected through this process. When we override an Aviary output, it is no longer promoted as the original variable name, but is instead promoted with the string \"AUTO_OVERRIDE:\" prepended to the variable name. This eliminates the connection from the output to the input and a visible dead-end promoted name that will be seen in the `list_outputs`. \n", + "\n", + "Once an output has been overridden, the inputs are free to take on any value specified in the `aviary_inputs`. If you add an external component to your aviary model that provides this same output, then those inputs will be implicitly connected to that component. If you add multiple components that provide the output, then you will have to override all but one of them.\n", + "\n", + "\n", + "## Replacing Computed Value with a Constant\n", + "\n", + "Consider a simple case where we want to specify a constant value for the horizontal tail mass instead of using the value calculated in Aviary. We simply set the value in our `aviary_inputs`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "discrete-south", + "metadata": {}, + "outputs": [], + "source": [ + "from aviary.api import Aircraft\n", + "import aviary.api as av\n", + "\n", + "aviary_inputs = av.AviaryValues(av.FLOPS_Test_Data['LargeSingleAisle1FLOPS']['inputs'])\n", + "\n", + "aviary_inputs.set_val(Aircraft.HorizontalTail.MASS, 2200.0, units='lbm')" + ] + }, + { + "cell_type": "markdown", + "id": "encouraging-picnic", + "metadata": {}, + "source": [ + "## Replacing Computed Value with the Output of Another Component\n", + "\n", + "Consider a case where we have added one component that computes the mass of the horizontal tail. We want to override the internally computed value of the mass with a new value that comes from an external component. We can do this in the level 2 interface when we define our builder, by simply providing an output that uses Aviary's name in the variable hierarchy. (i.e., Aircraft.HorizontalTail.MASS for this case) When we do this, aviary will automatically detect that an external subsystem is providing this variable, and will override the internal calculation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "unlikely-baltimore", + "metadata": {}, + "outputs": [], + "source": [ + "import openmdao.api as om\n", + "\n", + "from aviary.api import SubsystemBuilderBase, Aircraft\n", + "\n", + "\n", + "class HTailMass(om.ExplicitComponent):\n", + " \"\"\"\n", + " User-provided subsystem to compute the tail weight with a simple formula.\n", + " \"\"\"\n", + "\n", + " def setup(self):\n", + "\n", + " self.add_input('Area', 1.0, units='ft**2')\n", + " self.add_output('Mass', 1.0, units='lbm')\n", + " \n", + " self.declare_partials('Mass', 'Area', val=20.0)\n", + "\n", + " def compute(self, inputs, outputs):\n", + " outputs['Mass'] = 20.0 * inputs['Area']\n", + " \n", + " \n", + "class HTailWeightBuilder(SubsystemBuilderBase):\n", + " \"\"\"\n", + " Prototype of a subsystem that overrides an aviary internally computed var.\n", + " \"\"\"\n", + "\n", + " def __init__(self, name='wing_weight'):\n", + " super().__init__(name)\n", + "\n", + " def build_pre_mission(self, aviary_inputs):\n", + " '''\n", + " Build an OpenMDAO system for the pre-mission computations of the subsystem.\n", + "\n", + " Returns\n", + " -------\n", + " pre_mission_sys : openmdao.core.System\n", + " An OpenMDAO system containing all computations that need to happen in\n", + " the pre-mission (formerly statics) part of the Aviary problem. This\n", + " includes sizing, design, and other non-mission parameters.\n", + " '''\n", + " wing_group = om.Group()\n", + " wing_group.add_subsystem(\"tail_weight\", HTailMass(),\n", + " promotes_inputs=[('Area', Aircraft.HorizontalTail.AREA)],\n", + " promotes_outputs=[('Mass', Aircraft.HorizontalTail.MASS)]\n", + " )\n", + " return wing_group\n", + "\n", + "\n", + "from aviary.api import default_height_energy_phase_info as phase_info \n", + "phase_info['pre_mission']['external_subsystems'] = [HTailWeightBuilder(name=\"tail_external\")]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "temporal-duplicate", + "metadata": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "# Make sure the syntax is correct.\n", + "\n", + "builder = HTailWeightBuilder()\n", + "builder.build_pre_mission(None)" + ] + }, + { + "cell_type": "markdown", + "id": "acquired-trinity", + "metadata": {}, + "source": [ + "Note that if we add two components that provide the same output, we should be careful to only promote one of them to a specific variable name. If you promote two or more outputs with the same name, an error will be raised indicating that there are multiple outputs with the same name." + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/_sources/user_guide/features_and_functionalities.md b/_sources/user_guide/features_and_functionalities.md new file mode 100644 index 000000000..23f729d38 --- /dev/null +++ b/_sources/user_guide/features_and_functionalities.md @@ -0,0 +1,102 @@ +# Features and Functionalities + +## Subsystems + +At a minimum, an Aviary model needs to include the following subsystems: + +- Geometry +- Mass +- Aerodynamics +- Propulsion +- Mission + +Basically, these subsystems provide all the necessary forces acting on the aircraft which allows us to evaluate the performance of the aircraft across its mission. +Aviary does not explicitly support models with only some of these subsystems, but you are welcome to use parts of Aviary's code to build your own model. + +The following sections will discuss each of these subsystems in more detail. + +## Basic Assumptions + +Because Aviary is a tool for conceptual design, we make a number of assumptions about the aircraft and mission that allow us to simplify the model. +These are often baked in to the underlying subsystem models, but it's important to understand what these assumptions are so that you can make sure they're appropriate for your problem. + +For example, Aviary's computed aerodynamic models are only valid for subsonic flight. +Aviary itself is not limited to subsonic flight, but the aerodynamic models are. +So, you could use Aviary to model a supersonic aircraft, but you would need to provide your own aerodynamic model. + +Other assumptions are largely dependent on which subsystems you include, the aircraft you're designing, and the mission you're evaluating. + + + +## Mission Optimization + +We'll now discuss mission optimization from a user's perspective. +What we mean by that is that we'll not go into details on the theory or math behind mission optimization, but instead focus on what it means for you to set up a mission optimization problem in Aviary. +We'll start by discussing the different phases of a mission that you can model in Aviary, and then we'll discuss how to set up constraints for your mission optimization problem. +Additionally, we'll dig into just how much flexibility you should give the optimizer when defining your mission. + +### Basic definition of a mission + +Throughout Aviary we use a series of terms when discussing mission optimization. + +A "trajectory" is the full mission that the aircraft flies. +Usually this is from takeoff to landing, inclusive. +Sometimes you might want to model just a portion of the full aircraft trajectory; for example only the cruise portion. + +A "phase" is a part of the trajectory that is defined by a single set of differential equations. +For example, a simple way of defining a full trajectory is to have climb, cruise, and descent phases. +Each of these phases can have different physics, subsystems, controls, and constraints. +For example, the climb phase for a hybrid-electric aircraft might be have electric motor assistance whereas that might not be needed for the cruise phase. + +A "segment" is a sub-portion of a phase that is mostly used internally or when discussing the math behind the problem. +Users that are not defining custom phases will likely never need to worry about segments. + +### Defining a mission + +A mission is defined by a series of phases that the user chooses by specifying options in the `phase_info` dictionary. +The `phase_info` dictionary is a dictionary of dictionaries, where each key is the name of a phase and the value is a dictionary of options for that phase. + +How you choose to define your phases is dependent on the aircraft you're modeling, the mission you're trying to evaluate, and the flexibility you want to give the optimizer. +For example, if you have a relatively conventional aircraft that is flying a straightforward mission, you might just need three phases: climb, cruise, and descent. +However, if you have a more complex aircraft or mission, you might need to define more phases. +For instance, if you're modeling a hybrid-electric aircraft with non-conventional propulsion systems that are controlled in different ways, you might want to define additional phases and prescribe different options based on which physics you want included at different stages in the flight. + +In general, if you're familiar with the legacy tools FLOPS or GASP, you can use the corresponding default `phase_info` objects to start defining your mission. +FLOPS-based missions have three integrated phases: climb, cruise, and descent, as well as analytic takeoff and landing systems. +GASP-based missions have at least nine integrated phases: groundroll, rotation, ascent, accel, climb1, climb2, cruise, desc1, and desc2, as well landing systems. +GASP-based missions that are solved using SGM have additional phases. +The difference in the number of phases is due to the fact that GASP had more detailed requirements on the flight profile, especially in the early phases of a mission. + +You can import a copy of the default `phase_info` dicts and then modify them as you need to for your own mission definition. + +### Defining mission controls and constraints + +How you choose to define your mission constraints depends on the aircraft your modeling, the equations of motion used, and which subsystems you're including in your model. +For example, if you're modeling a single-aisle commercial transport aircraft that will fly a relatively conventional mission, you might define your mission so that the aircraft can only climb in the first phase, cruises at a fixed altitude and Mach number, then descends in the final phase. +This would mimic the actual flight profile of this aircraft to a reasonable degree. + +However, if you're modeling an urban air mobility aircraft that will fly a more complex mission, you might want to give the optimizer more flexibility in how it flies the mission. +Purposefully giving the optimizer the freedom to explore the trajectory design space at the same time it's designing the aircraft is a perfect example use case for Aviary. +This will result in a more complex optimization problem that might not converge well without some expert knowledge of the problem, but it will allow you to explore the design space more fully. + +## Collocation and Shooting + +Both [collocation](https://openmdao.org/dymos/docs/latest/getting_started/collocation.html) and shooting methods are included in Aviary for mission analysis as they each have something to offer. +Collocation methods are easily parallelizable and call the model ODE relatively few times. +This leads to significantly faster optimization times for large problems. + +```{note} +Please see [this Dymos doc page](https://openmdao.org/dymos/docs/latest/getting_started/transcriptions.html#differences-between-collocation-and-explicit-shooting) for a better understanding of the similarities and differences between shooting and collocation methods. +``` + +Shooting (or Forward in Time Integration) methods provide physically valid trajectories at all iterations of the optimization. This means that even if an optimization fails to converge, the results are still physical and can be useful for debugging. +[This journal paper](https://link.springer.com/article/10.1007/s10957-023-02303-3) contains more information about the shooting method used in Aviary. + +While collocation methods require a reasonably accurate estimation of the trajectory to be able to converge, shooting methods only require the initial state. This makes analyzing a new aircraft or mission easier for analysts as they do not need to produce accurate initial guesses. +One of the main advantages of shooting methods is the ability to dynamically order phases based on events. This means that different constraints, controls, or ODEs can be used depending on conditions during the trajectory. For example, the drag calculations change depending on aircraft configuration during takeoff; if the flaps are retracted when the aircraft reaches a certain speed, but the gear is retracted based on altitude, the two events could occur in either order. + +Collocation results are presented as part of a fixed step-size timeseries. To improve performance, the shooting method uses an adaptive step size; this means that the resulting trajectories will not always have a consistent number of points. There are plans to add a post processing interpolation to the trajectory results to produce a consistent timeseries, but that has not been implemented yet. + +```{note} +When using Aviary, the `AnalysisScheme` option is used to select the integration method. The default is `COLLOCATION`, but this can be changed to `SHOOTING` to use the shooting method. +``` diff --git a/_sources/user_guide/input_files.ipynb b/_sources/user_guide/input_files.ipynb new file mode 100644 index 000000000..39e37182e --- /dev/null +++ b/_sources/user_guide/input_files.ipynb @@ -0,0 +1,229 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Input Files\n", + "\n", + "Aviary can read input files for a few different purposes.\n", + "The main purpose is to load information from a .csv file about the aircraft to be designed.\n", + "Other input files might be necessary if you're loading in tabulated aerodynamic or propulsion data.\n", + "This doc page goes into more details about the different types of input files and how to use them. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Aviary Aircraft Input Files\n", + "\n", + "Aviary uses a .csv file to load in information about the aircraft to be designed.\n", + "The file format is straightforward and follows the convention of `name, value, units` for each row.\n", + "The names of the variables are detailed in the [Understanding Variable Metadata doc page](variable_metadata).\n", + "\n", + "Here are the first few lines of an example input file:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "from aviary.api import Aircraft\n", + "import aviary.api as av\n", + "\n", + "file_path = av.get_path('models/test_aircraft/aircraft_for_bench_FwFm.csv')\n", + "\n", + "with open(file_path, 'r') as file:\n", + " for i, line in enumerate(file):\n", + " if i < 20:\n", + " print(line.strip('\\n'))\n", + " else:\n", + " break\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## External Data Files\n", + "Several subsystems, including propulsion and aerodynamics, support loading existing tabular engine performance data and drag polars respectively from text files. Aviary has a specific format that data files are required to be in to ensure both human and machine readability.\n", + "\n", + "Most arbitrary file extensions will work, however it is recommended to use a basic text-based file format (such as .txt or .csv) so the data file is compatible for viewing with other programs.\n", + "\n", + "Aviary's data table format consists of three parts: comments, headers, and data. Comments are any text on a line following the `#` character. Comments may be placed anywhere in the file, including in-line.\n", + "\n", + "Headers are information on variable name, and optionally units. Only one header can be present, and it must appear *before* the numerical performance data begins. The header consists of a comma separated list of variable names in the order they appear in the data table, with units optionally provided in parentheses after the variable name. Aviary supports the same [list of units](https://openmdao.org/newdocs/versions/latest/features/units.html) supported by OpenMDAO. \n", + "If units are not specified, a default of 'unitless' is assumed, unless the user provides variable metadata when using the csv reading utility function. In that case, the default units of that variable in the metadata is used. This functionality is demonstrated below.\n", + "\n", + "The data in an external data file must be in column format, delimited by commas. Only numerical data that can be cast to type `float` is compatible with Aviary data tables at this time. An error will be raised if non-numerical data is present in the data file that is not a comment or a correctly formatted header." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reading and writing Aviary data files\n", + "Aviary includes a pair of utility functions, `read_data_file` and `write_data_file`, to assist reading and writing files in Aviary data format. Here we will demonstrate writing data to a csv file, then reading it back to retrieve the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate fake data set with units using NamedValues\n", + "data = av.NamedValues()\n", + "data.set_val(Aircraft.Wing.SPAN, [79, 118, 171], 'ft')\n", + "data.set_val('Scale Factor', [0.5, 0.75, 0.8], 'unitless')\n", + "# add these comments to the file, added to the top. Demonstrate how comments do not\n", + "# require inclusion of a '#' symbol, and will work either way\n", + "comments = ['This is test data generated using write_data_file',\n", + " '# Aviary data tables can support multiple comments']\n", + "# the name of the file we will write to\n", + "filename = 'example.csv'\n", + "\n", + "av.write_data_file(filename, data, comments)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The .csv file that is created looks like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "with open('example.csv', 'r') as file:\n", + " for line in file:\n", + " print(line.strip('\\n'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's read this file back into memory and confirm everything was read correctly. Note that `Scale Factor` does not have units explicitly listed. Variables without specified units, or units of 'unitless' do not require units to be listed in the header to reduce clutter. When reading this csv back, Aviary will know to add units of 'unitless' to any variables without specified units. The exception is when using metadata to filter what data will be read, which will be demonstrated later on this page. Also, it can be seen both comments have the `#` as the first character, even though it was not included in the first comment given to the csv writer. Aviary handles comment formatting, so including a `#` character with comments is optional." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# read the csv file that was just created\n", + "read_data, read_comments = av.read_data_file(filename, save_comments=True)\n", + "# print out comments\n", + "print(read_comments)\n", + "# print out variable name, units, and values\n", + "items = av.get_items(read_data)\n", + "for item in items:\n", + " print(f'{item[0]}, units: {item[1][1]}')\n", + " print(item[1][0])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Running this code shows our comments were correctly retrieved (stripped of leading `#`). We also have both our variables with their correct units and values. The `write_data_file` function has added back in units of 'unitless' for Mach Number. `Scale Factor` was also modified to `Scale_Factor`. This is because it is assumed these names will feed into openMDAO variables, and spaces are not allowed.\n", + "\n", + "Now let's explore some optional arguments for `csv_reader`.\n", + "\n", + "The first optional argument for `csv_reader` is variable metadata. When provided, `read_data_file` checks variable names in the header against the metadata and skips reading any variables not found. In addition, units specified in the data file are checked for compatibility with the default units for that variable. If units are not provided for a variable, default units are applied instead of always applying 'unitless'. Let's re-run the same code as before, but this time provide Aviary's core metadata to the reader. The expected behavior is for `Scale Factor` to be skipped, since it isn't in the variable hierarchy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# call read_data_file again, but this time provide variable metadata\n", + "read_data, read_comments = av.read_data_file(filename, av.CoreMetaData, save_comments=True)\n", + "# print out comments\n", + "print(read_comments)\n", + "# print out variable name, units, and values\n", + "items = av.get_items(read_data)\n", + "for item in items:\n", + " print(f'{item[0]}, units: {item[1][1]}')\n", + " print(item[1][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that only `aircraft:wing:span` was read from file this time, and is the only variable present in the data loaded to memory. Additionally, a warning was created informing us that `Scale Factor` was skipped.\n", + "\n", + "A second optional argument is `aliases`. This argument is used to map multiple possible header names to the same openMDAO variable. This is useful if your data files do not use Aviary variable names, or could contain multiple variants of names that all mean the same thing (such as 'height', 'alt', and 'altitude'). In this example, our data file has a header labeled `Scale Factor`, but we would like to map it to the more precise `aircraft:wing:mass_scaler`. The allowable header name matching is not case-sensitive and Aviary will treat spaces and underscores as identical, so `scale_factor` will match with `Scale Factor`. This improves ease-of-use. However, the variable name you want headers mapped to are case-sensitive, in case you are connecting to an external component that doesn't follow Aviary's [variable naming standards](../developer_guide/coding_standards.md). So if your alias dict contains `Final_Name: example_var`, any case combination of `example_var` will always return `Final_Name` capitalized as specified." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# keys are desired openMDAO variable name, values are header names that we want to match\n", + "# values can also be a list of multiple header names that map to the same key\n", + "alias_dict = {Aircraft.Wing.MASS_SCALER: 'Scale Factor'}\n", + "\n", + "# call read_data_file again, but this time provide variable alias dictionary\n", + "read_data, read_comments = av.read_data_file(filename, aliases=alias_dict, save_comments=True)\n", + "# print out comments\n", + "print(read_comments)\n", + "# print out variable name, units, and values\n", + "items = av.get_items(read_data)\n", + "for item in items:\n", + " print(f'{item[0]}, units: {item[1][1]}')\n", + " print(item[1][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that instead of returning `Scale Factor`, we have our values listed under `aircraft:wing:mass_scaler`, as desired." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aviary", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/user_guide/mass.md b/_sources/user_guide/mass.md new file mode 100644 index 000000000..c3da0ade1 --- /dev/null +++ b/_sources/user_guide/mass.md @@ -0,0 +1,41 @@ +# Mass Subsystem + +The mass subsystem in Aviary plays a straightforward but crucial role. +We need to know a reasonable estimate for the mass of an aircraft to evaluate its performance. +The mass subsystem provides this estimate. + +```{note} +The mass subsystem in Aviary is similar to the "weights" or "weights and balances" in other tools or aircraft design. +``` + +## Overview + +Aviary's mass subsystem is designed to accommodate different methodologies, including FLOPS-based and GASP-based approaches, catering to diverse design needs and preferences. The subsystem is divided into multiple components, each handling specific aspects of mass calculation. + +### FLOPS-Based Components + +- **Total Mass Summation:** Orchestrates the calculation of the total mass by summing up contributions from structural, propulsion, systems and equipment, and fuel masses. +- **Structure Mass:** Calculates the mass contributions from the aircraft's structural components like wings, fuselage, landing gear, etc. +- **Propulsion Mass:** Computes the mass related to the aircraft's propulsion system, including engines and associated components. +- **Systems and Equipment Mass:** Determines the mass of systems and equipment on the aircraft, with an alternative calculation option (`AltSystemsEquipMass`) available. +- **Empty Mass:** Represents the total mass of the aircraft without fuel, calculated using either standard or alternative methods. +- **Operating Mass:** Accounts for the mass of the crew, passengers, and service items in addition to the empty mass. +- **Zero Fuel Mass:** The total mass of the aircraft without considering the fuel. +- **Fuel Mass:** Calculates the mass of the fuel required for the mission. + +### GASP-Based Components + +- **Design Load Group:** Establishes design load parameters that influence other mass calculations. +- **Fixed Mass Group:** Deals with fixed masses, like payload and engine mass, that are essential in determining the wing and fuel mass. +- **Equip and Useful Load Mass:** Calculates the equipment and useful load mass, vital for determining the aircraft's operability. +- **Wing Mass Group:** Computes the mass of the wing, influenced by fixed mass group outputs. +- **Fuel Mass Group:** Determines the fuel mass, taking into account design load and fixed mass group parameters. + +## Using the Mass Subsystem + +The choice of which code's methods for mass estimate to use is set using the variable `settings:mass_method`. This variable can be specified in the Aviary input file or can be manually set when using the Level 2 or 3 interface. +To effectively use the mass subsystem in Aviary, users need to provide reasonable estimates for mass-related variables in their aircraft .csv file. +Which variables are used depends on which mass estimation subsystem you're using, such as `aircraft:crew_and_payload:mass_per_passenger`, `aircraft:engine:additional_mass_fraction`, etc. + +Aviary allows for extensive customization and extensions within the mass subsystem. +Users can develop alternative components and integrate them as subsystems with the existing platform. \ No newline at end of file diff --git a/_sources/user_guide/outputs_and_how_to_read_them.md b/_sources/user_guide/outputs_and_how_to_read_them.md new file mode 100644 index 000000000..87672db50 --- /dev/null +++ b/_sources/user_guide/outputs_and_how_to_read_them.md @@ -0,0 +1,109 @@ +# Outputs and How to Read Them + +## Dashboard + +Aviary provides the ability to create a dashboard that lets the user easily browse between the reports and files that are generated during an Aviary run. The dashboard runs locally inside a Web-browser. + +The dashboard is organized into 3 sections: Model, Optimization, and Results. + +The dashboard assumes these locations for the various reports that are embedded into the dashboard. + +| **Section** | **Report name** | **Location** | +|--------------|-----------------------------------------------|--------------------------------------------------------------------------------| +| Model | Inputs | ./reports/*name_of_run_script*/inputs.html | +| Model | Debug Input List | ./input_list.txt | +| Model | Debug Input List | ./output_list.txt | +| Model | N2 | ./reports/*name_of_run_script*/n2.html | +| Model | Trajectory Linkage Report | ./reports/*name_of_run_script*/traj_linkage_report.html | +| Optimization | Driver Scaling Report | ./reports/*name_of_run_script*/driver_scaling_report.html | +| Optimization | Total Coloring Report | ./reports/*name_of_run_script*/total_coloring.html | +| Optimization | Optimization Report | ./reports/*name_of_run_script*/opt_report.html | +| Optimization | SNOPT Output (similarly for other optimizers) | ./reports/*name_of_run_script*/SNOPT_print.out | +| Optimization | Desvars, cons, opt plot | Derived from Case Recorder file specified by `driver_recorder` command option | +| Results | Trajectory Results Report | ./reports/*name_of_run_script*/traj_results_report.html | +| Results | Aviary Variables | Derived from Case Recorder file specified by `problem_recorder` command option | + +As an example of the workflow for the dashboard, assume that the user has run an Aviary script, `test_full_mission_solved_level3`, which records both the `Problem` final case and also all the cases of the optimization done by the `Driver`. (To record both the Problem final case and also the Driver optimization iterations, the user must make use of the `optimization_history_filename` option in the call to `run_aviary_problem`.) + +```bash +python test_full_mission_solved_level3 +``` + +In this example, the case recorder files are named `problem_final_case.db` and `driver_cases.db`, respectively. So after the run is completed, the user could run the dashboard using: + +```bash +aviary dashboard test_full_mission_solved_level3 --problem_recorder=problem_final_case.db --driver_recorder=driver_cases.db +``` + +The resulting dashboard would look something like this: + +![Dashboard](images/dashboard.png) + +## Accessing Variables + +How to get print/access any variable as an output. + +## Reports and Outputs + +### Default Reports + +Each standard Aviary run generates several output files. Which output files are generated depend on the run options. There is always a sub-folder `reports/` that contains a few HTML files. + +- `driver_scaling_report.html` + - This is an OpenMDAO output. After all design variables, objectives, and constraints are declared and the problem has been set up, this report presents all the design variables and constraints in all phases as well as the objectives. + - It lists design variables and constraints and objectives in three different tables. It contains the following columns: name, size, indices, driver value and units, model value and units, ref, ref0, scaler, adder, etc. It contains a Jacobian Info matrix too. + - More details can be found at [openmdao scaling](https://openmdao.org/newdocs/versions/latest/other_useful_docs/om_command.html#om-command-scaling). +- `inputs.html` + - This is a sortable and filterable inputs report of input variables in different phases. + - It contains the following columns: absolute name, source name, source is IVC, source is DV, units, shape, tags, val, min val, and max val. Here, `IVC` is the abbreviation of `IndepVarComp` and `DV` is the abbreviation of "design variable". +- `n2.html` + - This is an OpenMDAO model hierarchy and an N-squared diagram in the shape of a matrix, representing functional or physical interfaces between system elements. It can be used to systematically identify, define, tabulate, design, and analyze functional and physical interfaces. + - More information can be found at OpenMDAO's [N2 Basics](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_basics/n2_basics.html) and [N2 Details](https://openmdao.org/newdocs/versions/latest/features/model_visualization/n2_details/n2_details.html). There is a tutorial on [YouTub e](https://www.youtube.com/watch?v=42VtbX6CX3A). +- `opt_report.html` + - This is the OpenMDAO Optimization Report. It writes a summary of results of an optimization run. + - OpenMDAO reference is at [Optimization Report](https://openmdao.org/newdocs/versions/latest/features/reports/optimization_report.html). +- `total_coloring.html` + - OpenMDAO computes a coloring for the total jacobian. + - More information can be found at [Simultaneous Total Derivative Coloring For Separable Problems](https://openmdao.org/newdocs/versions/latest/features/core_features/working_with_derivatives/simul_derivs.html) and [Simultaneous Coloring of Approximated Derivatives](https://openmdao.org/newdocs/versions/latest/features/experimental/approx_coloring.html). +- `traj_linkage_report.html` + - This is a dymos linkage report. It provides a report detailing how phases are linked together via constraint or connection. It can be used to identify errant linkages between fixed quantities. +- `traj_results_report.html` + - This file contains timeseries and phase parameters in different tabs. + +We will show details of the above reports in [the onboarding docs](../getting_started/onboarding.md). + +OpenMDAO has a reports system which will generate reports when you run your model. More on OpenMDAO reports system can be found [here](https://openmdao.org/newdocs/versions/latest/features/reports/reports_system.html). + +### Database Output Files + +There is an SQLite database output. By default, it is `aviary_history.db`. It can be used to rerun your case though we do not detail that here. Users can write separate Python script to create user customized outputs and graphs. We will show how to use the this database to create user's customized graph in [the onboarding docs](../getting_started/onboarding.md). + +### Relevant Reports + +There is an optimizer output. If `SNOPT` is the optimizer, `SNOPT_print.out` is generated. The SNOPT output is a detailed output of the optimizer performance. New users likely will want to exercise caution when viewing this output, as it includes some advanced information. + +If `IPOPT` is the optimizer, `IPOPT.out` is generated. If `SLSQP` is the optimizer and `pyOptSparseDriver` is the driver, `SLSQP.out` is generated. + +If `debug_mode` is set to `True`, `input_list.txt` and `output_list.txt` are generated. + +You may notice some warning messages in the Aviary output. Frequently seen warnings are: + +- PromotionWarning: Issued when there is ambiguity due to variable promotion (an [OpenMDAO warning](https://openmdao.org/newdocs/versions/latest/features/warning_control/warnings.html)). +- RuntimeWarning: Issued for warnings about dubious runtime features (a [Python warning](https://docs.python.org/3/library/warnings.html)). +- UserWarning: Issued for warnings about potential OpenMDAO, dymos, and/or Aviary problems. +- DerivativesWarning: Issued when the approximated partials or coloring cannot be evaluated as expected (an [OpenMDAO warning](https://openmdao.org/newdocs/versions/latest/features/warning_control/warnings.html)). + +Users should pay attention accordingly. + +When a problem is setup, we can add an argument `check=True`. This is an OpenMDAO feature (see [Setup Your Model](https://openmdao.org/newdocs/versions/latest/features/core_features/running_your_models/setup.html) for more information). If we do, a bunch of checks will be performed. You will see those checks on the command line. + +After a model is run, a `check_partials()` method can be applied and results are printed to the command line. This helps us make sure all of our partial derivatives are correct. We refer users to OpenMDAO's document [Working with Derivatives +Using Finite Difference or Complex Step](https://openmdao.org/newdocs/versions/latest/features/core_features/working_with_derivatives/main.html). + +When Aviary is run, some messages are printed on the command line and they are important. More details are in [the onboarding docs](../getting_started/onboarding.md). + +In addition, users can add their own outputs. + +We will cover more details on all those outputs when we show concrete examples in [the onboarding docs](../getting_started/onboarding.md). + +Discuss when these reports are relevant and in what situations they would be used. diff --git a/_sources/user_guide/pre_mission_and_mission.md b/_sources/user_guide/pre_mission_and_mission.md new file mode 100644 index 000000000..0c9ad8ce7 --- /dev/null +++ b/_sources/user_guide/pre_mission_and_mission.md @@ -0,0 +1,64 @@ +# Pre-Mission and Mission + +Within an Aviary model there are two main types of systems: pre-mission and mission. + +Pre-mission systems are those that are run before the mission analysis and do not vary throughout the mission. +Examples include aircraft geometry, masses of aircraft components, any pre-computed quantities needed for mission systems. +Any quantities within the pre-mission systems are assumed to be constant throughout the mission. + +Mission systems are those that are run during the mission analysis and may vary throughout the mission. +Examples include aerodynamics, propulsion, current mass and velocity of the aircraft, etc. +Any quantities within the mission systems are allowed to vary throughout the mission. + +A nominal diagram showing the pre-mission and mission systems is shown below. + +```{note} +In other works the pre-mission systems are sometimes called "static" and the mission systems are called "dynamic". +Within Aviary we avoid the terms "static" and "dynamic" because they are confusing due to their use in other contexts, such as structural dynamics. +``` + +![Pre-mission vs mission](images/pre_mission_and_mission.svg) + +## Pre-Mission Systems + +Pre-mission systems are run before the mission analysis and are assumed to be constant throughout the mission. +The values in the pre-mission systems _can_ vary during the optimization process. +For example, gross takeoff weight (GTOW) is often a design variable in an aircraft optimization problem. +GTOW does not vary across the mission but it does vary during the optimization process. + +## Mission Systems + +Systems within the mission group of Aviary are the systems that vary during the aircraft's flight trajectory. +This means that the systems are evaluated at each analysis point within the mission analysis. +For example, the aerodynamics subsystem is evaluated at each analysis point to determine the aerodynamic forces and moments acting on the aircraft at that point. +The propulsion subsystem is evaluated at each point to determine the thrust and fuel flow of the propulsion system. + +Systems within the mission group are often vectorized. +This is possible because the systems are evaluated at each analysis point independently of the other analysis points when using {term}`collocation integration methods`. +Within Aviary, the number of mission analysis points is called `num_nodes`. + +## States, Controls, and Parameters + +States, controls, and parameters are the three main types of variables within Aviary that are relevant to the mission analysis. +States are variables that are integrated over the mission analysis. +Controls are variables that are manipulated by the optimizer and are allowed to vary across the mission. +Parameters are variables that are allowed to be controlled by the optimizer (but don't have to be) and are assumed to be constant across the entire trajectory or a single phase, depending on how they're set up. + +## The Bus System in Aviary + +Within Aviary, you might want to connect a pre-mission system to a mission system. +Variables that begin with `'aircraft:'` are connected when you use the `get_parameters()` method within `SubsystemBuilderBase`. +However, you might want to connect a variable from a pre-mission system to a mission system that does not begin with `'aircraft:'`. +For example, you might have a subsystem that has some computations in the pre-mission system that you want to connect to the mission system, but you don't necessarily want to expose those variables to the rest of Aviary. +The bus system is also useful if you have variables that begin with `'aircraft:'` but you don't want them exposed to the rest of Aviary. + +To do this, you can use the "bus" system. +The bus system allows you to connect variables from the pre-mission system to the mission system based on what you specify. +This is especially relevant when you're using external subsystems as core Aviary does not use the bus system internally. +The notion of the bus system is detailed more within the `SubsystemBuilderBase` docstrings. + +## Post-Mission Systems + +Post-mission systems are run after the pre-mission and mission analyses, as expected by the name. +These systems are used to compute any post-mission quantities that are needed, such as landing-related properties, economic models, mission postprocessing, etc. +These systems can use any of the outputs from the pre-mission and mission systems. diff --git a/_sources/user_guide/propulsion.md b/_sources/user_guide/propulsion.md new file mode 100644 index 000000000..74a438c08 --- /dev/null +++ b/_sources/user_guide/propulsion.md @@ -0,0 +1,123 @@ +# Propulsion + +The propulsion subsystem in Aviary organizes and executes models for engine sizing and performance. + +Aviary does not natively model gas-turbine or electric motor performance, and instead relies on user-provided data and/or custom performance models to perform propulsion analysis. + +Aviary supports an arbitrary number of propulsor models on a vehicle, each with their own unique properties such as performance characteristics, scaling behaviors, and number of propulsors for that given type. + +Each unique type of engine is referred to as an engine model. In Aviary, an engine model contains information on how to size and estimate performance for a single instance of an engine of that type. During analysis, Aviary handles summing performance data to a system level. This way, information is available on the performance of both a single instance of an engine, as well as aircraft-level totals, for other Aviary subsystems to utilize. + +## Engine Decks + +The built-in way Aviary handles engine performance is by interpolating tabular data from a user-defined file that describes performance characteristics for a given engine. Engines modeled in this manner are called engine decks. Engine decks are a type of engine model - they use the same basic interface, but have additional functionality to handle reading and processing data files. + +### Formatting +An engine deck data file requires specific formatting for Aviary to correctly interpret. These files must follow the [Aviary data file format](input_files).An example of a properly-formatted engine deck can be found [here](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/models/engines/turbofan_22k.deck). + +### Variables + +The following engine performance parameters are supported natively by Aviary for use in engine decks. If units are not specified, the default units are assumed. A variety of alternate names for these variables are understood by Aviary, but it is recommended to use the official names given here. A column with a header not recognized by Aviary will be ignored, with a warning raised at runtime. This allows for variables not used by Aviary to still be included in a data file, either for reference or compatibility with another analysis tool. + + +| Variable | Default Units | Required? | +| :--- | :--- | :---: | +| `Mach Number` | unitless | ✔ | +| `Altitude` | ft | ✔ | +| `Throttle` | unitless | ✔ | +| `Hybrid Throttle` | unitless | ✘ | +| `Net Thrust` | lbf | ✔* | +| `Gross Thrust` | lbf | ✘ | +| `Ram Drag` | lbf | ✘ | +| `Fuel Flow Rate` | lbm/h | ✘ | +| `Electric Power` | kW | ✘ | +| `NOx Rate` | lbm/h | ✘ | +| `T4 Temperature` | degR | ✘ | + +**`Net Thrust` (defined as `Gross Thrust` - `Ram Drag`) is not required if both of those variables are provided for calculation* + +`Mach Number`, `Altitude`, and the two throttle parameters are independent variables required to describe the operating conditions of the engine. `Hybrid Throttle` is optional, and is intended for use as a second degree of control for engines using independently controllable fuel- and electric-based power. The remaining variables are dependent on the operating conditions and are therefore typically optional. + +Engine decks without headers are assumed to contain only the required variable set, in the order specified by the table (`Mach`, `Altitude`, `Throttle`, and `Net Thrust`), and with default units. + +Comments may be added to an engine deck data file by using a '`#`' symbol preceding the comment. Anything after this symbol on that line is ignored by Aviary, allowing the user to temporarily remove data points or add in-line comments with context for the data. It is good practice to include comments at the start of the file to explain what kind of engine the data represents, and where it came from. + +## Setting Up Propulsion Analysis + +### Beginner Guide + +To add an engine deck to Aviary, the minimum set of variables to describe it must be provided in your input file. This list includes: + +* `Aircraft.Engine.DATA_FILE` +* `Aircraft.Engine.SCALE_PERFORMANCE` +* `Aircraft.Engine.IGNORE_NEGATIVE_THRUST` +* `Aircraft.Engine.GEOPOTENTIAL_ALT` +* `Aircraft.Engine.GENERATE_FLIGHT_IDLE` +* `Aircraft.Engine.NUM_WING_ENGINES` and/or `Aircraft.Engine.NUM_FUSELAGE_ENGINES` + + + + + +If generating flight idle points is desired, the following variables are also required. More information on flight idle generation is available here . + +* `Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION` +* `Aircraft.Engine.FLIGHT_IDLE_MIN_FRACTION` +* `Aircraft.Engine.FLIGHT_IDLE_MAX_FRACTION` + +If you are missing any required variables, you will see a warning at runtime. Aviary will try using the default value for the missing variable, which may affect analysis results. + +```bash +UserWarning: is a required option for EngineDecks, but has not been specified for EngineDeck . The default value will be used. +``` + + + + + +### Intermediate Guide + +Engine models are defined in Aviary using an `EngineModel` object. An `EngineModel` is responsible for handling many tasks required to prepare an engine for use in Aviary, such as reading engine data from a file in the case of an `EngineDeck` (which is a child class of `EngineModel`). + +An `EngineModel` (and classes inheriting it) can be manually created and added to the Aviary problem. This is extremely useful when setting up an aircraft with multiple engine types, each with unique properties, or using a custom engine model. An `EngineModel` requires an `AviaryValues` object containing the variables required for that engine (such as those outlined in the Beginner Guide example for `EngineDecks`). + + +```python +import aviary.api as av + +engine_options = av.AviaryValues() +# Add relevant inputs and options to engine_options +# using engine_options.set_val(...) + +engine_model = av.EngineModel(name='example', + options=engine_options) +``` + +Once an `EngineModel` has been created, it must be added to the Aviary analysis you want to perform. The simplest way to do this is to take advantage of the propulsion preprocessor utility. This preprocessor handles all of the details of getting data related to `EngineModels`, which may change during initialization, correctly set up in the `AviaryValues` object which is used to define the vehicle at the Aviary problem level. + +```python +aviary_options = av.AviaryValues() +# It is assumed here that aviary_options is configured to have +# all inputs needed for analysis, except engine-level values + +av.preprocess_propulsion(aviary_options=aviary_options, + engine_models=[engine_model]) +``` + +In this example, *aviary_options* is modified in-place with updated values from *engine_model*, as well as properly configuring engine-related variables into vectors. When working with multiple engines, simply provide `preprocess_propulsion()` with a list of all `EngineModels`, like so: + +```python +av.preprocess_propulsion(aviary_options=aviary_options, + engine_models=[engine_model_1, + engine_model_2]) +``` + +The propulsion preprocessor is also capable of creating an `EngineDeck` based on existing inputs in the provided `AviaryValues` object and add it to the analysis, which is what is done behind-the-scenes in the Level 1 interface. To use the preprocessor in this way, simply do not provide an `EngineModel` to the function: + +```python +av.preprocess_propulsion(aviary_options=aviary_options) +``` + +### Advanced Guide + +This section is a work in progress. Please check back later for more information. diff --git a/_sources/user_guide/step_by_step_external_guide.md b/_sources/user_guide/step_by_step_external_guide.md new file mode 100644 index 000000000..9ebc812d2 --- /dev/null +++ b/_sources/user_guide/step_by_step_external_guide.md @@ -0,0 +1,108 @@ +# Step-by-step guide for creating, testing, and using external subsystems + +## How to plan for your subsystem integration + +You need to determine if your subsystem has a pre-mission aspect, a mission aspect, post-mission aspect, or any combination of these. +For example, if you are sizing a part of the aircraft, you might only need the pre-mission systems. +But if you're trying to track the performance of a dynamic variable -- something that varies across the mission -- you'd want to add a dynamic aspect. +The most common and general subsystems have both pre-mission and mission systems. + +The external subsystem interface allows you to provide OpenMDAO Systems (Groups or Components) for the pre-mission, mission, and post-mission parts of Aviary. +You'll want to consider which parts of your model should live where. + +It helps to diagram your model and break it down into `pre-mission`, `mission`, and `post-mission` systems that you'll need. +I find XDSM diagrams very helpful for doing this as they have prescribed and clear formats that you can easily share with others. +See [this video](https://www.youtube.com/watch?v=yutKRwIL3BA) for more information on understanding and creating XDSM diagrams. +Specifically think about the inputs and outputs to each one of these systems and what needs to be exposed to Aviary. + +1. For `mission` systems, these would include anything that occurs during the flight of the aircraft. Thus, if you have n nodal mission analysis points, this system would be analyzed n times per mission. An example of mission systems include batteries, propulsion, sensors, thermal systems, and anything that varies in time. +2. `pre-mission` systems include anything that happens before a mission is analyzed. This includes weights, structures, geometry, other one-time-per-optimization iteration analyses. `pre-mission` also includes anything associated with pre-flight systems. For example, if your takeoff analysis is analytic instead of mission-based, it would live here. +3. `post-mission` systems are evaluated after the mission is analyzed. This is useful for anything that needs the mission timeseries information, including acoustics, emissions, costs, etc. + +## Define variables for Aviary to use + +Next up, define the variables that you will need for your model. You can use any sort of variables internally within your model, but if you want Aviary to know about the variables you must define them in a specific way. Specifically, if you use the Aviary naming convention of `'aircraft:...'` or `'mission:...'` and promote them out of your system, then other Aviary subsystems can see and use those values. + +If your subsystem does not need to tell Aviary about any new variables (i.e. all of the variables that your system will use within Aviary already exist in Aviary itself), then you can skip this step. You will not need to add any variable or metadata info. + + + +1. First, view the [battery_variables.py file](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/battery/battery_variables.py) to see an example of the variable hierarchy we use in Aviary. You can also look at the [core Aviary variables](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/variable_info/variables.py) to see what's available already. You can add any arbitrary system as a subclass within here. Items that define aircraft properties should go within `Aircraft` whereas any variables pertaining to the `Mission` should exist there. + + These variable names are what's used within the OpenMDAO system that Aviary uses. This sort of hierarchy is a purposeful design choice to make it clear what values live where, which subsystem they belong to, and that they are named the same between different systems. Additionally, we recommend including the legacy name of any variable you add that so that users of your builder will know how the variable names map to existing analyses. + + + +2. Now, with the variable names defined, we need to define variable metadata. Variable metadata helps Aviary understand your system. It also helps humans understand what units, defaults, and other values your variables use. Check out the [battery metadata example](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/battery/battery_variable_meta_data.py) as well as the [core Aviary metadata](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/variable_info/variable_meta_data.py). + + When you define your variable metadata, you'll use the same names you just defined. With those names, you'll provide units, a brief description, and default values. You're not locking yourself into specific units here, but by providing units then Aviary can convert the values behind-the-scenes to whatever units are actually used in the code. Users can input variables in any units that can be converted to those units prescribed in the metadata. + +## Making OpenMDAO groups for your subsystem + +Once you've diagramed your model and defined your variables, create OpenMDAO Groups for each of the systems you need. Some disciplinary models may only need `pre-mission` systems, whereas others may need a different subset of these three possible systems. If you're using a tool that already provides models in the OpenMDAO framework, you won't have much (if any!) work to do here. + +If you haven't yet used OpenMDAO, definitely dig into [its docs](http://openmdao.org/twodocs/versions/latest/main.html) or talk to somebody who has worked with it. These groups will be what Aviary adds to its own model. + +To use gradient-based optimization in an efficient way, it greatly benefits you to provide derivatives for your model. It's not strictly necessary, but the core Aviary tool has efficient derivative computations throughout. To take full computational advantage of this, your OpenMDAO models should also compute derivatives. + +## Using the SubsystemBuilderBase class + +Now we'll create your subsystem builder. This is arguably the most important step since it exposes your model to Aviary using a consistent interface. The main idea surrounding the subsystem builder is that subject matter experts (you!) will create a specialized Python class that defines specific methods needed by Aviary to integrate your subsystem. I'll walk you through this process now, but don't worry -- we also have some tests to help ensure your subsystem builder is set up correctly. + +1. First, let's work out some ground rules of the subsystem builder. You'll inherit from `SubsystemBuilderBase` when you create your builder. This base class features *all* methods used by Aviary, even if your specific subsystem doesn't need them (this varies on a subsystem to subsystem basis). +2. Most all of these methods are documented in-line, as well as on the doc page. I hope that you can follow those and understand what to do with your model, but if you can't, please let us know your questions and we'll rework these docs. +3. These methods can be roughly divided into three broad categories (shown in the graphic below): + + 1. Defining your subsystem + 2. Telling Aviary about your design problem + 3. Helping Aviary handle your subsystem + + Each one of these categories is only a notional way of organizing the methods, but I find it helpful to explain their general purposes. + +![subsystem methods](images/external_subsystem_methods.png) + +To integrate external subsystems into Aviary, you need to use the [`SubsystemBuilderBase` class](../user_guide/subsystems.md) as a template for creating your builder object. +This class provides you with skeletal methods that you replace to specify the behavior of your subsystem. +The methods you should implement depend on what type of subsystem you're building. + +## Testing your builder and ensuring it's behaving as intended + +Okay, now we should test your subsystem builder to make sure it's providing the correct outputs to Aviary. You don't have to put it into Aviary (yet!) to do this. Look at the [`test_battery_builder.py` file](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/battery/test_battery_builder.py) to see how to test your subsystem. This is also detailed in the [battery subsystem example](battery_subsystem_example) doc page. + +If everything goes well then those tests passed. If they didn't, you should get some info about your builder that you can use to fix any bugs or errors. + +This test probably won't catch *everything* that could go wrong when interfacing your model with Aviary, but hopefully it catches the basic problems. If you reach an error that the test doesn't help you with or it's not clear what you need to do to fix your builder, please let us know! + +## Using your builder within Aviary + +Awesome. Let's keep going and start to discuss using these subsystems within Aviary. The overarching idea is that now that you have a subsystem builder, you can pass an instantiation of this builder object to Aviary via the `phase_info` dictionary. Take a look at [`run_cruise.py`](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/battery/run_cruise.py) and [`run_multiphase_mission.py`](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/battery/run_multiphase_mission.py) to see how we do this for the battery model. Specifically, here are the relevant lines of code from the `run_cruise.py` file: + +```python +battery_builder = BatteryBuilder() + +phase_info = { + 'pre_mission': { + 'include_takeoff': False, + 'external_subsystems': [battery_builder], + 'optimize_mass': False, + }, + 'cruise': { + ... + 'external_subsystems': [battery_builder], + ... + } + }, + ... +``` + +Those additional `'external_subsystems'` entires are where you add your subsystem instances. Let's go through that step-by-step now. + +1. **Add the `external_subsystems` list to your mission phases.** For each disciplinary subsystem you're adding, add them to the `external_subsystems` list. Each phase has its own `external_subsystems` list and this is on purpose. You may only care about your subsystem within a particular portion of the aircraft flight, or maybe you care about your subsystem throughout the entire flight. By defining the external subsystems on a phase-by-phase basis, you have exquisite control over where they're added to Aviary. This is especially helpful for more computationally expensive subsystems. + +2. **Add any `external_subsystems` to your pre- and post-mission phases too.** If you have pre- or post-mission analyses in your subsystem, make sure to add the `external_subsystems` list to the `pre_mission` and `post_mission` sub-dicts within the `phase_info` dict. This means that Aviary will build and use those systems before or after the mission; otherwise Aviary won't know to put the systems there. + +3. **Start with a simple mission in Aviary.** To begin, try adapting the [`run_cruise.py`](https://github.com/OpenMDAO/om-Aviary/blob/main/aviary/external_subsystems/battery/run_cruise.py) script to use your subsystem. Replace the `BatteryBuilder()` instance with your subsystem, for example. You might need other setup or inputs based on the complexity of your model. But in general, it helps to start with the simplest mission you can. In this case, that's probably a steady level cruise flight. + + Even though this is a "simple" mission, there's still a lot that can go wrong. It turns out that designing an aircraft is challenging sometimes. I don't expect your mission optimization to converge well your first try; it often takes some debugging and digging to get your subsystem integrated well. It's really challenging to write docs to help you do this without knowing more about your system, what it's trying to do while the aircraft is flying, and what you've already checked. That being said, make sure to reach out if you're encountering problems here. + +4. **Move on to a multi-phase mission.** If you're able to get a cruise-only mission converging well with your subsystem, next we should move on to a multiphase mission that features takeoff, climb, cruise, descent, and landing. This is much more representative of true aircraft performance (obviously) and generally puts your subsystem model to the test. This also introduces the idea of linking variables between mission phases, which introduces additional complexity to the model. For instance, your battery's charge at the end of climb needs to match the battery's charge at the beginning of cruise. Details like this can be tricky depending on your subsystem, so again this step often involves some debugging. diff --git a/_sources/user_guide/subsystems.md b/_sources/user_guide/subsystems.md new file mode 100644 index 000000000..d5441dbac --- /dev/null +++ b/_sources/user_guide/subsystems.md @@ -0,0 +1,44 @@ +# SubsystemBuilderBase + +## Method Overview + +Here is a brief overview of the available methods that are used in the `SubsystemBuilderBase` object. +The docstrings within this builder base class go into much more detail. +This overview is automatically generated from the docstrings in the builder base class. + +We'll now detail where in the Aviary stack each one of these methods is used. +Understanding this can be helpful for knowing which parts of the Aviary problem will be impacted by your subsystem. +In the following outline, the methods listed at the top-level are defined in `methods_for_level2.py` and are called in this order to run an Aviary problem. +Any sub-listed method is one that you can provide with your subsystem builder, showing where within the level 3 method hierarchy that subsystem method gets used. + +- `load_inputs` - loads the aviary_values inputs and options that the user specifies. +- `check_and_preprocess_inputs` - checks the user-supplied input values for any potential problems. + - `preprocess_inputs` +- `add_pre_mission_systems` - adds pre-mission Systems to the Aviary problem + - `get_mass_names` + - `build_pre_mission` +- `add_phases` - adds mission phases to the Aviary problem + - `get_states` + - `get_constraints` + - `get_controls` + - `get_parameters` + - `build_mission` +- `add_post_mission_systems` - adds the post-mission Systems to the Aviary problem + - `build_post_mission` +- `link_phases` - links variables between phases + - `get_linked_variables` + - `get_bus_variables` +- `add_driver` - adds the driver (usually an optimizer) +- `add_design_variables` - adds the optimization design variables + - `get_design_vars` +- `add_objective` - adds the user-selected objective +- `setup` - sets up the Aviary problem + - `get_outputs` + - `define_order` +- `set_initial_guesses` - sets the initial guesses for the Aviary problem + - `get_initial_guesses` +- `run_aviary_problem` - actually runs the Aviary problem + +```{note} +Understanding the flow of the above methods and how the subsystem methods are used within Aviary is pretty important! Make sure to review these methods and where in the stack they're used before digging too deep into debugging your subsystem. +``` diff --git a/_sources/user_guide/troubleshooting.md b/_sources/user_guide/troubleshooting.md new file mode 100644 index 000000000..1a8770efb --- /dev/null +++ b/_sources/user_guide/troubleshooting.md @@ -0,0 +1,63 @@ +# Troubleshooting + +## Building Understanding + +A fantastic feature of Aviary is the fact that you can construct ridiculously complex coupled aircraft-mission design problems that span multiple disciplines and fidelities. +However, this can also be a curse. +When you're first starting out with Aviary, it can be difficult to understand why your model is behaving the way it is. +This section will discuss some strategies for building up an understanding of your model and how to troubleshoot when things aren't working as expected. + +````{margin} +```{note} +It'd be wonderful if optimization allowed you to press one button and create the best aircraft. Unfortunately, that's not the case. We still need engineering intuition and understanding to build good models and interpret results. +``` +```` + +A valuable resource that we've already developed is the [Debugging your optimizations](https://openmdao.github.io/PracticalMDO/Notebooks/Optimization/debugging_your_optimizations.html) content from the [Practical Multidisciplinary Design Optimization](https://openmdao.github.io/PracticalMDO/) course. +This video and notebook discuss how to build up an understanding of your optimization model in a general sense. + +This doc page will discuss how to build up an understanding of your Aviary model in particular. + +### Understand your subsystem models + +The first step in building up an understanding of your complete model is to understand the subsystem models you're using. +For example, if you're using an engine deck for the propulsion model, plotting the thrust and fuel flow as a function of Mach number and altitude can be a great way to understand how the engine will behave. +Similarly, if you're using a battery model, plotting the battery state of charge as a function of time with the expected power draw can be a great way to understand how the battery will behave. + +Without a thorough understanding of your subsystem models, it will be nearly impossible to understand how and why the optimizer is making certain decisions. +Famously, optimizers are very good at finding parts of the model space that are poorly defined and exploiting them in pursuit of minimizing the objective. + +### Start with a simple mission + +The first step in building up an understanding of your model is to start simple. +This might sound straightforward, but you should start with a simple aircraft model and a simple mission. +For example, if you want to eventually model a hybrid-electric aircraft flying a fully optimized trajectory, you might want to start with a simpler mission where the climb rate and cruise altitude are fixed. +Once you get good results with the simple mission and understand the results, you can start adding complexity and flexibility. + +### Interpreting optimized results + +Once you've built up an understanding of your model and have successfully performed optimization, you can start to interpret the results. +This is where a mix of aircraft engineering knowledge and optimization knowledge is extremely helpful. + +First, examine the exit code of the optimizer. +If the optimizer exited with a non-zero exit code, it means that the optimizer did not converge well to a solution. +This could be due to a number of reasons, such as the prescribed constraints being unsatisfiable or that the optimizer had numerical difficulties finding the optimum. + +In the event of non-convergence, you should see if you are solving the simplest relevant optimization case for your studies. +If you aren't, it's beneficial to start with the simplest case and build up complexity until you find the source of the non-convergence. + +If the optimizer exited with a zero exit code, it means that the optimizer converged to a solution. +Now you can start to interpret the resulting trajectory and aircraft design. + +Aviary provides a number of reports to help you interpret the results, including the `opt_report.html` and `traj_results_report.html`. + +The `opt_report.html` shows you the final values of the design variables, constraints, and objective, along with the corresponding bounds for each value. +This is helpful in determining which design variables are at their limits as well as which constraints are driving the design of the aircraft. + +The `traj_results_report.html` shows you plots of the trajectory variables as a function of time. +Specifically, you can look at the altitude and Mach profiles to see if the aircraft flight is in line with what you expected. +You can also view any tracked state variables, such as the battery state of charge, to see if the subsystems are behaving as expected. + +## Ensuring Subsystems Compatibility + +This section is under development. diff --git a/_sources/user_guide/user_interface.md b/_sources/user_guide/user_interface.md new file mode 100644 index 000000000..b9c5dd1ec --- /dev/null +++ b/_sources/user_guide/user_interface.md @@ -0,0 +1,21 @@ +# Aviary User Interface + +![three Aviary levels](images/levels.png) + +Aviary's user interface is designed to provide a seamless transition between different levels of complexity, allowing users to adapt and progress based on their needs and expertise. +The levels build upon one another, with each level incorporating the methods and capabilities of the previous level. +We'll explore how the levels are interconnected, but first let's describe the levels in broad strokes using a Lego-based metaphor. + +Level 3 is like a huge pile of Legos. +You can build anything you want with it, but you have to know how to use the Legos; there are no instructions. +This is using the pieces of Aviary to build your own analysis or optimization model. + +Level 2 is like a Lego set with instructions, but it's those late 80s/90s instructions where the steps aren't necessarily clear. +You have more flexibility in choosing how you assemble the Legos, but you have some guide rails and reasonably clear instructions. +Most anything you would do in Level 3 you can do here, you just might have slightly less flexibility in how you do it because we've established an API and some assumptions. + +Level 1 is like a modern-day Lego set where the instructions are very clear and you have a limited number of Legos to work with. +You can build a lot of different coupled aircraft-mission optimization problems, but you don't have much flexibility in how you do it. + +Maybe this metaphor is helpful for you. +Regardless, let's dive into the details of each level. \ No newline at end of file diff --git a/_sources/user_guide/using_external_subsystems.md b/_sources/user_guide/using_external_subsystems.md new file mode 100644 index 000000000..07b7a8b38 --- /dev/null +++ b/_sources/user_guide/using_external_subsystems.md @@ -0,0 +1,60 @@ +# Using external subsystems + +Aviary has the ability to include user-defined external subsystems within its mission analysis and optimization processes. +This doc page explains what these subsystems are, how to write a builder object that Aviary uses, and details the methods that you need to provide to use external subsystems. + +If you are using or developing external subsystems in Aviary, you should absolutely read this doc page! + +```{note} +The external subsystem integration process in Aviary is under active development. Expect some APIs and expectations to change, and we gladly accept any feedback or suggestions. +``` + +## Breaking down the flow of Aviary systems + +Throughout the process of using external subsystems, we will reference a few of the internal processes that Aviary uses. +Specifically, the pre-mission, mission, and post-mission systems within Aviary are important to understand when using external subsystems. +You can add OpenMDAO systems (groups or components) to any of the three main systems within Aviary, as shown in the graphic below. + +![Aviary process](images/aviary_process.png) + +## What do we mean by external subsystems? + +In Aviary, a subsystem is simply an openMDAO component or group that is self-contained, and therefore modular. Subsystems typically capture physics related to a traditional discipline (such as aerodynamics or propulsion) but are not restricted to particular topics. Aviary comes with the following discipline analysis, referred to as "core subsystems": +- geometry +- mass +- aerodynamics (table-based or empirically computed) +- propulsion (table-based) +- flight dynamics / equations of motion (height energy or 2-DOF) + +Aviary allows for integration with arbitrary subsystems beyond the included low-fidelity subsystems. +These could be disciplinary models to do with batteries, structural models, acoustics, or anything to do with aircraft. +The user can provide builder objects for these new subsystems and Aviary will loop through them to add to the model. +Aviary handles the integration for these systems across the aircraft's trajectory so we can track state variables and aircraft performance. + +Core subsystems and external subsystems are created using the same code infrastructure: the [`SubsystemBuilderBase` object](../user_guide/subsystems.md). This makes swapping out a core Aviary subsystem with an external one relatively straightforward, as they share the same interface. + +Some examples of disciplines that would fall under the "external subsystem" category include: + +- acoustics +- battery modeling +- motor modeling +- structural analyses +- thermal management systems +- sensor packages +- and many more! + +More detailed instructions on creating an external subsystem and integrating it into Aviary can be found [here](./step_by_step_external_guide.md). Wrapping external models in OpenMDAO and creating builders for them can be challenging. To help alleviate this burden on users, the Aviary team is continually developing and sharing external subsystems in the `aviary/examples/external_subsystems` folder. + +## Clarifying subsystems in Aviary and their fidelity levels + +Next, we want to graphically show a notional breakdown of subsystems in Aviary and potential subsystems that can be added by users. +Lower fidelity analyses are at the bottom of this figure with higher fidelity analyses at the top. +Subsystems contained in green boxes are those provided in core Aviary and subsystems in light orange are ones that users can define subsystems for and integrate within Aviary. +Any of the subsystems in light orange are not developed by NASA; instead they'd be developed by users of Aviary. +All hooks and capabilities needed by users for these subsystems would need to be added by the users. + +This graphic is notional and is not meant to be exhaustive or exact. +Specifically, any arbitrary disciplinary subsystem can be added to Aviary; it is not limited to those shown here. +Additionally, there are many more types of analyses that could be included on this graph, at all sorts of different fidelity levels. + +![fidelity levels](images/subsystems.png) diff --git a/_sources/user_guide/variable_hierarchy.ipynb b/_sources/user_guide/variable_hierarchy.ipynb new file mode 100644 index 000000000..c0a54118c --- /dev/null +++ b/_sources/user_guide/variable_hierarchy.ipynb @@ -0,0 +1,282 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Understanding the Variable Hierarchy\n", + "## How Variable Hierarchies Work\n", + "Aircraft models in Aviary usually consist of hundreds of different variables representing different aspects of the physical aircraft, behavior of the model, behavior of the mission, etc. Managing and properly connecting all those variables requires a simple framework within which we can interact with several variables at once. The idea of variable hierarchies meets this need for a simple variable framework and breaks all the variables of a model up into smaller controllable categories. \n", + "\n", + "The variable hierarchy itself is rather simple. The variables are broken up into separate high level categories and each category becomes its own top-level class. Within that class we create \"inner classes\" (classes which are an attribute of a higher level class) that encompass a more specific category. If needed, secondary inner classes within an inner class may be created, and so on until the desired detail depth is achieved. However, too many layers down and the tedium will outweigh any value gained through specificity. \n", + "\n", + "These classes and inner classes are not used for any sort of complex coding functionality. Instead they simply serve to house model variables themselves. Each class and inner class can have variables assigned to it (in object-oriented speak, the variables become an attribute of the class or inner class), and each variable assigned to a class or inner class corresponds 1-to-1 with a variable needed for the model. The variables in each class are really just identifiers that point to the actual variable name in the model. The value assigned to each variable in the classes is a string that is the name of that variable in the actual model. That string is the variable name that OpenMDAO will see, despite the fact that the user will rarely call the variable by that name. Instead the user will refer to a variable name by its hierarchy variable (eg. referring to `'aircraft:wing:span'` as `Aircraft.Wing.SPAN`) to make it easier to autofill the variable and also to allow more uniform and controlled access to the variable names themselves.\n", + "\n", + "Below is an example of a simple variable hierarchy that includes basic information for an aircraft:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "class Aircraft:\n", + " class Fuselage:\n", + " DIAMETER = 'aircraft:fuselage:diameter'\n", + " LENGTH = 'aircraft:fuselage:length'\n", + "\n", + " class HorizontalTail:\n", + " CHORD = 'aircraft:horizontal_tail:chord'\n", + " SPAN = 'aircraft:horizontal_tail:span'\n", + "\n", + " class LandingGear:\n", + " CONFIGURATION = 'aircraft:landing_gear:configuration'\n", + " MASS = 'aircraft:landing_gear:mass'\n", + "\n", + " class VerticalTail:\n", + " CHORD = 'aircraft:vertical_tail:chord'\n", + " SPAN = 'aircraft:vertical_tail:span'\n", + "\n", + " class Wing:\n", + " CHORD = 'aircraft:wing:chord'\n", + " SPAN = 'aircraft:wing:span'\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This code snippet is a notional example of how an overly simple hierarchy looks. In this example the variables all have a depth of three, meaning that all the variables are referred to in three tiers: `Aircraft.Fuselage.LENGTH`, `Aircraft.HorizontalTail.CHORD`, `Aircraft.Wing.SPAN`, etc. The variable names in this hierarchy can actually be used to access the values of those variables in an Aviary model, assuming that the hierarchy has been properly provided to the Aviary model. Below is an example of using a variable hierarchy variable in the `add_aviary_input()` and `add_aviary_output()` functions to add inputs and outputs to an OpenMDAO component for use in Aviary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import openmdao.api as om\n", + "import aviary.api as av\n", + "\n", + "class AviaryExampleComponent(om.ExplicitComponent):\n", + " def setup(self):\n", + " \n", + " av.add_aviary_input(self, Aircraft.VerticalTail.CHORD, val=4, units='ft', desc='chord of the vertical tail')\n", + " av.add_aviary_output(self, Aircraft.VerticalTail.SPAN, val=0, units='ft', desc='span of the vertical tail')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this code snippet the variables `Aircraft.VerticalTail.CHORD` and `Aircraft.VerticalTail.SPAN` from the variable hierarchy are used in the `add_aviary_input` and `add_aviary_output` functions to represent the actual variable names, which are `aircraft:vertical_tail:chord` and `aircraft:vertical_tail:span` respectively. The point being illustrated here is that you can use the variables from these variable hierarchies just as you would use their string-valued variable names, and in fact you *must* use the variable hierarchy variable and *not* the string-valued variable name. This way, if a change is made to the string-valued variable name in the hierarchy, that change is automatically reflected throughout all your code.\n", + "\n", + "## The Aviary-core Variable Hierarchies\n", + "While the idea of a variable hierarchy can be created and used on its own, Aviary-core provides two specific variable hierarchies that are necessary for Aviary-core systems and which follow both the rules of convention and the rules of programmatic necessity laid out above. The two hierarchies provided by Aviary-core are `Aircraft` and `Mission`. `Aircraft` houses all variables that have to do with physical aspects of the aircraft, as well as all variables that do not affect the mission or change in time. This includes several variables that are options in the model instead of inputs or outputs. `Mission` on the other hand houses all variables that reference the mission or change in time. This includes things such as `Mission.Design.CRUISE_ALTITUDE` and `Mission.Design.RANGE` as well as things such as objectives for the optimization, parameters at various phases of flight, etc. The `Aircraft` and `Mission` hierarchies are the only hierarchies provided by Aviary-core, and they are both necessary for the successful running of various Aviary subsystems. Whatever additional or extended variable hierarchies have been created by the user, the end hierarchy *must* include the variables from the `Aircraft` and `Mission` hierarchies in the Aviary core, and these variables must not be altered. We offer more information below on extending and merging together variable hierarchies.\n", + "\n", + "For a complete list of the variables included in the Aviary-core hierarchy visit [List of Aviary Variables](../misc_resources/variable_list.ipynb). The hierarchies themselves are located [here](https://github.com/OpenMDAO/Aviary/blob/main/aviary/variable_info/variables.py) in the repository and can be accessed in this way:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "Aircraft = av.Aircraft\n", + "Mission = av.Mission" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conventions and Requirements of the Variable Hierarchies\n", + "There are some conventions surrounding the variable hierarchy that are required, and other things that are purely convention. Below is a list of the programmatically required aspects of the variable hierarchy:\n", + "- Avoiding periods in the string-valued variable names is a must. Periods that are included here will end up as periods in an OpenMDAO variable name which will throw an error.\n", + "- Including a colon after the first word in the string-valued variable name is also a must. The expressions `promotes=[\"aircraft:*\"]` and `promotes=[\"mission:*\"]` appear frequently within Aviary, and if these colons are not included variables will not get properly connected, leading to hard-to-detect errors.\n", + "\n", + "Conversely, other things are merely convention that the Aviary team follows. Below is a list of the conventions that are *not* programmatically required:\n", + "- Inner classes and variables are all organized alphabetically within a hierarchy. This is optional, but we follow this convention within the Aviary-core variable hierarchy to preserve cleanliness.\n", + "- All variables in the hierarchy have a depth of 3. This is optional, but again we follow this convention within the Aviary-core variable hierarchy to preserve cleanliness and uniformity of code.\n", + "- Including colons after all words in the string-valued variable name is optional. As stated above, it is a must after the first word for use in promotion statements, but after that it is purely a choice of convention to preserve clarity.\n", + "\n", + "It is prudent at this point to pause and explain what is meant by *hierarchy type*. This is not a technical coding in term, instead *type* is an explanatory term that we use to describe the classification of a hierarchy. A hierarchy's type is its high level category. For example, a hierarchy of the `Aircraft` type would be a hierarchy that houses the variables that have to do with the physical aspects of an aircraft, and a hierarchy of the `Mission` type would be a hierarchy that houses the variables which reference the mission or change in time. These are the only two types of hierarchies that are provided in Aviary-core, however, other types are possible, such as a `Fleet` type hierarchy describing the variables that affect an entire fleet of aircraft, an `AirTrafficControl` type hierarchy describing all the variables having to do with air traffic control, etc. The concept of the `Aircraft` and `Mission` type hierarchies will be used throughout the rest of this article.\n", + "\n", + "\n", + "## Building Your Own Hierarchy\n", + "The Aviary-core provides the pre-built variable hierarchies listed above. However, for the user that would like to add external subsystems to Aviary, the variables in the Aviary-core hierarchies may not be sufficient. In this case, there are three options: 1) extend the existing variable hierarchies from Aviary-core, 2) create your own variable hierarchies and merge them with the existing hierarchies from Aviary-core, 3) do a combination of #1 and #2. Extending a creating your own variable hierarchies are addressed below.\n", + "\n", + "### Extend the Existing Aviary-core Hierarchies\n", + "If you are just adding one external subsystem to an Aviary-core model, or if you are adding multiple subsystems all being developed in the same location by the same person, our suggested path is to create one extension of the Aviary-core hierarchies. The method to extend the Aviary-core variable hierarchies is to subclass those hierarchies (which preserves all the data from the original hierarchies) and add your own additional variables as necessary. To take a simple example, let's say we wanted to add a little bit of detail to the existing `Aircraft` variable hierarchy for our external subsystem. The detail we would like to add is some information about the flaps on the wing as well as a jury strut and a center of gravity location. We would extend the existing variable hierarchy using the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "AviaryAircraft = av.Aircraft\n", + "\n", + "class Aircraft(AviaryAircraft):\n", + "\n", + " CG = 'aircraft:center_of_gravity'\n", + "\n", + " class Wing(AviaryAircraft.Wing):\n", + " class Flap:\n", + " AREA = 'aircraft:wing:flap:area'\n", + " ROOT_CHORD = 'aircraft:wing:flap:root_chord'\n", + " SPAN = 'aircraft:wing:flap:span'\n", + "\n", + " class Jury:\n", + " MASS = 'aircraft:jury:mass'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are a few things to notice about this code. The first is that, unlike the Aviary-core `Aircraft` variable hierarchy, this hierarchy has variables with a depth of two and a depth of four. When we extend the Aviary-core variable hierarchies we are not restricted to the depth of three that the core hierarchies have. The second thing to notice is that when we extend an inner class that already exists in the Aviary-core hierarchy (`Wing`) we subclass the inner class from the Aviary-core so that we can preserve all the information from that Aviary-core inner class. However, in the case of the inner class `Jury` which does not already exist in the Aviary-core hierarchy, there is nothing to subclass, and thus that inner class stands on its own.\n", + "\n", + "When extending the Aviary-core variable hierarchies, you can create one extension of each type of hierarchy, or you can create multiple extensions of each type which will eventually be merged together. If you are developing only one external subsystem or all your subsystems are being developed in the same place by the same person, one extension of each Aviary-core hierarchy should suffice. However, if you have multiple developers working on different subsystems in different locations, each developer may want to create their own extension. To aid in this case, Aviary provides the capability to merge together multiple hierarchies of the same type into one hierarchy of that type. More information on this capability is shown at the bottom of this page.\n", + "\n", + "### Creating Your Own Variable Hierarchy\n", + "It is possible to create your own variable hierarchy that is not an extension of the Aviary-core variable hierarchies, but there are specific things to know. The use case for this is mostly when you would like to create a third hierarchy that does not fall under either the `Aircraft` or the `Mission` categories. An example of this might be if you are doing fleet-level analyses and would like a `Fleet` variable hierarchy.\n", + "\n", + "A new variable hierarchy can be created in exactly the same manner that Aviary-core creates its own variable hierarchies, illustrated above. For the case of creating a new `Fleet` variable hierarchy, it might look something like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "class Fleet:\n", + " class RegionalSingleAisle:\n", + " NUM_AIRCRAFT = 'fleet:rejoinal_single_aisle:number_of_aircraft'\n", + " COST_PER_AIRCRAFT = 'fleet:rejoinal_single_aisle:cost_per_aircraft'\n", + " FLIGHTS_PER_DAY = 'fleet:rejoinal_single_aisle:flights_per_day'\n", + "\n", + " class JumboJet:\n", + " NUM_AIRCRAFT = 'fleet:jumbo_jet:number_of_aircraft'\n", + " COST_PER_AIRCRAFT = 'fleet:jumbo_jet:cost_per_aircraft'\n", + " FLIGHTS_PER_DAY = 'fleet:jumbo_jet:flights_per_day'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Usually if you are creating your own variable hierarchy that is not an extension of the Aviary-core hierarchies it will be because you want a hierarchy that is not of the type `Aircraft` or `Mission`. In this case, your new hierarchy is relatively straightforward, you can create it and simply provide it to Aviary along with the core hierarchies or extensions thereof. However, if you are creating your own variable hierarchy that is of the type `Aircraft` or `Mission` but is not an extension of the Aviary-core hierarchies (which we do not recommend doing), there are a few things to keep in mind:\n", + "- The newly created variable hierarchy does not have any of the information from the Aviary-core hierarchy. You *must* still provide Aviary with the input values and information from the Aviary-core hierarchy, or all the inputs will be set to their default values which are unlikely to suit your needs.\n", + " + You can merge together all variable hierarchies that are of the same type (see below).\n", + "- You should avoid adding variables to your created hierarchy that already exist in the Aviary-core hierarchy, as this may cause conflicts when merging hierarchies together.\n", + "\n", + "In general, we recommend extending the Aviary-core variable hierarchies whenever possible, and only creating a new hierarchy from scratch when the categories of `Aircraft` and `Mission` do not fit your needs.\n", + "\n", + "## Merging Extended Hierarchies\n", + "As briefly mentioned above, when there are multiple variable hierarchies of the same type we need the ability to merge them together into one hierarchy of that type which includes all the information from the different hierarchies. Aviary provides this capability through the `merge_hierarchies()` method. The goal of this method is to clean up all the user hierarchies so that Aviary can be provided with only one hierarchy of each type, and also to resolve any discrepancies between different hierarchies of the same type.\n", + "\n", + "Using the [`merge_hierarchies()` function](../theory_guide/merging_syntax.ipynb) is quite simple. It takes a list of all the hierarchies you would like to merge together and returns one hierarchy that has the merged information from all the input hierarchies, as in this snippet of code where we are merging together three notional `Aircraft` type hierarchies:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input", + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import copy\n", + "\n", + "Aircraft1 = copy.deepcopy(av.Aircraft)\n", + "Aircraft2 = copy.deepcopy(av.Aircraft)\n", + "Aircraft3 = copy.deepcopy(av.Aircraft)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "FullAircraft = av.merge_hierarchies([Aircraft1, Aircraft2, Aircraft3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When merging together variable hierarchies, make sure that all the hierarchies are of the same type. The `merge_hierarchies()` will throw an error if you attempt to merge multiple hierarchies subclassed from hierarchies of different types. Also ensure that the hierarchies you are merging don't contain the same variable with a different value. That is an impossible situation to merge, and will raise an error. Also ensure that when merging hierarchies of the `Aircraft` or `Mission` type the variable information from the Aviary-core hierarchies is present in your final merged hierarchies. This is handled automatically if you have built your hierarchies by extending the Aviary-core hierarchies (which is the recommended behavior), but if you have instead made your hierarchies from scratch then you will have to include the Aviary-core hierarchy of the same type in the hierarchies to be merged.\n", + "\n", + "```{note}\n", + "If even one of the hierarchies to be merged is an extension of the Aviary-core hierarchy of that type, then the Aviary core information will be included. You only need to include the Aviary-core hierarchy of that type in the list of hierarchies to merge if none of the other hierarchies are extensions.\n", + "```\n", + "\n", + "More syntactical data on the merging functions can be found [here](../theory_guide/merging_syntax.ipynb).\n", + "\n", + "## Providing Aviary with Necessary Variable Hierarchies\n", + "Need to add content here." + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "interpreter": { + "hash": "e6c7471802ed76737b16357fb02af5587f3a4cbee5ea7658f3f9a6981469039b" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/_sources/user_guide/variable_metadata.ipynb b/_sources/user_guide/variable_metadata.ipynb new file mode 100644 index 000000000..dbbde0be4 --- /dev/null +++ b/_sources/user_guide/variable_metadata.ipynb @@ -0,0 +1,412 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Understanding the Variable Metadata\n", + "## How Variable Metadata Works\n", + "\n", + "Every variable in an Aviary variable hierarchy must have metadata associated with it. This metadata is used for setting initial values, setting Aviary inputs and outputs, and various other functionalities throughout the code. It is also helpful information for the user to have regarding each variable and the metadata dictionary allows all that information to live in one organized location. Unlike variable hierarchies, which are broken up into different categories based on the type of information they contain, the variable metadata all lives in the same dictionary, regardless of which variable hierarchy its variables come from.\n", + "\n", + "The variable metadata dictionary is exactly what it sounds like: a Python dictionary, or more explicitly a Python dictionary of dictionaries. The entire metadata is one dictionary, and within that metadata dictionary each variable has its own sub-dictionary including all the information relevant to that variable. The information included in each sub-dictionary is:\n", + "\n", + "| Information | Default Value | Key Name in Metadata |\n", + "| --------------------------- | ------------- | -------------------- |\n", + "| Units | `unitless` | units |\n", + "| Description | `None` | desc |\n", + "| Default Value | `None` | default_value |\n", + "| Is Option? | `False` | option |\n", + "| Type Restrictions | `None` | types |\n", + "| Historical Variable Name(s) | `None` | historical_name |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The information in the metadata dictionary is accessed just like information in any other Python dictionary. For example, if you wanted to know the units of the `Aircraft.Wing.SPAN` variable from the Aviary-core `Aircraft` variable hierarchy along with whether or not the variable was an option, you would access those units using the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "AviaryAircraft = av.Aircraft\n", + "\n", + "wingspan_units = av.CoreMetaData[AviaryAircraft.Wing.SPAN]['units']\n", + "wingspan_is_option = av.CoreMetaData[AviaryAircraft.Wing.SPAN]['option']\n", + "\n", + "print(wingspan_units)\n", + "print(wingspan_is_option)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example we use the variable hierarchy to provide the name of the variable we are seeking to Aviary's `CoreMetaData`, and we use the keys from the metadata dictionary to provide the specific information that we would like to know. This would return" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-input" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "AviaryAircraft = av.Aircraft\n", + "\n", + "wingspan_units = av.CoreMetaData[AviaryAircraft.Wing.SPAN]['units']\n", + "wingspan_is_option = av.CoreMetaData[AviaryAircraft.Wing.SPAN]['option']\n", + "\n", + "print(wingspan_units)\n", + "print(wingspan_is_option)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "which tells you that the units of the variable Aircraft.Wing.SPAN from the Aviary-core `Aircraft` variable hierarchy are feet, and that Aircraft.Wing.SPAN is not an option.\n", + "\n", + "```{note}\n", + "Many of the weight and aerodynamic estimating relationships in Aviary originated from historical codes called GASP and FLOPS. For engineers who are familiar with GASP and FLOPS it is helpful to know what an Aviary variable was called in those historical codes.\n", + "\n", + "The historical variable name portion of the metadata allows us to associate any names that an Aviary variable may have had in a previous code. This piece of the metadata is actually a dictionary within each subdictionary belonging to each variable. This dictionary is used by adding an entry for each historical code, where the key is the name of the historical code, and the value for that key is a string or list of strings illustrating the name(s) that variable held in the historic code. This is an optional feature, but can be helpful for users who are porting old codes into new formats.\n", + "```\n", + "\n", + "## The Aviary-core Metadata\n", + "The Aviary code provides metadata for every variable in the Aviary-core variable hierarchies. As noted above, the metadata is not broken up into multiple dictionaries like the variable hierarchy, but instead the metadata for every variable lives in the same dictionary. As such there is only one Aviary-core metadata dictionary, which can be viewed [here](https://github.com/OpenMDAO/Aviary/blob/main/aviary/variable_info/variable_meta_data.py) and accessed in the following way:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "MetaData = av.CoreMetaData" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "In the Aviary-core metadata dictionary, due to the size of the data we have adopted a structure of organizing the metadata alphabetically by variable hierarchy. Thus, while all the variables are part of the same metadata dictionary, you will notice that the organization structure of the file is the same alphabetical hierarchal organization structure as the Aviary-core variable hierarchy. This is a convention that we encourage to improve the cleanliness of code, but it is not strictly required.\n", + "\n", + "## Building Your Own Metadata\n", + "Unlike the variable hierarchies, which are separated out into different hierarchies for different types of data, there is only one metadata dictionary for all variables in every variable hierarchy. Technically the user may build a metadata dictionary from scratch instead of extending the Aviary-core metadata, however, there is no real value to this as you will eventually have to merge back in the Aviary-core metadata anyway, so there are no normal circumstances under which this is the recommended practice. However, just like with variable hierarchies, you can have several different metadata dictionaries which will eventually be merged together. This may be necessary when there are multiple people developing different external subsystems in different locations.\n", + "\n", + "There are two different ways to change the metadata in a metadata dictionary. The first is to add a new variable to the dictionary, and add that variable's metadata along with it. This makes use of the `add_meta_data()` function. This function takes in the variable name of the variable to be added to the metadata dictionary be provided, as well as the dictionary itself that the variable should be added to. It also optionally takes in all of the metadata information listed at the beginning of this page. The function returns nothing, but it internally updates the provided metadata dictionary so that dictionary will contain the new variable and its metadata.\n", + "\n", + "The second way to change the metadata in a metadata dictionary is by updating the metadata associated with a variable that is already in the dictionary. This is accomplished using the `update_meta_data()` function. This function behaves almost identically to the `add_meta_data()` function, the only difference being that instead of adding a new variable to the dictionary, it will take the input of metadata information that you provide and overwrite the old metadata of the given variable with the new metadata.\n", + "\n", + "There are two pitfalls that may occur when using these functions. The first pitfall is attempting to call the `add_meta_data()` function for a variable that already exists in the metadata. This will throw an error, because the `add_meta_data()` function is only for new variables to the metadata. Conversely, attempting to update the metadata of a variable that is not in the metadata dictionary via `update_meta_data()` will throw an error because that function is only for variables that already exist in the metadata.\n", + "\n", + "The methods outlined above for updating and adding to the variable metadata are the crux of how the variable metadata can be extended for new variables. The user will simply import the existing Aviary-core metadata and add to it as they see fit.\n", + "\n", + "```{note}\n", + "The variable metadata dictionary that is imported from the Aviary API is actually a copy of the original Aviary metadata dictionary to avoid mutating the original dictionary. That being said, it functions just as a metadata dictionary that you would input to an Aviary model and you can extend it or input it to a model as-is depending on your needs.\n", + "```\n", + "\n", + "Lets examine how we would extend the variable metadata dictionary in practice. Say we have just extended the Aviary-core `Aircraft` variable hierarchy to add some center of gravity, flap, and jury strut information using the extension below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "AviaryAircraft = av.Aircraft\n", + "\n", + "class ExtendedAircraft(AviaryAircraft):\n", + "\n", + " CG = 'aircraft:center_of_gravity'\n", + "\n", + " class Wing(AviaryAircraft.Wing):\n", + " class Flap:\n", + " AREA = 'aircraft:wing:flap:area'\n", + " ROOT_CHORD = 'aircraft:wing:flap:root_chord'\n", + " SPAN = 'aircraft:wing:flap:span'\n", + "\n", + " class Jury:\n", + " MASS = 'aircraft:jury:mass'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we want to extend the Aviary-core metadata into our own metadata that includes metadata for each one of these variables in the same code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "ExtendedMetaData = av.CoreMetaData\n", + "\n", + "av.add_meta_data(\n", + " ExtendedAircraft.CG,\n", + " meta_data=av.CoreMetaData,\n", + " units='ft',\n", + " desc='Center of gravity',\n", + " default_value=0,\n", + " option=False,\n", + ")\n", + "\n", + "av.add_meta_data(\n", + " ExtendedAircraft.Wing.Flap.AREA,\n", + " meta_data=ExtendedMetaData,\n", + " units='ft**2',\n", + " desc='planform area of flap',\n", + " default_value=10,\n", + " option=False\n", + ")\n", + "\n", + "av.add_meta_data(\n", + " ExtendedAircraft.Wing.Flap.ROOT_CHORD,\n", + " meta_data=ExtendedMetaData,\n", + " units='ft',\n", + " desc='chord of flap at root of wing',\n", + " default_value=1,\n", + " option=False\n", + ")\n", + "\n", + "av.add_meta_data(\n", + " ExtendedAircraft.Wing.Flap.SPAN,\n", + " meta_data=ExtendedMetaData,\n", + " units='ft',\n", + " desc='span of flap',\n", + " default_value=60,\n", + " option=False\n", + ")\n", + "\n", + "av.add_meta_data(\n", + " ExtendedAircraft.Jury.MASS,\n", + " meta_data=ExtendedMetaData,\n", + " units='kg',\n", + " desc='mass of jury strut',\n", + " default_value=50,\n", + " option=False\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`ExtendedMetaData` now contains the metadata of all the Aviary-core variables along with the metadata information that we just added.\n", + "\n", + "## Merging Independent Metadata\n", + "Extending the metadata is great, but sometimes users will end up with multiple metadata dictionaries because different subsystem developers extended the metadata (and created associated variable hierarchies) to suit their own needs. Aviary needs to be given one single metadata dictionary which contains metadata of all the variables it has been given, so we need to be able to merge together multiple metadata dictionaries into one. The `merge_meta_data()` function has been provided to combine all the different metadata into one. The `merge_meta_data()` function behaves quite similarly to the `merge_variable_hierarchies()` function. It takes in a string of metadata dictionaries that need to be merged together, and it returns a single metadata dictionary containing the metadata from all the individual dictionaries.\n", + "\n", + "Let's say that we have created our `ExtendedAircraft` and `ExtendedMetaData` from above, and that elsewhere we have a subsystem that requires information about engine cooling system mass as well as whether the aircraft has winglets. Below is the buildup of the `Aircraft` type hierarchy and the metadata for our new subsystem:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "import aviary.api as av\n", + "\n", + "class ExtendedAircraft2(av.Aircraft):\n", + "\n", + " class Engine(av.Aircraft.Engine):\n", + "\n", + " class Cooling:\n", + " MASS = 'aircraft:engine:cooling:mass'\n", + "\n", + " class Wing(av.Aircraft.Wing):\n", + " WINGLETS = 'aircraft:wing:winglets'\n", + "\n", + "ExtendedMetaData2 = av.CoreMetaData\n", + "\n", + "av.add_meta_data(\n", + " ExtendedAircraft2.Engine.Cooling.MASS,\n", + " units='kg',\n", + " desc='mass of cooling system for one engine',\n", + " default_value=100,\n", + " meta_data=ExtendedMetaData2,\n", + " historical_name=None,\n", + ")\n", + "\n", + "av.add_meta_data(\n", + " ExtendedAircraft2.Wing.WINGLETS,\n", + " units=None,\n", + " desc='Tells whether the aircraft has winglets',\n", + " default_value=True,\n", + " option=True,\n", + " types=bool,\n", + " meta_data=ExtendedMetaData2,\n", + " historical_name=None,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see from the above code that we have an `Aircraft` type variable hierarchy named `ExtendedAircraft2` and that we have created our own metadata dictionary `ExtendedMetaData2` which is an extension of the `CoreMetaData` dictionary in Aviary-core. Now we have two different `Aircraft` type variable hierarchy extensions, `ExtendedAircraft` and `ExtendedAircraft2`. We also have two different metadata extensions, `ExtendedMetaData` and `ExtendedMetaData2`. We need a single `Aircraft` type variable hierarchy, and single metadata dictionary. Thus, we will use the merging functions built into Aviary:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "remove-output" + ] + }, + "outputs": [], + "source": [ + "FinalAircraft = av.merge_hierarchies([ExtendedAircraft, ExtendedAircraft2])\n", + "FinalMetaData = av.merge_meta_data([ExtendedMetaData, ExtendedMetaData2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above we merged together our hierarchy and metadata extensions, and now we have one single `Aircraft` type hierarchy `FinalAircraft` and one single metadata dictionary `FinalMetaData` which we can provide to the Aviary model.\n", + "\n", + "There is one situation when an attempt to merge together multiple metadata dictionaries will cause errors, and that situation is if more than one metadata dictionary contains the same variable with different metadata. If multiple dictionaries contain the same variable with identical metadata the merge will proceed, but if the metadata differs at all the merge will halt and force the user to rectify the discrepancy.\n", + "\n", + "More syntactical data on the merging functions can be found [here](../theory_guide/merging_syntax.ipynb).\n", + "\n", + "\n", + "## Providing Aviary with Necessary Variable Metadata\n", + "\n", + "This section is under development." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Searchable Metadata Table\n", + "\n", + "The table below contains all the metadata for every variable in the Aviary-core variable hierarchies.\n", + "The table is searchable and sortable and is created automatically from the Aviary core metadata dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "full-width", + "remove-input" + ] + }, + "outputs": [], + "source": [ + "try:\n", + " from itables import init_notebook_mode\n", + " from itables import show\n", + "except:\n", + " print(\"Warning: itables is not installed.\")\n", + " print(\"To install itables, run the following command:\")\n", + " print(\"pip install itables\")\n", + "\n", + "else:\n", + " import pandas as pd\n", + " from copy import deepcopy\n", + "\n", + " init_notebook_mode(all_interactive=True)\n", + "\n", + " # Your complex dictionary\n", + " data = deepcopy(av.CoreMetaData)\n", + "\n", + " # Transforming the dictionary into a format suitable for DataFrame\n", + " transformed_data = []\n", + " for key, value in data.items():\n", + " row = {'variable name': key}\n", + " for k, v in value.items():\n", + " if k == 'historical_name' and v is not None:\n", + " value[k] = '
'.join([f\"{k2}: {v2}\" for k2, v2 in v.items()])\n", + " row.update(value)\n", + " transformed_data.append(row)\n", + "\n", + " # Creating a DataFrame\n", + " df = pd.DataFrame(transformed_data)\n", + "\n", + " # Reordering the columns\n", + " columns = df.columns.tolist()\n", + " columns.remove('historical_name')\n", + " columns.append('historical_name')\n", + " df = df.reindex(columns=columns)\n", + "\n", + " show(df, scrollY=\"600px\", scrollCollapse=True, paging=False, classes=\"display compact\", columnDefs=[{\"width\": \"120px\", \"className\": \"dt-left\", \"targets\": \"_all\"}], scrollX=True)\n" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "interpreter": { + "hash": "e6c7471802ed76737b16357fb02af5587f3a4cbee5ea7658f3f9a6981469039b" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + }, + "orphan": true + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/_sphinx_design_static/design-style.4045f2051d55cab465a707391d5b2007.min.css b/_sphinx_design_static/design-style.4045f2051d55cab465a707391d5b2007.min.css new file mode 100644 index 000000000..3225661c2 --- /dev/null +++ b/_sphinx_design_static/design-style.4045f2051d55cab465a707391d5b2007.min.css @@ -0,0 +1 @@ +.sd-bg-primary{background-color:var(--sd-color-primary) !important}.sd-bg-text-primary{color:var(--sd-color-primary-text) !important}button.sd-bg-primary:focus,button.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}a.sd-bg-primary:focus,a.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}.sd-bg-secondary{background-color:var(--sd-color-secondary) !important}.sd-bg-text-secondary{color:var(--sd-color-secondary-text) !important}button.sd-bg-secondary:focus,button.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}a.sd-bg-secondary:focus,a.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}.sd-bg-success{background-color:var(--sd-color-success) !important}.sd-bg-text-success{color:var(--sd-color-success-text) !important}button.sd-bg-success:focus,button.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}a.sd-bg-success:focus,a.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}.sd-bg-info{background-color:var(--sd-color-info) !important}.sd-bg-text-info{color:var(--sd-color-info-text) !important}button.sd-bg-info:focus,button.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}a.sd-bg-info:focus,a.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}.sd-bg-warning{background-color:var(--sd-color-warning) !important}.sd-bg-text-warning{color:var(--sd-color-warning-text) !important}button.sd-bg-warning:focus,button.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}a.sd-bg-warning:focus,a.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}.sd-bg-danger{background-color:var(--sd-color-danger) !important}.sd-bg-text-danger{color:var(--sd-color-danger-text) !important}button.sd-bg-danger:focus,button.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}a.sd-bg-danger:focus,a.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}.sd-bg-light{background-color:var(--sd-color-light) !important}.sd-bg-text-light{color:var(--sd-color-light-text) !important}button.sd-bg-light:focus,button.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}a.sd-bg-light:focus,a.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}.sd-bg-muted{background-color:var(--sd-color-muted) !important}.sd-bg-text-muted{color:var(--sd-color-muted-text) !important}button.sd-bg-muted:focus,button.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}a.sd-bg-muted:focus,a.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}.sd-bg-dark{background-color:var(--sd-color-dark) !important}.sd-bg-text-dark{color:var(--sd-color-dark-text) !important}button.sd-bg-dark:focus,button.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}a.sd-bg-dark:focus,a.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}.sd-bg-black{background-color:var(--sd-color-black) !important}.sd-bg-text-black{color:var(--sd-color-black-text) !important}button.sd-bg-black:focus,button.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}a.sd-bg-black:focus,a.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}.sd-bg-white{background-color:var(--sd-color-white) !important}.sd-bg-text-white{color:var(--sd-color-white-text) !important}button.sd-bg-white:focus,button.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}a.sd-bg-white:focus,a.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}.sd-text-primary,.sd-text-primary>p{color:var(--sd-color-primary) !important}a.sd-text-primary:focus,a.sd-text-primary:hover{color:var(--sd-color-primary-highlight) !important}.sd-text-secondary,.sd-text-secondary>p{color:var(--sd-color-secondary) !important}a.sd-text-secondary:focus,a.sd-text-secondary:hover{color:var(--sd-color-secondary-highlight) !important}.sd-text-success,.sd-text-success>p{color:var(--sd-color-success) !important}a.sd-text-success:focus,a.sd-text-success:hover{color:var(--sd-color-success-highlight) !important}.sd-text-info,.sd-text-info>p{color:var(--sd-color-info) !important}a.sd-text-info:focus,a.sd-text-info:hover{color:var(--sd-color-info-highlight) !important}.sd-text-warning,.sd-text-warning>p{color:var(--sd-color-warning) !important}a.sd-text-warning:focus,a.sd-text-warning:hover{color:var(--sd-color-warning-highlight) !important}.sd-text-danger,.sd-text-danger>p{color:var(--sd-color-danger) !important}a.sd-text-danger:focus,a.sd-text-danger:hover{color:var(--sd-color-danger-highlight) !important}.sd-text-light,.sd-text-light>p{color:var(--sd-color-light) !important}a.sd-text-light:focus,a.sd-text-light:hover{color:var(--sd-color-light-highlight) !important}.sd-text-muted,.sd-text-muted>p{color:var(--sd-color-muted) !important}a.sd-text-muted:focus,a.sd-text-muted:hover{color:var(--sd-color-muted-highlight) !important}.sd-text-dark,.sd-text-dark>p{color:var(--sd-color-dark) !important}a.sd-text-dark:focus,a.sd-text-dark:hover{color:var(--sd-color-dark-highlight) !important}.sd-text-black,.sd-text-black>p{color:var(--sd-color-black) !important}a.sd-text-black:focus,a.sd-text-black:hover{color:var(--sd-color-black-highlight) !important}.sd-text-white,.sd-text-white>p{color:var(--sd-color-white) !important}a.sd-text-white:focus,a.sd-text-white:hover{color:var(--sd-color-white-highlight) !important}.sd-outline-primary{border-color:var(--sd-color-primary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-primary:focus,a.sd-outline-primary:hover{border-color:var(--sd-color-primary-highlight) !important}.sd-outline-secondary{border-color:var(--sd-color-secondary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-secondary:focus,a.sd-outline-secondary:hover{border-color:var(--sd-color-secondary-highlight) !important}.sd-outline-success{border-color:var(--sd-color-success) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-success:focus,a.sd-outline-success:hover{border-color:var(--sd-color-success-highlight) !important}.sd-outline-info{border-color:var(--sd-color-info) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-info:focus,a.sd-outline-info:hover{border-color:var(--sd-color-info-highlight) !important}.sd-outline-warning{border-color:var(--sd-color-warning) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-warning:focus,a.sd-outline-warning:hover{border-color:var(--sd-color-warning-highlight) !important}.sd-outline-danger{border-color:var(--sd-color-danger) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-danger:focus,a.sd-outline-danger:hover{border-color:var(--sd-color-danger-highlight) !important}.sd-outline-light{border-color:var(--sd-color-light) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-light:focus,a.sd-outline-light:hover{border-color:var(--sd-color-light-highlight) !important}.sd-outline-muted{border-color:var(--sd-color-muted) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-muted:focus,a.sd-outline-muted:hover{border-color:var(--sd-color-muted-highlight) !important}.sd-outline-dark{border-color:var(--sd-color-dark) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-dark:focus,a.sd-outline-dark:hover{border-color:var(--sd-color-dark-highlight) !important}.sd-outline-black{border-color:var(--sd-color-black) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-black:focus,a.sd-outline-black:hover{border-color:var(--sd-color-black-highlight) !important}.sd-outline-white{border-color:var(--sd-color-white) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-white:focus,a.sd-outline-white:hover{border-color:var(--sd-color-white-highlight) !important}.sd-bg-transparent{background-color:transparent !important}.sd-outline-transparent{border-color:transparent !important}.sd-text-transparent{color:transparent !important}.sd-p-0{padding:0 !important}.sd-pt-0,.sd-py-0{padding-top:0 !important}.sd-pr-0,.sd-px-0{padding-right:0 !important}.sd-pb-0,.sd-py-0{padding-bottom:0 !important}.sd-pl-0,.sd-px-0{padding-left:0 !important}.sd-p-1{padding:.25rem !important}.sd-pt-1,.sd-py-1{padding-top:.25rem !important}.sd-pr-1,.sd-px-1{padding-right:.25rem !important}.sd-pb-1,.sd-py-1{padding-bottom:.25rem !important}.sd-pl-1,.sd-px-1{padding-left:.25rem !important}.sd-p-2{padding:.5rem !important}.sd-pt-2,.sd-py-2{padding-top:.5rem !important}.sd-pr-2,.sd-px-2{padding-right:.5rem !important}.sd-pb-2,.sd-py-2{padding-bottom:.5rem !important}.sd-pl-2,.sd-px-2{padding-left:.5rem !important}.sd-p-3{padding:1rem !important}.sd-pt-3,.sd-py-3{padding-top:1rem !important}.sd-pr-3,.sd-px-3{padding-right:1rem !important}.sd-pb-3,.sd-py-3{padding-bottom:1rem !important}.sd-pl-3,.sd-px-3{padding-left:1rem !important}.sd-p-4{padding:1.5rem !important}.sd-pt-4,.sd-py-4{padding-top:1.5rem !important}.sd-pr-4,.sd-px-4{padding-right:1.5rem !important}.sd-pb-4,.sd-py-4{padding-bottom:1.5rem !important}.sd-pl-4,.sd-px-4{padding-left:1.5rem !important}.sd-p-5{padding:3rem !important}.sd-pt-5,.sd-py-5{padding-top:3rem !important}.sd-pr-5,.sd-px-5{padding-right:3rem !important}.sd-pb-5,.sd-py-5{padding-bottom:3rem !important}.sd-pl-5,.sd-px-5{padding-left:3rem !important}.sd-m-auto{margin:auto !important}.sd-mt-auto,.sd-my-auto{margin-top:auto !important}.sd-mr-auto,.sd-mx-auto{margin-right:auto !important}.sd-mb-auto,.sd-my-auto{margin-bottom:auto !important}.sd-ml-auto,.sd-mx-auto{margin-left:auto !important}.sd-m-0{margin:0 !important}.sd-mt-0,.sd-my-0{margin-top:0 !important}.sd-mr-0,.sd-mx-0{margin-right:0 !important}.sd-mb-0,.sd-my-0{margin-bottom:0 !important}.sd-ml-0,.sd-mx-0{margin-left:0 !important}.sd-m-1{margin:.25rem !important}.sd-mt-1,.sd-my-1{margin-top:.25rem !important}.sd-mr-1,.sd-mx-1{margin-right:.25rem !important}.sd-mb-1,.sd-my-1{margin-bottom:.25rem !important}.sd-ml-1,.sd-mx-1{margin-left:.25rem !important}.sd-m-2{margin:.5rem !important}.sd-mt-2,.sd-my-2{margin-top:.5rem !important}.sd-mr-2,.sd-mx-2{margin-right:.5rem !important}.sd-mb-2,.sd-my-2{margin-bottom:.5rem !important}.sd-ml-2,.sd-mx-2{margin-left:.5rem !important}.sd-m-3{margin:1rem !important}.sd-mt-3,.sd-my-3{margin-top:1rem !important}.sd-mr-3,.sd-mx-3{margin-right:1rem !important}.sd-mb-3,.sd-my-3{margin-bottom:1rem !important}.sd-ml-3,.sd-mx-3{margin-left:1rem !important}.sd-m-4{margin:1.5rem !important}.sd-mt-4,.sd-my-4{margin-top:1.5rem !important}.sd-mr-4,.sd-mx-4{margin-right:1.5rem !important}.sd-mb-4,.sd-my-4{margin-bottom:1.5rem !important}.sd-ml-4,.sd-mx-4{margin-left:1.5rem !important}.sd-m-5{margin:3rem !important}.sd-mt-5,.sd-my-5{margin-top:3rem !important}.sd-mr-5,.sd-mx-5{margin-right:3rem !important}.sd-mb-5,.sd-my-5{margin-bottom:3rem !important}.sd-ml-5,.sd-mx-5{margin-left:3rem !important}.sd-w-25{width:25% !important}.sd-w-50{width:50% !important}.sd-w-75{width:75% !important}.sd-w-100{width:100% !important}.sd-w-auto{width:auto !important}.sd-h-25{height:25% !important}.sd-h-50{height:50% !important}.sd-h-75{height:75% !important}.sd-h-100{height:100% !important}.sd-h-auto{height:auto !important}.sd-d-none{display:none !important}.sd-d-inline{display:inline !important}.sd-d-inline-block{display:inline-block !important}.sd-d-block{display:block !important}.sd-d-grid{display:grid !important}.sd-d-flex-row{display:-ms-flexbox !important;display:flex !important;flex-direction:row !important}.sd-d-flex-column{display:-ms-flexbox !important;display:flex !important;flex-direction:column !important}.sd-d-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}@media(min-width: 576px){.sd-d-sm-none{display:none !important}.sd-d-sm-inline{display:inline !important}.sd-d-sm-inline-block{display:inline-block !important}.sd-d-sm-block{display:block !important}.sd-d-sm-grid{display:grid !important}.sd-d-sm-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-sm-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 768px){.sd-d-md-none{display:none !important}.sd-d-md-inline{display:inline !important}.sd-d-md-inline-block{display:inline-block !important}.sd-d-md-block{display:block !important}.sd-d-md-grid{display:grid !important}.sd-d-md-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-md-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 992px){.sd-d-lg-none{display:none !important}.sd-d-lg-inline{display:inline !important}.sd-d-lg-inline-block{display:inline-block !important}.sd-d-lg-block{display:block !important}.sd-d-lg-grid{display:grid !important}.sd-d-lg-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-lg-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 1200px){.sd-d-xl-none{display:none !important}.sd-d-xl-inline{display:inline !important}.sd-d-xl-inline-block{display:inline-block !important}.sd-d-xl-block{display:block !important}.sd-d-xl-grid{display:grid !important}.sd-d-xl-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-xl-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}.sd-align-major-start{justify-content:flex-start !important}.sd-align-major-end{justify-content:flex-end !important}.sd-align-major-center{justify-content:center !important}.sd-align-major-justify{justify-content:space-between !important}.sd-align-major-spaced{justify-content:space-evenly !important}.sd-align-minor-start{align-items:flex-start !important}.sd-align-minor-end{align-items:flex-end !important}.sd-align-minor-center{align-items:center !important}.sd-align-minor-stretch{align-items:stretch !important}.sd-text-justify{text-align:justify !important}.sd-text-left{text-align:left !important}.sd-text-right{text-align:right !important}.sd-text-center{text-align:center !important}.sd-font-weight-light{font-weight:300 !important}.sd-font-weight-lighter{font-weight:lighter !important}.sd-font-weight-normal{font-weight:400 !important}.sd-font-weight-bold{font-weight:700 !important}.sd-font-weight-bolder{font-weight:bolder !important}.sd-font-italic{font-style:italic !important}.sd-text-decoration-none{text-decoration:none !important}.sd-text-lowercase{text-transform:lowercase !important}.sd-text-uppercase{text-transform:uppercase !important}.sd-text-capitalize{text-transform:capitalize !important}.sd-text-wrap{white-space:normal !important}.sd-text-nowrap{white-space:nowrap !important}.sd-text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sd-fs-1,.sd-fs-1>p{font-size:calc(1.375rem + 1.5vw) !important;line-height:unset !important}.sd-fs-2,.sd-fs-2>p{font-size:calc(1.325rem + 0.9vw) !important;line-height:unset !important}.sd-fs-3,.sd-fs-3>p{font-size:calc(1.3rem + 0.6vw) !important;line-height:unset !important}.sd-fs-4,.sd-fs-4>p{font-size:calc(1.275rem + 0.3vw) !important;line-height:unset !important}.sd-fs-5,.sd-fs-5>p{font-size:1.25rem !important;line-height:unset !important}.sd-fs-6,.sd-fs-6>p{font-size:1rem !important;line-height:unset !important}.sd-border-0{border:0 solid !important}.sd-border-top-0{border-top:0 solid !important}.sd-border-bottom-0{border-bottom:0 solid !important}.sd-border-right-0{border-right:0 solid !important}.sd-border-left-0{border-left:0 solid !important}.sd-border-1{border:1px solid !important}.sd-border-top-1{border-top:1px solid !important}.sd-border-bottom-1{border-bottom:1px solid !important}.sd-border-right-1{border-right:1px solid !important}.sd-border-left-1{border-left:1px solid !important}.sd-border-2{border:2px solid !important}.sd-border-top-2{border-top:2px solid !important}.sd-border-bottom-2{border-bottom:2px solid !important}.sd-border-right-2{border-right:2px solid !important}.sd-border-left-2{border-left:2px solid !important}.sd-border-3{border:3px solid !important}.sd-border-top-3{border-top:3px solid !important}.sd-border-bottom-3{border-bottom:3px solid !important}.sd-border-right-3{border-right:3px solid !important}.sd-border-left-3{border-left:3px solid !important}.sd-border-4{border:4px solid !important}.sd-border-top-4{border-top:4px solid !important}.sd-border-bottom-4{border-bottom:4px solid !important}.sd-border-right-4{border-right:4px solid !important}.sd-border-left-4{border-left:4px solid !important}.sd-border-5{border:5px solid !important}.sd-border-top-5{border-top:5px solid !important}.sd-border-bottom-5{border-bottom:5px solid !important}.sd-border-right-5{border-right:5px solid !important}.sd-border-left-5{border-left:5px solid !important}.sd-rounded-0{border-radius:0 !important}.sd-rounded-1{border-radius:.2rem !important}.sd-rounded-2{border-radius:.3rem !important}.sd-rounded-3{border-radius:.5rem !important}.sd-rounded-pill{border-radius:50rem !important}.sd-rounded-circle{border-radius:50% !important}.shadow-none{box-shadow:none !important}.sd-shadow-sm{box-shadow:0 .125rem .25rem var(--sd-color-shadow) !important}.sd-shadow-md{box-shadow:0 .5rem 1rem var(--sd-color-shadow) !important}.sd-shadow-lg{box-shadow:0 1rem 3rem var(--sd-color-shadow) !important}@keyframes sd-slide-from-left{0%{transform:translateX(-100%)}100%{transform:translateX(0)}}@keyframes sd-slide-from-right{0%{transform:translateX(200%)}100%{transform:translateX(0)}}@keyframes sd-grow100{0%{transform:scale(0);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50{0%{transform:scale(0.5);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50-rot20{0%{transform:scale(0.5) rotateZ(-20deg);opacity:.5}75%{transform:scale(1) rotateZ(5deg);opacity:1}95%{transform:scale(1) rotateZ(-1deg);opacity:1}100%{transform:scale(1) rotateZ(0);opacity:1}}.sd-animate-slide-from-left{animation:1s ease-out 0s 1 normal none running sd-slide-from-left}.sd-animate-slide-from-right{animation:1s ease-out 0s 1 normal none running sd-slide-from-right}.sd-animate-grow100{animation:1s ease-out 0s 1 normal none running sd-grow100}.sd-animate-grow50{animation:1s ease-out 0s 1 normal none running sd-grow50}.sd-animate-grow50-rot20{animation:1s ease-out 0s 1 normal none running sd-grow50-rot20}.sd-badge{display:inline-block;padding:.35em .65em;font-size:.75em;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.sd-badge:empty{display:none}a.sd-badge{text-decoration:none}.sd-btn .sd-badge{position:relative;top:-1px}.sd-btn{background-color:transparent;border:1px solid transparent;border-radius:.25rem;cursor:pointer;display:inline-block;font-weight:400;font-size:1rem;line-height:1.5;padding:.375rem .75rem;text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;vertical-align:middle;user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none}.sd-btn:hover{text-decoration:none}@media(prefers-reduced-motion: reduce){.sd-btn{transition:none}}.sd-btn-primary,.sd-btn-outline-primary:hover,.sd-btn-outline-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-primary:hover,.sd-btn-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary-highlight) !important;border-color:var(--sd-color-primary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-primary{color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary,.sd-btn-outline-secondary:hover,.sd-btn-outline-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary:hover,.sd-btn-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary-highlight) !important;border-color:var(--sd-color-secondary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-secondary{color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success,.sd-btn-outline-success:hover,.sd-btn-outline-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success:hover,.sd-btn-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success-highlight) !important;border-color:var(--sd-color-success-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-success{color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info,.sd-btn-outline-info:hover,.sd-btn-outline-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info:hover,.sd-btn-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info-highlight) !important;border-color:var(--sd-color-info-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-info{color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning,.sd-btn-outline-warning:hover,.sd-btn-outline-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning:hover,.sd-btn-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning-highlight) !important;border-color:var(--sd-color-warning-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-warning{color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger,.sd-btn-outline-danger:hover,.sd-btn-outline-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger:hover,.sd-btn-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger-highlight) !important;border-color:var(--sd-color-danger-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-danger{color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light,.sd-btn-outline-light:hover,.sd-btn-outline-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light:hover,.sd-btn-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light-highlight) !important;border-color:var(--sd-color-light-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-light{color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted,.sd-btn-outline-muted:hover,.sd-btn-outline-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted:hover,.sd-btn-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted-highlight) !important;border-color:var(--sd-color-muted-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-muted{color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark,.sd-btn-outline-dark:hover,.sd-btn-outline-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark:hover,.sd-btn-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark-highlight) !important;border-color:var(--sd-color-dark-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-dark{color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black,.sd-btn-outline-black:hover,.sd-btn-outline-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black:hover,.sd-btn-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black-highlight) !important;border-color:var(--sd-color-black-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-black{color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white,.sd-btn-outline-white:hover,.sd-btn-outline-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white:hover,.sd-btn-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white-highlight) !important;border-color:var(--sd-color-white-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-white{color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.sd-hide-link-text{font-size:0}.sd-octicon,.sd-material-icon{display:inline-block;fill:currentColor;vertical-align:middle}.sd-avatar-xs{border-radius:50%;object-fit:cover;object-position:center;width:1rem;height:1rem}.sd-avatar-sm{border-radius:50%;object-fit:cover;object-position:center;width:3rem;height:3rem}.sd-avatar-md{border-radius:50%;object-fit:cover;object-position:center;width:5rem;height:5rem}.sd-avatar-lg{border-radius:50%;object-fit:cover;object-position:center;width:7rem;height:7rem}.sd-avatar-xl{border-radius:50%;object-fit:cover;object-position:center;width:10rem;height:10rem}.sd-avatar-inherit{border-radius:50%;object-fit:cover;object-position:center;width:inherit;height:inherit}.sd-avatar-initial{border-radius:50%;object-fit:cover;object-position:center;width:initial;height:initial}.sd-card{background-clip:border-box;background-color:var(--sd-color-card-background);border:1px solid var(--sd-color-card-border);border-radius:.25rem;color:var(--sd-color-card-text);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;min-width:0;position:relative;word-wrap:break-word}.sd-card>hr{margin-left:0;margin-right:0}.sd-card-hover:hover{border-color:var(--sd-color-card-border-hover);transform:scale(1.01)}.sd-card-body{-ms-flex:1 1 auto;flex:1 1 auto;padding:1rem 1rem}.sd-card-title{margin-bottom:.5rem}.sd-card-subtitle{margin-top:-0.25rem;margin-bottom:0}.sd-card-text:last-child{margin-bottom:0}.sd-card-link:hover{text-decoration:none}.sd-card-link+.card-link{margin-left:1rem}.sd-card-header{padding:.5rem 1rem;margin-bottom:0;background-color:var(--sd-color-card-header);border-bottom:1px solid var(--sd-color-card-border)}.sd-card-header:first-child{border-radius:calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0}.sd-card-footer{padding:.5rem 1rem;background-color:var(--sd-color-card-footer);border-top:1px solid var(--sd-color-card-border)}.sd-card-footer:last-child{border-radius:0 0 calc(0.25rem - 1px) calc(0.25rem - 1px)}.sd-card-header-tabs{margin-right:-0.5rem;margin-bottom:-0.5rem;margin-left:-0.5rem;border-bottom:0}.sd-card-header-pills{margin-right:-0.5rem;margin-left:-0.5rem}.sd-card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1rem;border-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom,.sd-card-img-top{width:100%}.sd-card-img,.sd-card-img-top{border-top-left-radius:calc(0.25rem - 1px);border-top-right-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom{border-bottom-left-radius:calc(0.25rem - 1px);border-bottom-right-radius:calc(0.25rem - 1px)}.sd-cards-carousel{width:100%;display:flex;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row;overflow-x:hidden;scroll-snap-type:x mandatory}.sd-cards-carousel.sd-show-scrollbar{overflow-x:auto}.sd-cards-carousel:hover,.sd-cards-carousel:focus{overflow-x:auto}.sd-cards-carousel>.sd-card{flex-shrink:0;scroll-snap-align:start}.sd-cards-carousel>.sd-card:not(:last-child){margin-right:3px}.sd-card-cols-1>.sd-card{width:90%}.sd-card-cols-2>.sd-card{width:45%}.sd-card-cols-3>.sd-card{width:30%}.sd-card-cols-4>.sd-card{width:22.5%}.sd-card-cols-5>.sd-card{width:18%}.sd-card-cols-6>.sd-card{width:15%}.sd-card-cols-7>.sd-card{width:12.8571428571%}.sd-card-cols-8>.sd-card{width:11.25%}.sd-card-cols-9>.sd-card{width:10%}.sd-card-cols-10>.sd-card{width:9%}.sd-card-cols-11>.sd-card{width:8.1818181818%}.sd-card-cols-12>.sd-card{width:7.5%}.sd-container,.sd-container-fluid,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container-xl{margin-left:auto;margin-right:auto;padding-left:var(--sd-gutter-x, 0.75rem);padding-right:var(--sd-gutter-x, 0.75rem);width:100%}@media(min-width: 576px){.sd-container-sm,.sd-container{max-width:540px}}@media(min-width: 768px){.sd-container-md,.sd-container-sm,.sd-container{max-width:720px}}@media(min-width: 992px){.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:960px}}@media(min-width: 1200px){.sd-container-xl,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:1140px}}.sd-row{--sd-gutter-x: 1.5rem;--sd-gutter-y: 0;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-top:calc(var(--sd-gutter-y) * -1);margin-right:calc(var(--sd-gutter-x) * -0.5);margin-left:calc(var(--sd-gutter-x) * -0.5)}.sd-row>*{box-sizing:border-box;flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--sd-gutter-x) * 0.5);padding-left:calc(var(--sd-gutter-x) * 0.5);margin-top:var(--sd-gutter-y)}.sd-col{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-auto>*{flex:0 0 auto;width:auto}.sd-row-cols-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}@media(min-width: 576px){.sd-col-sm{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-sm-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-sm-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-sm-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-sm-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-sm-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-sm-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-sm-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-sm-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-sm-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-sm-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-sm-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-sm-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-sm-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 768px){.sd-col-md{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-md-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-md-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-md-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-md-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-md-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-md-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-md-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-md-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-md-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-md-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-md-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-md-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-md-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 992px){.sd-col-lg{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-lg-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-lg-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-lg-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-lg-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-lg-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-lg-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-lg-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-lg-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-lg-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-lg-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-lg-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-lg-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-lg-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 1200px){.sd-col-xl{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-xl-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-xl-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-xl-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-xl-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-xl-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-xl-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-xl-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-xl-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-xl-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-xl-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-xl-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-xl-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-xl-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}.sd-col-auto{flex:0 0 auto;-ms-flex:0 0 auto;width:auto}.sd-col-1{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}.sd-col-2{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-col-3{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-col-4{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-col-5{flex:0 0 auto;-ms-flex:0 0 auto;width:41.6666666667%}.sd-col-6{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-col-7{flex:0 0 auto;-ms-flex:0 0 auto;width:58.3333333333%}.sd-col-8{flex:0 0 auto;-ms-flex:0 0 auto;width:66.6666666667%}.sd-col-9{flex:0 0 auto;-ms-flex:0 0 auto;width:75%}.sd-col-10{flex:0 0 auto;-ms-flex:0 0 auto;width:83.3333333333%}.sd-col-11{flex:0 0 auto;-ms-flex:0 0 auto;width:91.6666666667%}.sd-col-12{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-g-0,.sd-gy-0{--sd-gutter-y: 0}.sd-g-0,.sd-gx-0{--sd-gutter-x: 0}.sd-g-1,.sd-gy-1{--sd-gutter-y: 0.25rem}.sd-g-1,.sd-gx-1{--sd-gutter-x: 0.25rem}.sd-g-2,.sd-gy-2{--sd-gutter-y: 0.5rem}.sd-g-2,.sd-gx-2{--sd-gutter-x: 0.5rem}.sd-g-3,.sd-gy-3{--sd-gutter-y: 1rem}.sd-g-3,.sd-gx-3{--sd-gutter-x: 1rem}.sd-g-4,.sd-gy-4{--sd-gutter-y: 1.5rem}.sd-g-4,.sd-gx-4{--sd-gutter-x: 1.5rem}.sd-g-5,.sd-gy-5{--sd-gutter-y: 3rem}.sd-g-5,.sd-gx-5{--sd-gutter-x: 3rem}@media(min-width: 576px){.sd-col-sm-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-sm-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-sm-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-sm-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-sm-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-sm-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-sm-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-sm-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-sm-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-sm-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-sm-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-sm-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-sm-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-sm-0,.sd-gy-sm-0{--sd-gutter-y: 0}.sd-g-sm-0,.sd-gx-sm-0{--sd-gutter-x: 0}.sd-g-sm-1,.sd-gy-sm-1{--sd-gutter-y: 0.25rem}.sd-g-sm-1,.sd-gx-sm-1{--sd-gutter-x: 0.25rem}.sd-g-sm-2,.sd-gy-sm-2{--sd-gutter-y: 0.5rem}.sd-g-sm-2,.sd-gx-sm-2{--sd-gutter-x: 0.5rem}.sd-g-sm-3,.sd-gy-sm-3{--sd-gutter-y: 1rem}.sd-g-sm-3,.sd-gx-sm-3{--sd-gutter-x: 1rem}.sd-g-sm-4,.sd-gy-sm-4{--sd-gutter-y: 1.5rem}.sd-g-sm-4,.sd-gx-sm-4{--sd-gutter-x: 1.5rem}.sd-g-sm-5,.sd-gy-sm-5{--sd-gutter-y: 3rem}.sd-g-sm-5,.sd-gx-sm-5{--sd-gutter-x: 3rem}}@media(min-width: 768px){.sd-col-md-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-md-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-md-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-md-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-md-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-md-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-md-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-md-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-md-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-md-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-md-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-md-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-md-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-md-0,.sd-gy-md-0{--sd-gutter-y: 0}.sd-g-md-0,.sd-gx-md-0{--sd-gutter-x: 0}.sd-g-md-1,.sd-gy-md-1{--sd-gutter-y: 0.25rem}.sd-g-md-1,.sd-gx-md-1{--sd-gutter-x: 0.25rem}.sd-g-md-2,.sd-gy-md-2{--sd-gutter-y: 0.5rem}.sd-g-md-2,.sd-gx-md-2{--sd-gutter-x: 0.5rem}.sd-g-md-3,.sd-gy-md-3{--sd-gutter-y: 1rem}.sd-g-md-3,.sd-gx-md-3{--sd-gutter-x: 1rem}.sd-g-md-4,.sd-gy-md-4{--sd-gutter-y: 1.5rem}.sd-g-md-4,.sd-gx-md-4{--sd-gutter-x: 1.5rem}.sd-g-md-5,.sd-gy-md-5{--sd-gutter-y: 3rem}.sd-g-md-5,.sd-gx-md-5{--sd-gutter-x: 3rem}}@media(min-width: 992px){.sd-col-lg-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-lg-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-lg-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-lg-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-lg-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-lg-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-lg-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-lg-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-lg-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-lg-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-lg-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-lg-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-lg-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-lg-0,.sd-gy-lg-0{--sd-gutter-y: 0}.sd-g-lg-0,.sd-gx-lg-0{--sd-gutter-x: 0}.sd-g-lg-1,.sd-gy-lg-1{--sd-gutter-y: 0.25rem}.sd-g-lg-1,.sd-gx-lg-1{--sd-gutter-x: 0.25rem}.sd-g-lg-2,.sd-gy-lg-2{--sd-gutter-y: 0.5rem}.sd-g-lg-2,.sd-gx-lg-2{--sd-gutter-x: 0.5rem}.sd-g-lg-3,.sd-gy-lg-3{--sd-gutter-y: 1rem}.sd-g-lg-3,.sd-gx-lg-3{--sd-gutter-x: 1rem}.sd-g-lg-4,.sd-gy-lg-4{--sd-gutter-y: 1.5rem}.sd-g-lg-4,.sd-gx-lg-4{--sd-gutter-x: 1.5rem}.sd-g-lg-5,.sd-gy-lg-5{--sd-gutter-y: 3rem}.sd-g-lg-5,.sd-gx-lg-5{--sd-gutter-x: 3rem}}@media(min-width: 1200px){.sd-col-xl-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-xl-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-xl-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-xl-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-xl-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-xl-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-xl-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-xl-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-xl-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-xl-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-xl-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-xl-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-xl-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-xl-0,.sd-gy-xl-0{--sd-gutter-y: 0}.sd-g-xl-0,.sd-gx-xl-0{--sd-gutter-x: 0}.sd-g-xl-1,.sd-gy-xl-1{--sd-gutter-y: 0.25rem}.sd-g-xl-1,.sd-gx-xl-1{--sd-gutter-x: 0.25rem}.sd-g-xl-2,.sd-gy-xl-2{--sd-gutter-y: 0.5rem}.sd-g-xl-2,.sd-gx-xl-2{--sd-gutter-x: 0.5rem}.sd-g-xl-3,.sd-gy-xl-3{--sd-gutter-y: 1rem}.sd-g-xl-3,.sd-gx-xl-3{--sd-gutter-x: 1rem}.sd-g-xl-4,.sd-gy-xl-4{--sd-gutter-y: 1.5rem}.sd-g-xl-4,.sd-gx-xl-4{--sd-gutter-x: 1.5rem}.sd-g-xl-5,.sd-gy-xl-5{--sd-gutter-y: 3rem}.sd-g-xl-5,.sd-gx-xl-5{--sd-gutter-x: 3rem}}.sd-flex-row-reverse{flex-direction:row-reverse !important}details.sd-dropdown{position:relative}details.sd-dropdown .sd-summary-title{font-weight:700;padding-right:3em !important;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;user-select:none}details.sd-dropdown:hover{cursor:pointer}details.sd-dropdown .sd-summary-content{cursor:default}details.sd-dropdown summary{list-style:none;padding:1em}details.sd-dropdown summary .sd-octicon.no-title{vertical-align:middle}details.sd-dropdown[open] summary .sd-octicon.no-title{visibility:hidden}details.sd-dropdown summary::-webkit-details-marker{display:none}details.sd-dropdown summary:focus{outline:none}details.sd-dropdown .sd-summary-icon{margin-right:.5em}details.sd-dropdown .sd-summary-icon svg{opacity:.8}details.sd-dropdown summary:hover .sd-summary-up svg,details.sd-dropdown summary:hover .sd-summary-down svg{opacity:1;transform:scale(1.1)}details.sd-dropdown .sd-summary-up svg,details.sd-dropdown .sd-summary-down svg{display:block;opacity:.6}details.sd-dropdown .sd-summary-up,details.sd-dropdown .sd-summary-down{pointer-events:none;position:absolute;right:1em;top:1em}details.sd-dropdown[open]>.sd-summary-title .sd-summary-down{visibility:hidden}details.sd-dropdown:not([open])>.sd-summary-title .sd-summary-up{visibility:hidden}details.sd-dropdown:not([open]).sd-card{border:none}details.sd-dropdown:not([open])>.sd-card-header{border:1px solid var(--sd-color-card-border);border-radius:.25rem}details.sd-dropdown.sd-fade-in[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out;animation:sd-fade-in .5s ease-in-out}details.sd-dropdown.sd-fade-in-slide-down[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out}.sd-col>.sd-dropdown{width:100%}.sd-summary-content>.sd-tab-set:first-child{margin-top:0}@keyframes sd-fade-in{0%{opacity:0}100%{opacity:1}}@keyframes sd-slide-down{0%{transform:translate(0, -10px)}100%{transform:translate(0, 0)}}.sd-tab-set{border-radius:.125rem;display:flex;flex-wrap:wrap;margin:1em 0;position:relative}.sd-tab-set>input{opacity:0;position:absolute}.sd-tab-set>input:checked+label{border-color:var(--sd-color-tabs-underline-active);color:var(--sd-color-tabs-label-active)}.sd-tab-set>input:checked+label+.sd-tab-content{display:block}.sd-tab-set>input:not(:checked)+label:hover{color:var(--sd-color-tabs-label-hover);border-color:var(--sd-color-tabs-underline-hover)}.sd-tab-set>input:focus+label{outline-style:auto}.sd-tab-set>input:not(.focus-visible)+label{outline:none;-webkit-tap-highlight-color:transparent}.sd-tab-set>label{border-bottom:.125rem solid transparent;margin-bottom:0;color:var(--sd-color-tabs-label-inactive);border-color:var(--sd-color-tabs-underline-inactive);cursor:pointer;font-size:var(--sd-fontsize-tabs-label);font-weight:700;padding:1em 1.25em .5em;transition:color 250ms;width:auto;z-index:1}html .sd-tab-set>label:hover{color:var(--sd-color-tabs-label-active)}.sd-col>.sd-tab-set{width:100%}.sd-tab-content{box-shadow:0 -0.0625rem var(--sd-color-tabs-overline),0 .0625rem var(--sd-color-tabs-underline);display:none;order:99;padding-bottom:.75rem;padding-top:.75rem;width:100%}.sd-tab-content>:first-child{margin-top:0 !important}.sd-tab-content>:last-child{margin-bottom:0 !important}.sd-tab-content>.sd-tab-set{margin:0}.sd-sphinx-override,.sd-sphinx-override *{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sd-sphinx-override p{margin-top:0}:root{--sd-color-primary: #007bff;--sd-color-secondary: #6c757d;--sd-color-success: #28a745;--sd-color-info: #17a2b8;--sd-color-warning: #f0b37e;--sd-color-danger: #dc3545;--sd-color-light: #f8f9fa;--sd-color-muted: #6c757d;--sd-color-dark: #212529;--sd-color-black: black;--sd-color-white: white;--sd-color-primary-highlight: #0069d9;--sd-color-secondary-highlight: #5c636a;--sd-color-success-highlight: #228e3b;--sd-color-info-highlight: #148a9c;--sd-color-warning-highlight: #cc986b;--sd-color-danger-highlight: #bb2d3b;--sd-color-light-highlight: #d3d4d5;--sd-color-muted-highlight: #5c636a;--sd-color-dark-highlight: #1c1f23;--sd-color-black-highlight: black;--sd-color-white-highlight: #d9d9d9;--sd-color-primary-text: #fff;--sd-color-secondary-text: #fff;--sd-color-success-text: #fff;--sd-color-info-text: #fff;--sd-color-warning-text: #212529;--sd-color-danger-text: #fff;--sd-color-light-text: #212529;--sd-color-muted-text: #fff;--sd-color-dark-text: #fff;--sd-color-black-text: #fff;--sd-color-white-text: #212529;--sd-color-shadow: rgba(0, 0, 0, 0.15);--sd-color-card-border: rgba(0, 0, 0, 0.125);--sd-color-card-border-hover: hsla(231, 99%, 66%, 1);--sd-color-card-background: transparent;--sd-color-card-text: inherit;--sd-color-card-header: transparent;--sd-color-card-footer: transparent;--sd-color-tabs-label-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-hover: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-inactive: hsl(0, 0%, 66%);--sd-color-tabs-underline-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-underline-hover: rgba(178, 206, 245, 0.62);--sd-color-tabs-underline-inactive: transparent;--sd-color-tabs-overline: rgb(222, 222, 222);--sd-color-tabs-underline: rgb(222, 222, 222);--sd-fontsize-tabs-label: 1rem} diff --git a/_sphinx_design_static/design-tabs.js b/_sphinx_design_static/design-tabs.js new file mode 100644 index 000000000..36b38cf0d --- /dev/null +++ b/_sphinx_design_static/design-tabs.js @@ -0,0 +1,27 @@ +var sd_labels_by_text = {}; + +function ready() { + const li = document.getElementsByClassName("sd-tab-label"); + for (const label of li) { + syncId = label.getAttribute("data-sync-id"); + if (syncId) { + label.onclick = onLabelClick; + if (!sd_labels_by_text[syncId]) { + sd_labels_by_text[syncId] = []; + } + sd_labels_by_text[syncId].push(label); + } + } +} + +function onLabelClick() { + // Activate other inputs with the same sync id. + syncId = this.getAttribute("data-sync-id"); + for (label of sd_labels_by_text[syncId]) { + if (label === this) continue; + label.previousElementSibling.checked = true; + } + window.localStorage.setItem("sphinx-design-last-tab", syncId); +} + +document.addEventListener("DOMContentLoaded", ready, false); diff --git a/_srcdocs/index.html b/_srcdocs/index.html new file mode 100644 index 000000000..b4409522c --- /dev/null +++ b/_srcdocs/index.html @@ -0,0 +1,572 @@ + + + + + + + + + + + + Source Docs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

Source Docs

+ +
+
+ +
+
+
+ + + + +
+ +
+

Source Docs#

+ +
+ + + + +
+ + + + + + + + +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/interface.html b/_srcdocs/packages/interface.html new file mode 100644 index 000000000..1bfcb1424 --- /dev/null +++ b/_srcdocs/packages/interface.html @@ -0,0 +1,564 @@ + + + + + + + + + + + + aviary.interface + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

aviary.interface

+ +
+
+ +
+
+
+ + + + +
+ +
+

aviary.interface#

+ +
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/interface/cmd_entry_points.html b/_srcdocs/packages/interface/cmd_entry_points.html new file mode 100644 index 000000000..2b9e1039c --- /dev/null +++ b/_srcdocs/packages/interface/cmd_entry_points.html @@ -0,0 +1,565 @@ + + + + + + + + + + + + cmd_entry_points.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

cmd_entry_points.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

cmd_entry_points.py#

+
+
+
+aviary.interface.cmd_entry_points.aviary_cmd()[source]
+

Run an ‘aviary’ sub-command or list help info for ‘aviary’ command or sub-commands.

+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/interface/graphical_input.html b/_srcdocs/packages/interface/graphical_input.html new file mode 100644 index 000000000..36bc4ccae --- /dev/null +++ b/_srcdocs/packages/interface/graphical_input.html @@ -0,0 +1,701 @@ + + + + + + + + + + + + graphical_input.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

graphical_input.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

graphical_input.py#

+
+
+
+class aviary.interface.graphical_input.DraggablePoints(points, ax, canvas)[source]
+

Bases: object

+
+
+__init__(points, ax, canvas)[source]
+
+ +
+
+on_click(event)[source]
+
+ +
+
+on_motion(event)[source]
+
+ +
+
+on_release(event)[source]
+
+ +
+
+update_points(ax, data)[source]
+
+ +
+ +
+
+class aviary.interface.graphical_input.IntegratedPlottingApp[source]
+

Bases: Tk

+
+
+__init__()[source]
+

Return a new top level widget on screen SCREENNAME. A new Tcl interpreter will +be created. BASENAME will be used for the identification of the profile file (see +readprofile). +It is constructed from sys.argv[0] without extensions if None is given. CLASSNAME +is the name of the widget class.

+
+ +
+
+on_click(event)[source]
+
+ +
+
+on_done(event=None)[source]
+
+ +
+
+on_motion(event)[source]
+
+ +
+
+on_release(event)[source]
+
+ +
+
+setup_plot(ax)[source]
+
+ +
+
+show_help()[source]
+
+ +
+
+tooltip_func(x, y)[source]
+
+ +
+
+update_phase_options()[source]
+
+ +
+
+update_plot(ax, data, label, color)[source]
+
+ +
+
+update_point_data(index, point_type, value)[source]
+
+ +
+
+update_point_entries()[source]
+
+ +
+ +
+
+class aviary.interface.graphical_input.Tooltip(ax, tooltip_func)[source]
+

Bases: object

+
+
+__init__(ax, tooltip_func)[source]
+
+ +
+ +
+
+aviary.interface.graphical_input.create_phase_info(times, altitudes, mach_values, polynomial_order, num_segments, optimize_mach_phase_vars, optimize_altitude_phase_vars, user_choices)[source]
+

Creates a dictionary containing the information about different flight phases +based on input times, altitudes, and Mach values.

+

The information includes details such as duration bounds, initial guesses, +and various options for optimization and control for each phase.

+
+
Parameters:
+
    +

  • times (list of float) – The times at which phase changes occur, given in minutes.

    • +

  • altitudes (list of float) – The altitudes corresponding to each phase, given in feet.

    • +

  • mach_values (list of float) – The Mach numbers corresponding to each phase.

    • +
+
+
Returns:
+

A dictionary with all the phase information, including bounds and initial guesses.

+
+
Return type:
+

dict

+
+
+
+ +
+
+aviary.interface.graphical_input.estimate_total_range_trapezoidal(times, mach_numbers)[source]
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/interface/methods_for_level1.html b/_srcdocs/packages/interface/methods_for_level1.html new file mode 100644 index 000000000..2d4dda6cf --- /dev/null +++ b/_srcdocs/packages/interface/methods_for_level1.html @@ -0,0 +1,605 @@ + + + + + + + + + + + + methods_for_level1.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

methods_for_level1.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

methods_for_level1.py#

+
+

This file contains functions needed to run Aviary using the Level 1 interface.

+
+
+aviary.interface.methods_for_level1.run_aviary(aircraft_filename, phase_info, optimizer=None, analysis_scheme=AnalysisScheme.COLLOCATION, objective_type=None, record_filename='dymos_solution.db', restart_filename=None, max_iter=50, run_driver=True, make_plots=True, phase_info_parameterization=None, optimization_history_filename=None)[source]
+

Run the Aviary optimization problem for a specified aircraft configuration and mission.

+

This function creates an instance of the AviaryProblem class using provided phase information, +mission, and mass methods. It processes aircraft and options data from the given aircraft filename, +checks for clashing inputs, and sets up pre- and post-mission systems. The optimization problem is formulated, +initialized with guesses, and run to find a solution.

+
+
Parameters:
+
    +

  • aircraft_filename (str) – Filename from which to load the aircraft and options data.

    • +

  • phase_info (dict) – Information about the phases of the mission.

    • +

  • optimizer (str) – The optimizer to use.

    • +

  • analysis_scheme (AnalysisScheme, optional) – The analysis scheme to use, defaults to AnalysisScheme.COLLOCATION.

    • +

  • objective_type (str, optional) – Type of the optimization objective.

    • +

  • record_filename (str, optional) – Filename for recording the solution, defaults to ‘dymos_solution.db’.

    • +

  • restart_filename (str, optional) – Filename to use for restarting the optimization, if applicable.

    • +

  • max_iter (int, optional) – Maximum number of iterations for the optimizer, defaults to 50.

    • +

  • run_driver (bool, optional) – If True, the driver will be run, defaults to True.

    • +

  • make_plots (bool, optional) – If True, generate plots during the optimization, defaults to True.

    • +

  • phase_info_parameterization (function, optional) – Additional information to parameterize the phase_info object based on +desired cruise altitude and Mach.

    • +
+
+
Returns:
+

The AviaryProblem instance after running the optimization problem.

+
+
Return type:
+

AviaryProblem

+
+
+

Notes

+

The function allows for user overrides on aircraft and options data. +It raises warnings or errors if there are clashing user inputs. +Users can modify or add methods to alter the Aviary problem’s behavior.

+
+ +
+
+aviary.interface.methods_for_level1.run_level_1(input_deck, outdir='output', optimizer='SNOPT', phase_info=None, n2=False, max_iter=50, analysis_scheme=AnalysisScheme.COLLOCATION)[source]
+

This file enables running aviary from the command line with a user specified input deck. +usage: aviary run_mission [input_deck] [opt_args]

+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/interface/methods_for_level2.html b/_srcdocs/packages/interface/methods_for_level2.html new file mode 100644 index 000000000..c80bd0590 --- /dev/null +++ b/_srcdocs/packages/interface/methods_for_level2.html @@ -0,0 +1,850 @@ + + + + + + + + + + + + methods_for_level2.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

methods_for_level2.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

methods_for_level2.py#

+
+
+
+class aviary.interface.methods_for_level2.AviaryProblem(analysis_scheme=AnalysisScheme.COLLOCATION, **kwargs)[source]
+

Bases: Problem

+

Main class for instantiating, formulating, and solving Aviary problems.

+

On a basic level, this problem object is all the conventional user needs +to interact with. Looking at the three “levels” of use cases, from simplest +to most complicated, we have:

+

Level 1: users interact with Aviary through input files (.csv or .yaml, TBD) +Level 2: users interact with Aviary through a Python interface +Level 3: users can modify Aviary’s workings through Python and OpenMDAO

+

This Problem object is simply a specialized OpenMDAO Problem that has +additional methods to help users create and solve Aviary problems.

+
+
+__init__(analysis_scheme=AnalysisScheme.COLLOCATION, **kwargs)[source]
+

Initialize attributes.

+
+ +
+
+add_design_variables()[source]
+

Adds design variables to the Aviary problem.

+

Depending on the mission model and problem type, different design variables and constraints are added.

+

If using the FLOPS model, a design variable is added for the gross mass of the aircraft, with a lower bound of 100,000 lbm and an upper bound of 200,000 lbm.

+
+
If using the GASP model, the following design variables are added depending on the mission type:
    +

  • the initial thrust-to-weight ratio of the aircraft during ascent

    • +

  • the duration of the ascent phase

    • +

  • the time constant for the landing gear actuation

    • +

  • the time constant for the flaps actuation

    • +
+
+
In addition, two constraints are added for the GASP model:
    +

  • the initial altitude of the aircraft with gear extended is constrained to be 50 ft

    • +

  • the initial altitude of the aircraft with flaps extended is constrained to be 400 ft

    • +
+
+
+

If solving a sizing problem, a design variable is added for the gross mass of the aircraft, and another for the gross mass of the aircraft computed during the mission. A constraint is also added to ensure that the residual range is zero.

+

If solving an alternate problem, only a design variable for the gross mass of the aircraft computed during the mission is added. A constraint is also added to ensure that the residual range is zero.

+

In all cases, a design variable is added for the final cruise mass of the aircraft, with no upper bound, and a residual mass constraint is added to ensure that the mass balances.

+
+ +
+
+add_driver(optimizer=None, use_coloring=None, max_iter=50, debug_print=False)[source]
+

Add an optimization driver to the Aviary problem.

+

Depending on the provided optimizer, the method instantiates the relevant driver (ScipyOptimizeDriver or +pyOptSparseDriver) and sets the optimizer options. Options for ‘SNOPT’, ‘IPOPT’, and ‘SLSQP’ are +specified. The method also allows for the declaration of coloring and setting debug print options.

+
+
Parameters:
+
    +

  • optimizer (str) – The name of the optimizer to use. It can be “SLSQP”, “SNOPT”, “IPOPT” or others supported by OpenMDAO. +If “SLSQP”, it will instantiate a ScipyOptimizeDriver, else it will instantiate a pyOptSparseDriver.

    • +

  • use_coloring (bool, optional) – If True (default), the driver will declare coloring, which can speed up derivative computations.

    • +

  • max_iter (int, optional) – The maximum number of iterations allowed for the optimization process. Default is 50. This option is +applicable to “SNOPT”, “IPOPT”, and “SLSQP” optimizers.

    • +

  • debug_print (bool or list, optional) – If True, default debug print options [‘desvars’,’ln_cons’,’nl_cons’,’objs’] will be set. If a list is +provided, it will be used as the debug print options.

    • +
+
+
Return type:
+

None

+
+
+
+ +
+
+add_objective(objective_type=None, ref=None)[source]
+

Add the objective function based on the given objective_type and ref.

+

NOTE: the ref value should be positive for values you’re trying +to minimize and negative for values you’re trying to maximize. +Please check and double-check that your ref value makes sense +for the objective you’re using.

+
+
Parameters:
+
    +

  • objective_type (str) – The type of objective to add. Options are ‘mass’, ‘hybrid_objective’, ‘fuel_burned’, and ‘fuel’.

    • +

  • ref (float) – The reference value for the objective. If None, a default value will be used based on the objective type. Please see the +default_ref_values dict for these default values.

    • +
+
+
Raises:
+

ValueError – If an invalid problem type is provided.:

+
+
+
+ +
+
+add_phases(phase_info_parameterization=None)[source]
+

Add the mission phases to the problem trajectory based on the user-specified +phase_info dictionary.

+
+
Parameters:
+
    +

  • (function (phase_info_parameterization) – and aviary_inputs and returns modified aviary_inputs. Defaults to None.

    • +

  • optional) (A function that takes in the phase_info dictionary) – and aviary_inputs and returns modified aviary_inputs. Defaults to None.

    • +
+
+
Returns:
+

traj

+
+
Return type:
+

The Dymos Trajectory object containing the added mission phases.

+
+
+
+ +
+
+add_post_mission_systems(include_landing=True)[source]
+

Add post-mission systems to the aircraft model. This is akin to the statics group +or the “premission_systems”, but occurs after the mission in the execution order.

+

Depending on the mission model specified (FLOPS or GASP), this method adds various subsystems +to the aircraft model. For the FLOPS mission model, a landing phase is added using the Landing class +with the wing area and lift coefficient specified, and a takeoff constraints ExecComp is added to enforce +mass, range, velocity, and altitude continuity between the takeoff and climb phases. The landing subsystem +is promoted with aircraft and mission inputs and outputs as appropriate, while the takeoff constraints ExecComp +is only promoted with mission inputs and outputs.

+

For the GASP mission model, four subsystems are added: a LandingSegment subsystem, an ExecComp to calculate +the reserve fuel required, an ExecComp to calculate the overall fuel burn, and three ExecComps to calculate +various mission objectives and constraints. All subsystems are promoted with aircraft and mission inputs and +outputs as appropriate.

+

A user can override this with their own postmission systems.

+
+ +
+
+add_pre_mission_systems()[source]
+

Add pre-mission systems to the Aviary problem. These systems are executed before the mission +and are also known as the “pre_mission” group.

+

Depending on the mission model specified (FLOPS or GASP), this method adds various subsystems +to the aircraft model. For the FLOPS mission model, a takeoff phase is added using the Takeoff class +with the number of engines and airport altitude specified. For the GASP mission model, three subsystems +are added: a TaxiSegment subsystem, an ExecComp to calculate the time to initiate gear and flaps, +and an ExecComp to calculate the speed at which to initiate rotation. All subsystems are promoted with +aircraft and mission inputs and outputs as appropriate.

+

A user can override this method with their own pre-mission systems as desired.

+
+ +
+
+check_and_preprocess_inputs()[source]
+

This method checks the user-supplied input values for any potential problems +and preprocesses the inputs to prepare them for use in the Aviary problem.

+
+ +
+
+link_phases()[source]
+

Link phases together after they’ve been added.

+

Based on which phases the user has selected, we might need +special logic to do the Dymos linkages correctly. Some of those +connections for the simple GASP and FLOPS mission are shown here.

+
+ +
+
+load_inputs(input_filename, phase_info=None, engine_builder=None)[source]
+

This method loads the aviary_values inputs and options that the +user specifies. They could specify files to load and values to +replace here as well. +Phase info is also loaded if provided by the user. If phase_info is None, +the appropriate default phase_info based on mission analysis method is used.

+

This method is not strictly necessary; a user could also supply +an AviaryValues object and/or phase_info dict of their own.

+
+ +
+
+run_aviary_problem(record_filename='aviary_history.db', optimization_history_filename=None, restart_filename=None, suppress_solver_print=True, run_driver=True, simulate=False, make_plots=True)[source]
+

This function actually runs the Aviary problem, which could be a simulation, optimization, or a driver execution, depending on the arguments provided.

+
+
Parameters:
+
    +

  • record_filename (str, optional) – The name of the database file where the solutions are to be recorded. The default is “aviary_history.db”.

    • +

  • optimization_history_filename (str, None) – The name of the database file where the driver iterations are to be recorded. The default is None.

    • +

  • restart_filename (str, optional) – The name of the file that contains previously computed solutions which are to be used as starting points for this run. If it is None (default), no restart file will be used.

    • +

  • suppress_solver_print (bool, optional) – If True (default), all solvers’ print statements will be suppressed. Useful for deeply nested models with multiple solvers so the print statements don’t overwhelm the output.

    • +

  • run_driver (bool, optional) – If True (default), the driver (aka optimizer) will be executed. If False, the problem will be run through one pass – equivalent to OpenMDAO’s run_model behavior.

    • +

  • simulate (bool, optional) – If True, an explicit Dymos simulation will be performed. The default is False.

    • +

  • make_plots (bool, optional) – If True (default), Dymos html plots will be generated as part of the output.

    • +
+
+
+
+ +
+
+set_initial_guesses()[source]
+

Call set_val on the trajectory for states and controls to seed +the problem with reasonable initial guesses. This is especially +important for collocation methods.

+

This method first identifies all phases in the trajectory then +loops over each phase. If the mission method is “solved”, solved guesses +are added to the problem for each phase as those are handled differently +than other mission types. If not solved, specific initial guesses +are added depending on the phase and mission method. Cruise is treated +as a special phase for GASP-based missions because it is an AnalyticPhase +in Dymos. For this phase, we handle the initial guesses first separately +and continue to the next phase after that. For other phases, we set the initial +guesses for states and controls according to the information available +in the ‘initial_guesses’ attribute of the phase.

+
+ +
+
+setup(**kwargs)[source]
+

Lightly wrappd setup() method for the problem.

+

Allows us to do pre- and post-setup changes, like adding +calls to set_input_defaults and do some simple set_vals +if needed.

+
+ +
+ +
+
+class aviary.interface.methods_for_level2.PostMissionGroup(**kwargs)[source]
+

Bases: Group

+
+
+configure()[source]
+

Configure this group to assign children settings.

+

This method may optionally be overidden by your Group’s method.

+

You may only use this method to change settings on your children subsystems. This includes +setting solvers in cases where you want to override the defaults.

+

You can assume that the full hierarchy below your level has been instantiated and has +already called its own configure methods.

+
+
Available attributes:

name +pathname +comm +options +system hieararchy with attribute access

+
+
+
+ +
+ +
+
+class aviary.interface.methods_for_level2.PreMissionGroup(**kwargs)[source]
+

Bases: Group

+
+
+configure()[source]
+

Configure this group to assign children settings.

+

This method may optionally be overidden by your Group’s method.

+

You may only use this method to change settings on your children subsystems. This includes +setting solvers in cases where you want to override the defaults.

+

You can assume that the full hierarchy below your level has been instantiated and has +already called its own configure methods.

+
+
Available attributes:

name +pathname +comm +options +system hieararchy with attribute access

+
+
+
+ +
+ +
+
+aviary.interface.methods_for_level2.wrapped_convert_units(val_unit_tuple, new_units)[source]
+

Wrapper for OpenMDAO’s convert_units function.

+
+
Parameters:
+
    +

  • val_unit_tuple (tuple) – Tuple of the form (value, units) where value is a float and units is a +string.

    • +

  • new_units (string) – New units to convert to.

    • +
+
+
Returns:
+

Value converted to new units.

+
+
Return type:
+

float

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/interface/reports.html b/_srcdocs/packages/interface/reports.html new file mode 100644 index 000000000..5610b2bba --- /dev/null +++ b/_srcdocs/packages/interface/reports.html @@ -0,0 +1,578 @@ + + + + + + + + + + + + reports.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

reports.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

reports.py#

+
+
+
+aviary.interface.reports.register_custom_reports()[source]
+

Registers Aviary reports with openMDAO, so they are automatically generated and +added to the same reports folder as other default reports

+
+ +
+
+aviary.interface.reports.subsystem_report(prob, **kwargs)[source]
+

Loops through all subsystem builders in the AviaryProblem calls their write_report +method. All generated report files are placed in the ./reports/subsystem_reports folder

+
+
Parameters:
+

prob (AviaryProblem) – The AviaryProblem that will be used to generate this report

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils.html b/_srcdocs/packages/utils.html new file mode 100644 index 000000000..fa935e7de --- /dev/null +++ b/_srcdocs/packages/utils.html @@ -0,0 +1,577 @@ + + + + + + + + + + + + aviary.utils + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

aviary.utils

+ +
+
+ +
+
+
+ + + + +
+ +
+

aviary.utils#

+ +
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/Fortran_to_Aviary.html b/_srcdocs/packages/utils/Fortran_to_Aviary.html new file mode 100644 index 000000000..d9dbcf815 --- /dev/null +++ b/_srcdocs/packages/utils/Fortran_to_Aviary.html @@ -0,0 +1,646 @@ + + + + + + + + + + + + Fortran_to_Aviary.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

Fortran_to_Aviary.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

Fortran_to_Aviary.py#

+
+

Fortran_to_Aviary.py is used to read in Fortran based vehicle decks and convert them to Aviary decks.

+

FLOPS, GASP, or Aviary names can be used for variables (Ex WG or Mission:Design:GROSS_MASS) +When specifying variables from FORTRAN, they should be in the appropriate NAMELIST. +Aviary variable names should be specified outside any NAMELISTS. +Names are not case-sensitive. +Units can be specified using any of the openMDAO valid units. +Comments can be added using ! +Lists can be entered by separating values with commas. +Individual list elements can be specified by adding an index after the variable name. +(NOTE: 1 indexing is used inside NAMELISTS, while 0 indexing is used outside NAMELISTS)

+

Example inputs: +aircraft:fuselage:pressure_differential = .5, atm !DELP in GASP, but using atmospheres instead of psi +ARNGE(1) = 3600 !target range in nautical miles +pyc_phases = taxi, groundroll, rotation, landing +debug_mode = True

+
+
+aviary.utils.Fortran_to_Aviary.create_aviary_deck(fortran_deck: str, legacy_code=None, defaults_deck=None, out_file=None, force=False)[source]
+

Create an Aviary CSV file from a Fortran input deck +Required input is the filepath to the input deck and legacy code. Optionally, a +deck of default values can be specified, this is useful if an input deck +assumes certain values for any unspecified variables +If an invalid filepath is given, pre-packaged resources will be checked for +input decks with a matching name.

+
+ +
+
+aviary.utils.Fortran_to_Aviary.generate_aviary_names(code_bases)[source]
+

Create a dictionary for each of the specified Fortran code bases to map to the Aviary +variable names. Each dictionary of Aviary names will have a list of Fortran names for +each variable

+
+ +
+
+aviary.utils.Fortran_to_Aviary.input_parser(fortran_deck, vehicle_data, alternate_names, unused_vars, legacy_code)[source]
+

input_parser will modify the values in the vehicle_data dictionary using the data in the +fortran_deck. +Lines are read one by one, comments are removed, and namelists are tracked. +Lines with multiple variable-data pairs are supported, but the last value per variable must +be followed by a trailing comma.

+
+ +
+
+aviary.utils.Fortran_to_Aviary.process_and_store_data(data, var_name, legacy_code, current_namelist, alternate_names, vehicle_data, unused_vars, comment='')[source]
+

process_and_store_data takes in a string that contains the data, the current variable’s name and +namelist, the dictionary of alternate names, and the current vehicle data. +It will convert the string of data into a list, get units, check whether the data specified is +part of a list or a single element, and update the current name to it’s equivalent Aviary name. +The variables are also sorted based on whether they will set an Aviary variable or they are for initial guessing

+
+ +
+
+aviary.utils.Fortran_to_Aviary.set_value(var_name, var_value, value_dict: NamedValues, var_ind=None, units=None)[source]
+

set_value will update the current value of a variable in a value dictionary that contains a value +and it’s associated units. +If units are specified for the new value, they will be used, otherwise the current units in the +value dictionary or the default units from _MetaData are used. +If the new variable is part of a list, the current list will be extended if needed.

+
+ +
+
+aviary.utils.Fortran_to_Aviary.update_flops_options(vehicle_data)[source]
+

Handles variables that are affected by the values of others

+
+ +
+
+aviary.utils.Fortran_to_Aviary.update_flops_scalar_variables(var_name, input_values: NamedValues)[source]
+
+ +
+
+aviary.utils.Fortran_to_Aviary.update_gasp_options(vehicle_data)[source]
+

Handles variables that are affected by the values of others

+
+ +
+
+aviary.utils.Fortran_to_Aviary.update_name(alternate_names, var_name, debug_mode=False)[source]
+

update_name will convert a Fortran name to a list of equivalent Aviary names.

+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/aero_table_conversion.html b/_srcdocs/packages/utils/aero_table_conversion.html new file mode 100644 index 000000000..89f25c864 --- /dev/null +++ b/_srcdocs/packages/utils/aero_table_conversion.html @@ -0,0 +1,580 @@ + + + + + + + + + + + + aero_table_conversion.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

aero_table_conversion.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

aero_table_conversion.py#

+
+
+
+aviary.utils.aero_table_conversion.AeroDataConverter(input_file=None, output_file=None, data_format=None)[source]
+
+ +
+
+class aviary.utils.aero_table_conversion.CodeOrigin(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+
+
+FLOPS = 'FLOPS'
+
+ +
+
+GASP = 'GASP'
+
+ +
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/aviary_values.html b/_srcdocs/packages/utils/aviary_values.html new file mode 100644 index 000000000..0c4fd8718 --- /dev/null +++ b/_srcdocs/packages/utils/aviary_values.html @@ -0,0 +1,601 @@ + + + + + + + + + + + + aviary_values.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

aviary_values.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

aviary_values.py#

+
+

Define utilities for using aviary values with associated units and testing +for compatibility with aviary metadata dictionary.

+
+

Utilities#

+
+
Unitstype alias

define a type hint for associated units

+
+
ValueAndUnitstype alias

define a type hint for a single value paired with its associated units

+
+
OptionalValueAndUnitstype alias

define a type hint for an optional single value paired with its associated units

+
+
class AviaryValues

define a collection of named values with associated units

+
+
+
+
+class aviary.utils.aviary_values.AviaryValues(other=None, **kwargs)[source]
+

Bases: NamedValues

+

Define a collection of aviary values with associated units and aviary tests.

+
+
+set_val(key, val, units='unitless', meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}})[source]
+

Update the named value and its associated units.

+

Note, specifying units of None or units of any type other than str will raise +Typerror.

+
+
Parameters:
+
    +

  • key (str) – the name of the item

    • +

  • val (Any) – the new value of the item

    • +

  • units (str ('unitless')) – the units associated with the new value, if any

    • +
+
+
Raises:
+

TypeError – if units of None were specified or units of any type other than str

+
+
+
+ +
+ +
+
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/compare_hierarchies.html b/_srcdocs/packages/utils/compare_hierarchies.html new file mode 100644 index 000000000..726e9452e --- /dev/null +++ b/_srcdocs/packages/utils/compare_hierarchies.html @@ -0,0 +1,653 @@ + + + + + + + + + + + + compare_hierarchies.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

compare_hierarchies.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

compare_hierarchies.py#

+
+
+
+aviary.utils.compare_hierarchies.compare_hierarchies_to_merge(hierarchies_to_merge)[source]
+

Compares variable hierarchies to ensure there are no string-valued variable conflicts.

+

For all the variable hierarchies provided in hierarchies_to_merge this function compares each +hierarchy with every other hierarchy as well as the Aviary core aircraft and mission hierarchies +to ensure there are no string-valued variable conflicts within the same class or inner class to +and infinite depth.

+
+
Parameters:
+

hierarchies_to_merge (list of classes) – This is a list of variable hierarchy classes which will be compared for merge compatibility +with one another.

+
+
Return type:
+

None

+
+
Raises:
+

No explicit exceptions are raised by this function, although called functions may raise exceptions. –

+
+
+
+ +
+
+aviary.utils.compare_hierarchies.compare_inner_classes(class1, class2, show_all=False)[source]
+

Compare two nested class hierarchies and return a set of shared inner-classes.

+

Summary: +This function takes in two classes that both are part of variable hierarchies and may contain +inner-classes or variables with string-named values. This function compares those two classes +and returns a set of inner classes that have the same name in both inputted classes. It will throw +an error if the two classes have the same variable with a different string-named value.

+
+
Parameters:
+
    +

  • class1 (class) – A class that is all or part of a variable hierarchy. This can be the top-level +class in the hierarchy, or any inner class nested at any depth within that top-level class.

    • +

  • class2 (class) – A class that is all or part of a variable hierarchy. This can be the top-level +class in the hierarchy, or any inner class nested at any depth within that top-level class.

    • +

  • show_all (bool, optional) – Flag to tell the function to return the sets of variables and inner classes for +each provided class.

    • +
+
+
Returns:
+

    +

  • overlapping_inner_classes (set of strings) – A set of string names of all the inner classes which are common between the two +input classes.

    • +

  • class1_vars_set (set of strings, optional) – Set of string names of the variables belonging to class1, optional return based +on show_all flag.

    • +

  • class2_vars_set (set of strings, optional) – Set of string names of the variables belonging to class2, optional return based +on show_all flag.

    • +

  • class1_inner_classes_set (set of strings, optional) – Set of the string names of inner classes belonging to class1, optional return based +on show_all flag.

    • +

  • class2_inner_classes_set (set of strings, optional) – Set of the string names of inner classes belonging to class2, optional return based +on show_all flag.

    • +
+

+
+
Raises:
+

ValueError – If the two input classes both have a variable with the same variable name but + different string-named value.

+
+
+
+ +
+
+aviary.utils.compare_hierarchies.recursive_comparison(overlapping_inner_classes, outer_class_a, outer_class_b)[source]
+

Recursively compares all inner classes to an infinite depth and identifies mismatched string-named values.

+

For all of the inner class names provided in overlapping_inner_classes this function calls compare_inner_classes +and compares those inner classes recursively until it reaches the full depth to which outer_class_a and +outer_class_b have any inner classes in common.

+
+
Parameters:
+
    +

  • overlapping_inner_classes (set of strings) – This is a set of strings where each string is the name of an inner class that outer_class_a +and outer_class_b have in common.

    • +

  • outer_class_a (class) – A class that is all or part of a variable hierarchy. This can be the top-level class in the +hierarchy, or any inner class nested at any depth within that top-level class.

    • +

  • outer_class_b (class) – A class that is all or part of a variable hierarchy. This can be the top-level class in the +hierarchy, or any inner class nested at any depth within that top-level class.

    • +
+
+
Returns:
+

    +

  • None

    • +

  • Exceptions

    • +

  • ———-

    • +

  • No exceptions explicitly raised by this function, although called functions may raise exceptions.

    • +
+

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/conflict_checks.html b/_srcdocs/packages/utils/conflict_checks.html new file mode 100644 index 000000000..828c05234 --- /dev/null +++ b/_srcdocs/packages/utils/conflict_checks.html @@ -0,0 +1,564 @@ + + + + + + + + + + + + conflict_checks.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

conflict_checks.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

conflict_checks.py#

+
+
+
+aviary.utils.conflict_checks.check_fold_location_definition(inputs, options: AviaryValues)[source]
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/csv_data_file.html b/_srcdocs/packages/utils/csv_data_file.html new file mode 100644 index 000000000..36706e726 --- /dev/null +++ b/_srcdocs/packages/utils/csv_data_file.html @@ -0,0 +1,611 @@ + + + + + + + + + + + + csv_data_file.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

csv_data_file.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

csv_data_file.py#

+
+
+
+aviary.utils.csv_data_file.read_data_file(filename: (<class 'str'>, <class 'pathlib.Path'>), metadata=None, aliases=None, save_comments=False)[source]
+

Read data file in Aviary format, which is data delimited by commas with any amount of +whitespace allowed between data entries. Spaces are not allowed in openMDAO +variables, so any spaces in header entries are replaced with underscores.

+
+
Parameters:
+
    +

  • filename ((str, Path)) – filename or filepath of data file to be read

    • +

  • metadata (dict, optional) – metadata to check validity of variable names provided in data file. Columns with +variable names that can’t be found in metadata will be skipped. If not provided, +all validly formatted columns are always read.

    • +

  • aliases (dict, optional) – optional dictionary to define a mapping of variables to allowable aliases in the +data file header. Keys are variable names, to be used in openMDAO, values +are a list of headers that correspond to that variable. Alias matching is not +case-sensitive, and underscores and spaces are treated as equivalent.

    • +

  • save_comments (bool, optional) – flag if comments in data file should be returned along with data. Defaults to +False.

    • +
+
+
Returns:
+

    +

  • data (NamedValues) – data read from file in NamedValues format, including variable name, units, and +values (stored in a numpy array)

    • +

  • comments (list of str) – any comments from file, with comment characters (‘#’) stripped out (only if +save_comments=True)

    • +
+

+
+
+
+ +
+
+aviary.utils.csv_data_file.write_data_file(filename: (<class 'str'>, <class 'pathlib.Path'>) = None, data: ~aviary.utils.named_values.NamedValues = None, comments: (<class 'str'>, <class 'list'>) = [], include_timestamp: bool = False)[source]
+

Write data to a comma-separated values (csv) format file using the Aviary data table +format.

+
+
Parameters:
+
    +

  • filename ((str, Path)) – filename or filepath for data file to be written

    • +

  • data (NamedValues) – NamedValues object containing data that will be written to file, which includes +variable name, units, and values

    • +

  • comments ((str, list of str), optional) – optional comments that will be included in the top of the output file, before +data begins

    • +

  • include_timestamp (bool, optional) – optional flag to set if timestamp and user should be include in file comments

    • +
+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/data_interpolator_builder.html b/_srcdocs/packages/utils/data_interpolator_builder.html new file mode 100644 index 000000000..353408308 --- /dev/null +++ b/_srcdocs/packages/utils/data_interpolator_builder.html @@ -0,0 +1,597 @@ + + + + + + + + + + + + data_interpolator_builder.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

data_interpolator_builder.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

data_interpolator_builder.py#

+
+
+
+aviary.utils.data_interpolator_builder.build_data_interpolator(num_nodes, interpolator_data=None, interpolator_outputs=None, method='slinear', extrapolate=True, structured=None, training_data=False)[source]
+

Builder for openMDAO metamodel components using data provided via data file, directly +provided as an argument, or training data passed through openMDAO connections. +If using a structured grid, data can either be converted from a semistructured +grid format, or directly provided in structured grid format.

+
+
Parameters:
+
    +

  • num_nodes (int) – Number of points that will be simultaneously interpolated during model executuion.

    • +

  • interpolator_data ((str, Path, NamedValues)) – Path to the Aviary csv file containing all data required for interpolation, or +the data directly given as a NamedValues object.

    • +

  • interpolator_outputs (dict) – Dictionary describing the names of dependent variables (keys) and their +units (values). If training_data is False, these variable names must reference +variables in data_file or interpolator_data. If training_data is True, then +this dictionary describes the names and units for training data that will be +provided via openMDAO connections during model execution.

    • +

  • method (str, optional) – Interpolation method for metamodel. See openMDAO documentation for valid +options.

    • +

  • extrapolate (bool, optional) – Flag that sets if metamodel should allow extrapolation

    • +

  • structured (bool, optional) – Flag to set if interpolation data is a structure grid. If True, the +structured metamodel component is used, if False, the semistructured metamodel is +used. If None, the builder chooses based on provided data structure.

    • +

  • training_data (bool, optional) – Flag that sets if dependent data for interpolation will be passed via openMDAO +connections. If True, any provided values for dependent variables will +be ignored.

    • +
+
+
Returns:
+

interp_comp – OpenMDAO metamodel component using the provided data and flags

+
+
Return type:
+

om.MetaModelSemiStructuredComp, om.MetaModelStructuredComp

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/develop_metadata.html b/_srcdocs/packages/utils/develop_metadata.html new file mode 100644 index 000000000..adb7e3967 --- /dev/null +++ b/_srcdocs/packages/utils/develop_metadata.html @@ -0,0 +1,673 @@ + + + + + + + + + + + + develop_metadata.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

develop_metadata.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

develop_metadata.py#

+
+
+
+aviary.utils.develop_metadata.add_meta_data(key, meta_data, units='unitless', desc=None, default_value=0.0, option=False, types=None, historical_name=None, _check_unique=True)[source]
+

Add new meta data associated with variables in the Aviary data hierarchy.

+
+
Parameters:
+
    +

  • key (str) – Aviary variable name

    • +

  • meta_data (dict) – dictionary of meta data to add the variable to

    • +

  • units (str or None) – units of measure

    • +

  • desc (str) – brief description of the variable

    • +

  • default_value (any) –

    in context, the Aviary value assumed if the variable is missing from +options and/or inputs

    +

    Note, a default value of None indicates that the variable is +optional, but that there is no default.

    +

    • +

  • option (bool) – indicates that this variable is an option, rather than a normal input

    • +

  • types (type) – gives the allowable type(s) of the variable

    • +

  • historical_name (dict or None) –

    dictionary of names that the variable held in prior codes

    +

    Example: {“FLOPS”:”WTIN.WNGWT”, “LEAPS1”: “aircraft.inputs.wing_weight”, “GASP”: “INGASP.WWGHT”}

    +
    +
    NAMELIST nameing convention

    &<function_name>.<namelist_name>.<var_name>

    +
    +
    Example: &DEFINE.CONFIN.GW

    represents the GW variable of the CONFIN namelist as defined in +the DEFINE subroutine

    +
    +
    +
    +
    COMMON block naming convention, including aliases:

    <block_name>.<var_name>

    +
    +
    Example: CONFIG.GW

    represents the GW variable of the CONFIG common block

    +
    +
    +
    +
    Local variable naming convention, including equivalence statements, parameters, and other local declarations:

    ~<function_name>.<var_name>

    +
    +
    Example: ~ANALYS.GWTOL

    represents the GWTOL variable of the ANALYS subroutine

    +
    +
    +
    +
    +

    • +

  • _check_unique (bool) – private use only flag that tells whether to check the meta_data for the pre-existing presence +of the provided key. This should only be set to false when update_meta_data is the calling function.

    • +
+
+
Returns:
+

No variables returned by this method.

+
+
Return type:
+

None

+
+
Raises:
+

None – No exceptions raised by this method, although other methods called within may raise exceptions.

+
+
+
+ +
+
+aviary.utils.develop_metadata.update_meta_data(key, meta_data, units='unitless', desc=None, default_value=0.0, option=False, types=None, historical_name=None)[source]
+

Update existing meta data associated with variables in the Aviary data hierarchy.

+
+
Parameters:
+
    +

  • key (str) – Aviary variable name

    • +

  • meta_data (dict) – dictionary of meta data to add the variable to

    • +

  • units (str or None) – units of measure

    • +

  • desc (str) – brief description of the variable

    • +

  • default_value (Any) –

    in context, the Aviary value assumed if the variable is missing from +options and/or inputs

    +

    Note, a default value of None indicates that the variable is +optional, but that there is no default.

    +

    • +

  • option (bool) – indicates that this variable is an option, rather than a normal input

    • +

  • types (type) – gives the allowable type(s) of the variable

    • +

  • historical_name (dict or None) –

    dictionary of names that the variable held in prior codes

    +

    Example: {“FLOPS”:”WTIN.WNGWT”, “LEAPS1”: “aircraft.inputs.wing_weight”, “GASP”: “INGASP.WWGHT”}

    +
    +
    NAMELIST nameing convention

    &<function_name>.<namelist_name>.<var_name>

    +
    +
    Example: &DEFINE.CONFIN.GW

    represents the GW variable of the CONFIN namelist as defined in +the DEFINE subroutine

    +
    +
    +
    +
    COMMON block naming convention, including aliases:

    <block_name>.<var_name>

    +
    +
    Example: CONFIG.GW

    represents the GW variable of the CONFIG common block

    +
    +
    +
    +
    Local variable naming convention, including equivalence statements, parameters, and other local declarations:

    ~<function_name>.<var_name>

    +
    +
    Example: ~ANALYS.GWTOL

    represents the GWTOL variable of the ANALYS subroutine

    +
    +
    +
    +
    +

    • +
+
+
Returns:
+

No variables returned by this method.

+
+
Return type:
+

None

+
+
Raises:
+

None – No exceptions raised by this method, although other methods called within may raise exceptions.

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/engine_deck_conversion.html b/_srcdocs/packages/utils/engine_deck_conversion.html new file mode 100644 index 000000000..189b39e9d --- /dev/null +++ b/_srcdocs/packages/utils/engine_deck_conversion.html @@ -0,0 +1,679 @@ + + + + + + + + + + + + engine_deck_conversion.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

engine_deck_conversion.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

engine_deck_conversion.py#

+
+
+
+class aviary.utils.engine_deck_conversion.AtmosCalc(**kwargs)[source]
+

Bases: ExplicitComponent

+

Calculates T2 and P2 given static temperature and pressure

+
+
+compute(inputs, outputs)[source]
+

Compute outputs given inputs. The model is assumed to be in an unscaled state.

+
+
Parameters:
+
    +

  • inputs (Vector) – Unscaled, dimensional input variables read via inputs[key].

    • +

  • outputs (Vector) – Unscaled, dimensional output variables read via outputs[key].

    • +

  • discrete_inputs (dict or None) – If not None, dict containing discrete input values.

    • +

  • discrete_outputs (dict or None) – If not None, dict containing discrete output values.

    • +
+
+
+
+ +
+
+initialize()[source]
+

Perform any one-time initialization run at instantiation.

+
+ +
+
+setup()[source]
+

Declare inputs and outputs.

+
+
Available attributes:

name +pathname +comm +options

+
+
+
+ +
+ +
+
+class aviary.utils.engine_deck_conversion.CalculateIdle(**kwargs)[source]
+

Bases: ExplicitComponent

+

Calculates idle conditions of a GASP engine at a specified flight condition +Vectorized to calculate values for entire flight regime

+
+
+compute(inputs, outputs)[source]
+

Compute outputs given inputs. The model is assumed to be in an unscaled state.

+
+
Parameters:
+
    +

  • inputs (Vector) – Unscaled, dimensional input variables read via inputs[key].

    • +

  • outputs (Vector) – Unscaled, dimensional output variables read via outputs[key].

    • +

  • discrete_inputs (dict or None) – If not None, dict containing discrete input values.

    • +

  • discrete_outputs (dict or None) – If not None, dict containing discrete output values.

    • +
+
+
+
+ +
+
+initialize()[source]
+

Perform any one-time initialization run at instantiation.

+
+ +
+
+setup()[source]
+

Declare inputs and outputs.

+
+
Available attributes:

name +pathname +comm +options

+
+
+
+ +
+ +
+
+aviary.utils.engine_deck_conversion.EngineDeckConverter(input_file=None, output_file=None, data_format=None)[source]
+

Converts FLOPS- or GASP-formatted engine decks into Aviary csv format. +FLOPS decks are changed from column-delimited to csv format with added headers. +GASP decks are reorganized into csv. T4 is recovered using assumptions used in GASPy. +Data points whose T4 exceeds T4max are removed.

+
+
Parameters:
+
    +

  • input_file ((str, Path)) – path to engine deck file to be converted

    • +

  • output_file ((str, Path)) – path to file where new converted data will be written

    • +

  • data_format ((EngineDeckType)) – data format used by input_file (FLOPS or GASP)

    • +

  • readable ((bool)) – output_file will be organized with consistent column widths for easier reading

    • +
+
+
+
+ +
+
+class aviary.utils.engine_deck_conversion.EngineDeckType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+
+
+FLOPS = 'FLOPS'
+
+ +
+
+GASP = 'GASP'
+
+ +
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/functions.html b/_srcdocs/packages/utils/functions.html new file mode 100644 index 000000000..3b2237655 --- /dev/null +++ b/_srcdocs/packages/utils/functions.html @@ -0,0 +1,713 @@ + + + + + + + + + + + + functions.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

functions.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

functions.py#

+
+
+
+class aviary.utils.functions.Null[source]
+

Bases: object

+

This can be used to divert outputs, such as stdout, to improve performance

+
+
+flush(*args, **kwargs)[source]
+
+ +
+
+write(*args, **kwargs)[source]
+
+ +
+ +
+
+aviary.utils.functions.add_opts2vals(Group: Group, OptionsToValues, aviary_options: AviaryValues)[source]
+

Add the OptionsToValues component to the specified Group.

+
+
Parameters:
+
    +

  • Group (Group) – The group or model the component should be added to.

    • +

  • OptionsToValues (ExplicitComponent) – This is the explicit component that was created by create_opts2vals.

    • +

  • aviary_options (AviaryValues) – aviary_options is an AviaryValues object that contains all of the options +that need to be converted to outputs.

    • +
+
+
Returns:
+

Opts2Vals – A group that wraps the OptionsToValues component in order to rename its +variables with a prefix to keep them separate from any similarly named +variables in the original group the component is being added to.

+
+
Return type:
+

Group

+
+
+
+ +
+
+aviary.utils.functions.apply_all_values(aircraft_values: AviaryValues, prob)[source]
+
+ +
+
+aviary.utils.functions.convert_strings_to_data(string_list)[source]
+
+ +
+
+aviary.utils.functions.create_opts2vals(all_options: list, output_units: dict = {})[source]
+

create_opts2vals creates a component that converts options to outputs.

+
+
Parameters:
+
    +

  • all_options (list of strings) – Each string is the name of an option in aviary_options.

    • +

  • output_units (dict of units, optional) – This optional input allows the user to specify the units that will be used while +adding the outputs. Only the outputs that shouldn’t use their default units need +to be specified. Each key should match one of the names in all_options, and each +value must be a string representing a valid unit in openMDAO.

    • +
+
+
Returns:
+

OptionsToValues – An explicit component that takes in an AviaryValues object that contains any +options that need to be converted to outputs. There are no inputs to this +component, only outputs. If the resulting component is added directly to a +Group, the output variables will have the same name as the options they +represent. If you need to rename them to prevent conflicting names in the +group, running add_opts2vals will add the prefix “option:” to the name.

+
+
Return type:
+

ExplicitComponent

+
+
+
+ +
+
+aviary.utils.functions.create_printcomp(all_inputs: list, input_units: dict = {}, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}})[source]
+

Creates a component that prints the value of all inputs.

+
+
Parameters:
+
    +

  • all_inputs (list of strings) – Each string is the name of a variable in the system

    • +

  • input_units (dict of units, optional) – This optional input allows the user to specify the units that will be used while +adding the inputs. Only the variables that shouldn’t use their default units need +to be specified. Each key should match one of the names in all_inputs, and each +value must be a string representing a valid unit in openMDAO.

    • +
+
+
Returns:
+

PrintComp – An explicit component that can be added to a group to print the current values +of connected variables. There are no outputs from this component, only inputs.

+
+
Return type:
+

ExplicitComponent

+
+
+
+ +
+
+aviary.utils.functions.get_path(path: [<class 'str'>, <class 'pathlib.Path'>], verbose: bool = False) → Path[source]
+

Convert a string or Path object to an absolute Path object, prioritizing different locations.

+

This function attempts to find the existence of a path in the following order: +1. As an absolute path. +2. Relative to the current working directory. +3. Relative to the Aviary package.

+

If the path cannot be found in any of the locations, a FileNotFoundError is raised.

+
+
Parameters:
+
    +

  • path (str or Path) – The input path, either as a string or a Path object.

    • +

  • verbose (bool, optional) – If True, prints the final path being used. Default is False.

    • +
+
+
Returns:
+

The absolute path to the file.

+
+
Return type:
+

Path

+
+
Raises:
+

FileNotFoundError – If the path is not found in any of the prioritized locations.

+
+
+
+ +
+
+aviary.utils.functions.promote_aircraft_and_mission_vars(group)[source]
+
+ +
+
+aviary.utils.functions.set_aviary_initial_values(model, inputs, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}})[source]
+

This function sorts through all the input +variables to an Aviary model, and for those +which are not options it sets the input +value to be the value in the inputs, or +to be the default if the value is not in the +inputs.

+

In the case when the value is not input nor +present in the default, nothing is set.

+
+ +
+
+aviary.utils.functions.set_value(var_name, var_value, aviary_values: ~aviary.utils.aviary_values.AviaryValues, units=None, is_array=False, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}})[source]
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/merge_hierarchies.html b/_srcdocs/packages/utils/merge_hierarchies.html new file mode 100644 index 000000000..3c6d4745c --- /dev/null +++ b/_srcdocs/packages/utils/merge_hierarchies.html @@ -0,0 +1,679 @@ + + + + + + + + + + + + merge_hierarchies.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

merge_hierarchies.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

merge_hierarchies.py#

+
+
+
+aviary.utils.merge_hierarchies.merge_attributes(base_class, merge_class, base_class_attributes, merge_class_attributes)[source]
+

Adds unique attributes of merge_class to base_class.

+

For all the attributes of merge_class that are not present in base_class we add them to base_class. +Attributes present in both classes are ignored because if they are variables they have already +been checked and found identical and if they are inner classes they will be addressed on a +recursive call to this function. Attributes present only in base_class are ignored because we are +adding to base_class and thus all of its features are automatically preserved.

+
+
Parameters:
+
    +

  • base_class (class) – A class that is all or part of a variable hierarchy. This can be the top=level +class in the hierarchy, or any inner class nested at any depth within that top-level class.

    • +

  • merge_class (class) – A class that is all or part of a variable hierarchy. This can be the top=level +class in the hierarchy, or any inner class nested at any depth within that top-level class.

    • +

  • base_class_attributes (set of strings) – A set of the name of all attributes (either variables, inner classes, or both) of base_class.

    • +

  • merge_class_attributes (set of strings) – A set of the name of all attributes (either variables, inner classes, or both) of merge_class.

    • +
+
+
Returns:
+

base_class – A class that contains the merged together attributes of base_class and merge_class, with +the exception that inner class base_class and merge_class share which have diverging attributes inside +of them are not necessarily included.

+
+
Return type:
+

class

+
+
Raises:
+

None – No exceptions raised by this method, although other methods called within may raise exceptions.

+
+
+
+ +
+
+aviary.utils.merge_hierarchies.merge_hierarchies(hierarchies_to_merge)[source]
+

Combines all provided variable hierarchies into one unified variable hierarchy.

+

Performs checks on the user-provided list of variable hierarchies in order to ensure that they are +compatible for merge. Ensures that they are not derived from different superclasses, and that they do +not have conflicting values. Assuming all checks pass, the provided hierarchies are combined into a +single hierarchy.

+
+
Parameters:
+

hierarchies_to_merge (list of classes) – This is a list of all the variable hierarchies which should be merged into a single hierarchy. This list should not include hierarchies of multiple types (i.e. an av.Mission hierarchy extension should not be mixed with an av.Aircraft hierarchy extension)

+
+
Returns:
+

merged_hierarchy – Aviary variable hierarchy that includes all the variables present in the inputted hierarchy list. Duplicates have been removed, and conflicting duplicates are not possible.

+
+
Return type:
+

class

+
+
Raises:
+

ValueError – Raises an exception if the list of inputted variable hierarchies includes hierarchies that have been subclassed from different superclasses.

+
+
+
+ +
+
+aviary.utils.merge_hierarchies.merge_two_hierarchies(base_hierarchy, hierarchy_b)[source]
+

Merge two variable hierarchies together by adding the second into the first.

+

Add the attributes (variables and inner classes) of two variable hierarchies together, so that +the attributes that are unique to each hierarchy are combined in the resultant hierarchy. This +is accomplished by adding on to the first of the two provided hierarchies, and returning it.

+
+
Parameters:
+
    +

  • base_hierarchy (class) – An Aviary variable hierarchy. This hierarchy will function as the ‘base’ hierarchy, +which is the hierarchy that has attributes added onto it from another hierarchy in order to combine +the attributes of the base and the other hierarchy.

    • +

  • hierarchy_b (class) – An Aviary variable hierarchy. This hierarchy will function as the ‘auxiliary’ hierarhcy, +which is the hierarchy whose unique attributes are added onto a base in order to combine the +attributes of the base and the auxiliary.

    • +
+
+
Returns:
+

base_hierarchy – An Aviary variable hierarchy which includes both the attributes of the inputted base_hierarchy +and hierarchy_b. This is the same object as the inputted base_hierarchy and has been updated through +mutability.

+
+
Return type:
+

class

+
+
Raises:
+

None – No exceptions raised by this method, although other methods called within may raise exceptions.

+
+
+
+ +
+
+aviary.utils.merge_hierarchies.recursive_merge(overlapping_inners, base_class, merge_class)[source]
+

Recursively compares all inner classes to an infinite depth and identifies mismatched string-named values.

+

For all of the inner class names provided in overlapping_inner_classes this function calls compare_inner_classes +and compares those inner classes recursively until it reaches the full depth to which outer_class_a and +outer_class_b have any inner classes in common.

+
+
Parameters:
+
    +

  • overlapping_inner_classes (set of strings) – This is a set of strings where each string is the name of an inner class that outer_class_a +and outer_class_b have in common.

    • +

  • outer_class_a (class) – A class that is all or part of a variable hierarchy. This can be the top-level class in the +hierarchy, or any inner class nested at any depth within that top-level class.

    • +

  • outer_class_b (class) – A class that is all or part of a variable hierarchy. This can be the top-level class in the +hierarchy, or any inner class nested at any depth within that top-level class.

    • +
+
+
Returns:
+

No variables returned by this method.

+
+
Return type:
+

None

+
+
Raises:
+

None – No exceptions raised by this method, although other methods called within may raise exceptions.

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/merge_variable_metadata.html b/_srcdocs/packages/utils/merge_variable_metadata.html new file mode 100644 index 000000000..65807d905 --- /dev/null +++ b/_srcdocs/packages/utils/merge_variable_metadata.html @@ -0,0 +1,613 @@ + + + + + + + + + + + + merge_variable_metadata.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

merge_variable_metadata.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

merge_variable_metadata.py#

+
+
+
+aviary.utils.merge_variable_metadata.almost_equal(a, b, rel_tol=1e-08, abs_tol=0.0)[source]
+
+ +
+
+aviary.utils.merge_variable_metadata.merge_2_meta_data_dicts(dict1, dict2)[source]
+

Combines metadata from two dictionaries into a single dictionary containing metadata of both.

+

Performs a check to ensure that the two dictionaries don’t have the same variable with conflicting +metadata. Assuming that check passes, the variables and their associated metadata from both +dictionaries are combined into one dictionary.

+
+
Parameters:
+
    +

  • dict1 (dict) – Dictionaries with keys of Aviary variables and values of their associated metadata.

    • +

  • dict2 (dict) – Dictionaries with keys of Aviary variables and values of their associated metadata.

    • +
+
+
Returns:
+

new_dict – Single dictionary with all the combined entries from the two input Aviary metadata dictionaries.

+
+
Return type:
+

dict

+
+
Raises:
+

ValueError – Raises error if dict1 and dict2 have differing metadata for the same variable.

+
+
+
+ +
+
+aviary.utils.merge_variable_metadata.merge_meta_data(dicts_to_merge)[source]
+

Merges the metadata of multiple Aviary metadata dictionaries into a single metadata dictionary.

+

Checks the metadata of all the provided Aviary metadata dictionaries to see if there are identical +variables with conflicting metadata. Assuming this check passes, the input dictionaries are merged +together into a single dictionary containing all their information.

+
+
Parameters:
+

dicts_to_merge (list of dicts) – List of Aviary metadata dictionaries to be merged.

+
+
Returns:
+

merged_dict – Single Aviary metadata dictionary with all the information of the inputted metadata dictionaries.

+
+
Return type:
+

dict

+
+
Raises:
+

None – No exceptions raised by this method, although other methods called within may raise exceptions.

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/named_values.html b/_srcdocs/packages/utils/named_values.html new file mode 100644 index 000000000..d99beb142 --- /dev/null +++ b/_srcdocs/packages/utils/named_values.html @@ -0,0 +1,769 @@ + + + + + + + + + + + + named_values.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

named_values.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

named_values.py#

+
+

Define utilities for using named values with associated units.

+
+

Utilities#

+
+
Unitstype alias

define a type hint for associated units

+
+
ValueAndUnitstype alias

define a type hint for a single value paired with its associated units

+
+
OptionalValueAndUnitstype alias

define a type hint for an optional single value paired with its associated units

+
+
class NamedValues

define a collection of named values with associated units

+
+
+
+
+class aviary.utils.named_values.NamedValues(other=None, **kwargs)[source]
+

Bases: Collection

+

Define a collection of named values with associated units.

+
+
+__contains__(key)[source]
+

Return whether or not the named value exists.

+
+ +
+
+__init__(other=None, **kwargs)[source]
+

Initialize this collection.

+

Notes

+

When intializing from another collection, the following types of +collections are supported:

+
+
    +

  • NamedValues

    • +

  • Dict[str, ValueAndUnits]

    • +

  • Iterable[Tuple[str, ValueAndUnits]]

    • +
+
+

When initializing from keyword arguments, the mapped item must be of a +type of ValueAndUnits.

+
+ +
+
+__iter__()[source]
+

Return an iterator over the (key, (val, units)) data stored in this collection.

+
+ +
+
+clear()[source]
+

Remove all items from the collection.

+
+ +
+
+copy()[source]
+

Return a copy of the instance of this class.

+
+
Parameters:
+

None –

+
+
Return type:
+

NamedValues()

+
+
+
+ +
+
+deepcopy()[source]
+

Return a deep copy of the instance of this class.

+
+
Parameters:
+

None –

+
+
Return type:
+

NamedValues()

+
+
+
+ +
+
+delete(key)[source]
+

Remove the named value and its associated units.

+
+
Raises:
+

KeyError – if the named value does not exist

+
+
+
+ +
+
+get_item(key, default=(None, None)) → Union[Tuple[Any, str], Any][source]
+

Return the named value and its associated units.

+

Note, this method never raises KeyError or TypeError.

+
+
Parameters:
+
    +

  • key (str) – the name of the item

    • +

  • default (OptionalValueAndUnits (None, None)) – if the item does not exist, return this object

    • +
+
+
Return type:
+

OptionalValueAndUnits

+
+
+
+

See also

+

get_val, set_val

+
+
+ +
+
+get_val(key, units='unitless') → Any[source]
+

Return the named value in the specified units.

+

Note, requesting a named value that does not exist will raise KeyError.

+

Note, specifying units of None or units of any type other than str will raise +TypeError.

+
+
Parameters:
+
    +

  • key (str) – the name of the item

    • +

  • units (str ('unitless')) – the units of the returned value

    • +
+
+
Return type:
+

val

+
+
Raises:
+
    +

  • KeyError – if the named value does not exist

    • +

  • TypeError – if units of None were specified or units of any type other than str

    • +
+
+
+
+ +
+
+set_val(key, val, units='unitless')[source]
+

Update the named value and its associated units.

+

Note, specifying units of None or units of any type other than str will raise +Typerror.

+
+
Parameters:
+
    +

  • key (str) – the name of the item

    • +

  • val (Any) – the new value of the item

    • +

  • units (str ('unitless')) – the units associated with the new value, if any

    • +
+
+
Raises:
+

TypeError – if units of None were specified or units of any type other than str

+
+
+
+ +
+
+update(other=None, **kwargs)[source]
+

Assign named values and their associated units found in another +collection to this collection, overwriting existing items.

+

If keyword arguments are specified, the collection is then assigned those +named values and their associated units, overwriting existing items.

+
+
Parameters:
+
    +

  • (None) (other) – a collection of named values and their associated units

    • +

  • (optional) (**kwargs) – individual named values and their associated units

    • +
+
+
+

Notes

+
+
The following types of collections are supported
    +

  • NamedValues

    • +

  • Dict[str, ValueAndUnits]

    • +

  • Iterable[Tuple[str, ValueAndUnits]]

    • +
+
+
+

When assigning from keyword arguments, the mapped item must be of a +type of ValueAndUnits.

+
+ +
+ +
+
+aviary.utils.named_values.get_items(named_values: NamedValues)[source]
+

Return a new view of the collection’s (key, (val, units)).

+
+ +
+
+aviary.utils.named_values.get_keys(named_values: NamedValues)[source]
+

Return a new view of the collection’s names.

+
+ +
+
+aviary.utils.named_values.get_values(named_values: NamedValues)[source]
+

Return a new view of the collection’s (val, units).

+
+ +
+
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/options.html b/_srcdocs/packages/utils/options.html new file mode 100644 index 000000000..db9d8ddda --- /dev/null +++ b/_srcdocs/packages/utils/options.html @@ -0,0 +1,577 @@ + + + + + + + + + + + + options.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

options.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

options.py#

+
+
+
+aviary.utils.options.list_options(model: System, aviary_keys: list = None)[source]
+

Lists all option values in the provided model. All top-level option values will +be listed, and items in model.options[‘aviary_options’] will also be listed. +A list of keys may be provided to limit the list of items in aviary_options.

+
+
Parameters:
+
    +

  • model (System) – A model.

    • +

  • aviary_keys (iter of str) – List of aviary_options keys whose values will be looked up and +listed in the options printout. If None, all items in +model.options[‘aviary_options’] will be listed.

    • +
+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/preprocessors.html b/_srcdocs/packages/utils/preprocessors.html new file mode 100644 index 000000000..e3ab08d49 --- /dev/null +++ b/_srcdocs/packages/utils/preprocessors.html @@ -0,0 +1,602 @@ + + + + + + + + + + + + preprocessors.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

preprocessors.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

preprocessors.py#

+
+
+
+aviary.utils.preprocessors.preprocess_crewpayload(aviary_options: AviaryValues)[source]
+

Calculates option values that are derived from other options, and are not direct inputs. +This function modifies the entries in the supplied collection, and for convenience also +returns the modified collection.

+
+ +
+
+aviary.utils.preprocessors.preprocess_options(aviary_options: AviaryValues)[source]
+

Run all preprocessors on provided AviaryValues object

+
+
Parameters:
+

aviary_options (AviaryValues) – Options to be updated

+
+
+
+ +
+
+aviary.utils.preprocessors.preprocess_propulsion(aviary_options: AviaryValues, engine_models: list = None)[source]
+

Updates AviaryValues object with values taken from provided EngineModels.

+

If no EngineModels are provided, either in engine_models or included in +aviary_options, an EngineDeck is created using avaliable inputs and options in +aviary_options.

+

Vectorizes variables in aviary_options in the correct order for multi-engine +vehicles.

+

Performs basic sanity checks on inputs that are universal to all EngineModels.

+

!!! WARNING !!! +Values in aviary_options are overwritten with corresponding values in engine_models!

+
+
Parameters:
+
    +

  • aviary_options (AviaryValues) – Options to be updated. EngineModels (provided or generated) are added, and +Aircraft:Engine:* and Aircraft:Nacelle:* variables are vectorized as numpy arrays

    • +

  • engine_models (<list of EngineModels> (optional)) – EngineModel objects to be added to aviary_options. Replaced existing EngineModels +in aviary_options

    • +
+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/process_input_decks.html b/_srcdocs/packages/utils/process_input_decks.html new file mode 100644 index 000000000..3512821ca --- /dev/null +++ b/_srcdocs/packages/utils/process_input_decks.html @@ -0,0 +1,672 @@ + + + + + + + + + + + + process_input_decks.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

process_input_decks.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

process_input_decks.py#

+
+

This module, process_input_decks.py, is responsible for reading vehicle input decks, initializing options, +and setting initial guesses for aircraft design parameters. It works primarily with .csv files, +allowing for the specification of units, comments, and lists within these files.

+

The module supports various functions like creating a vehicle, parsing input files, updating options based +on inputs, and handling initial guesses for different aircraft design aspects. It heavily relies on the +aviary and openMDAO libraries for processing and interpreting the aircraft design parameters.

+
+
Functions:

create_vehicle(vehicle_deck=’’): Create and initialize a vehicle with default or specified parameters. +parse_inputs(vehicle_deck, aircraft_values): Parse input files and update aircraft values and initial guesses. +update_options(aircraft_values, initial_guesses): Update dependent options based on current aircraft values. +update_dependent_options(aircraft_values, dependent_options): Update options that depend on the value of an input variable. +initial_guessing(aircraft_values): Set initial guesses for aircraft parameters based on problem type and other factors.

+
+
+
+
+aviary.utils.process_input_decks.create_vehicle(vehicle_deck='')[source]
+

Creates and initializes a vehicle with default or specified parameters. It sets up the aircraft values +and initial guesses based on the input from the vehicle deck.

+
+
Parameters:
+

(str) (vehicle_deck) –

+
+
Returns:
+

tuple

+
+
Return type:
+

Returns a tuple containing aircraft values and initial guesses.

+
+
+
+ +
+
+aviary.utils.process_input_decks.initial_guessing(aircraft_values: {})[source]
+

Sets initial guesses for various aircraft parameters based on the current problem type, aircraft values, +and other factors. It calculates and sets values like takeoff mass, cruise mass, flight duration, etc.

+
+
Parameters:
+

(AviaryValues) (aircraft_values) –

+
+
Returns:
+

tuple

+
+
Return type:
+

Updated aircraft values and initial guesses.

+
+
+
+ +
+
+aviary.utils.process_input_decks.parse_inputs(vehicle_deck, aircraft_values: {}, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}})[source]
+

Parses the input files and updates the aircraft values and initial guesses. The function reads the +vehicle deck file, processes each line, and updates the aircraft_values object based on the data found.

+
+
Parameters:
+
    +

  • (str) (vehicle_deck) –

    • +

  • (AviaryValues) (aircraft_values) –

    • +
+
+
Returns:
+

tuple

+
+
Return type:
+

Updated aircraft values and initial guesses.

+
+
+
+ +
+
+aviary.utils.process_input_decks.update_dependent_options(aircraft_values: {}, dependent_options)[source]
+

Updates options that are dependent on the value of an input variable or option. The function iterates +through each dependent option and sets its value based on the current aircraft values.

+
+
Parameters:
+
    +

  • (AviaryValues) (aircraft_values) –

    • +

  • (list) (dependent_options) –

    • +
+
+
Returns:
+

AviaryValues

+
+
Return type:
+

Updated aircraft values with modified dependent options.

+
+
+
+ +
+
+aviary.utils.process_input_decks.update_options(aircraft_values: {}, initial_guesses)[source]
+

Updates options based on the current values in aircraft_values. This function also handles special cases +and prints debug information if the debug mode is active.

+
+
Parameters:
+
    +

  • (AviaryValues) (aircraft_values) –

    • +

  • (dict) (initial_guesses) –

    • +
+
+
Returns:
+

tuple

+
+
Return type:
+

Updated aircraft values and initial guesses.

+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/report.html b/_srcdocs/packages/utils/report.html new file mode 100644 index 000000000..6bfe2d29c --- /dev/null +++ b/_srcdocs/packages/utils/report.html @@ -0,0 +1,579 @@ + + + + + + + + + + + + report.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

report.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

report.py#

+
+
+
+aviary.utils.report.report_benchmark_comparison(prob, rtol=0.1, remote=False, file=None, size_engine=False, base='GASP')[source]
+
+ +
+
+aviary.utils.report.report_cruise(prob, remote=False, file=None)[source]
+
+ +
+
+aviary.utils.report.report_fuelburn(prob, remote=False, file=None)[source]
+
+ +
+
+aviary.utils.report.report_gasp_comparison(prob, rtol=0.1, remote=False, file=None)[source]
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/utils/set_mass_defaults.html b/_srcdocs/packages/utils/set_mass_defaults.html new file mode 100644 index 000000000..0e8543e54 --- /dev/null +++ b/_srcdocs/packages/utils/set_mass_defaults.html @@ -0,0 +1,564 @@ + + + + + + + + + + + + set_mass_defaults.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

set_mass_defaults.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

set_mass_defaults.py#

+
+
+
+aviary.utils.set_mass_defaults.mass_defaults(prob)[source]
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info.html b/_srcdocs/packages/variable_info.html new file mode 100644 index 000000000..6d90ad4fc --- /dev/null +++ b/_srcdocs/packages/variable_info.html @@ -0,0 +1,566 @@ + + + + + + + + + + + + aviary.variable_info + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

aviary.variable_info

+ +
+
+ +
+
+
+ + + + +
+ +
+

aviary.variable_info#

+ +
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info/core_promotes.html b/_srcdocs/packages/variable_info/core_promotes.html new file mode 100644 index 000000000..e23169f5b --- /dev/null +++ b/_srcdocs/packages/variable_info/core_promotes.html @@ -0,0 +1,560 @@ + + + + + + + + + + + + core_promotes.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

core_promotes.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

core_promotes.py#

+
+

Curated list of aviary inputs that are promoted as parameters in the mission.

+
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info/enums.html b/_srcdocs/packages/variable_info/enums.html new file mode 100644 index 000000000..dd85e2658 --- /dev/null +++ b/_srcdocs/packages/variable_info/enums.html @@ -0,0 +1,891 @@ + + + + + + + + + + + + enums.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

enums.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

enums.py#

+
+
+
+class aviary.variable_info.enums.AlphaModes(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+
+
AlphaModes is used to specify how angle of attack is defined during

climb and descent.

+
+
DEFAUT:

Alpha is an input

+
+
ROTATION

Alpha is calculated as the initial angle plus the rotation rate +times the duration of the rotation.

+
+
LOAD_FACTOR

Alpha is limited to ensure the load factor never exceeds a +specified maximum.

+
+
FUSELAGE_PITCH

Alpha is calculated to set a particular floor angle given the +current flight path angle.

+
+
DECELERATION

Alpha is calculated to target a specified TAS rate, the default +is a TAS rate of 0 (Constant TAS).

+
+
REQUIRED_LIFT

Alpha is calculated such that the aircraft produces a particular +lifting force.

+
+
ALTITUDE_RATE

Alpha is calculated to target a specified altitude rate, the default +is 0 (Constant Altitude).

+
+
+
+
+ALTITUDE_RATE = 7
+
+ +
+
+CONSTANT_ALTITUDE = 8
+
+ +
+
+DECELERATION = 5
+
+ +
+
+DEFAULT = 1
+
+ +
+
+FUSELAGE_PITCH = 4
+
+ +
+
+LOAD_FACTOR = 3
+
+ +
+
+REQUIRED_LIFT = 6
+
+ +
+
+ROTATION = 2
+
+ +
+ +
+
+class aviary.variable_info.enums.AnalysisScheme(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

AnalysisScheme is used to select from Collocation and shooting.

+

COLLOCATION uses the collocation method to optimize all points simultaneously +and can be run in parallel. However, it requires reasonable initial guesses +for the trajectory and is fairly sensitive to those initial guesses.

+

SHOOTING is a forward in time integration method that simulates the trajectory. +This does not require initial guesses and will always produce physically valid +trajectories, even during optimizer failures. The shooting method cannot be run +in parallel.

+
+
+COLLOCATION = 1
+
+ +
+
+SHOOTING = 2
+
+ +
+ +
+
+class aviary.variable_info.enums.EquationsOfMotion(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

Available equations of motion for use during mission analysis

+
+
+HEIGHT_ENERGY = 'height_energy'
+
+ +
+
+SIMPLE = 'simple'
+
+ +
+
+SOLVED = 'solved'
+
+ +
+
+TWO_DEGREES_OF_FREEDOM = '2DOF'
+
+ +
+ +
+
+class aviary.variable_info.enums.FlapType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

Defines the type of flap used on the wing. Used in GASP-based aerodynamics and mass calculations.

+
+
+DOUBLE_SLOTTED = 4
+
+ +
+
+DOUBLE_SLOTTED_FOWLER = 7
+
+ +
+
+FOWLER = 6
+
+ +
+
+PLAIN = 1
+
+ +
+
+SINGLE_SLOTTED = 3
+
+ +
+
+SPLIT = 2
+
+ +
+
+TRIPLE_SLOTTED = 5
+
+ +
+ +
+
+class aviary.variable_info.enums.GASPEngineType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

Defines the type of engine to use in GASP-based mass calculations. +Note that only the value for the first engine model will be used. +Currenly only the TURBOJET option is implemented, but other types of engines will be added in the future.

+
+
+RECIP_CARB = 1
+
+ +
+
+RECIP_CARB_HOPWSZ = 11
+
+ +
+
+RECIP_FUEL_INJECT = 2
+
+ +
+
+RECIP_FUEL_INJECT_GEARED = 3
+
+ +
+
+RECIP_FUEL_INJECT_GEARED_HOPWSZ = 13
+
+ +
+
+RECIP_FUEL_INJECT_HOPWSZ = 12
+
+ +
+
+ROTARY = 4
+
+ +
+
+ROTARY_RCWSZ = 14
+
+ +
+
+TURBOJET = 7
+
+ +
+
+TURBOPROP = 6
+
+ +
+
+TURBOSHAFT = 5
+
+ +
+ +
+
+class aviary.variable_info.enums.LegacyCode(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

Flag for legacy codebases

+
+
+FLOPS = 'FLOPS'
+
+ +
+
+GASP = 'GASP'
+
+ +
+ +
+
+class aviary.variable_info.enums.ProblemType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

ProblemType is used to switch between different combinations of +design variables and constraints.

+

SIZING: Varies the design gross weight and actual gross weight to +close to design range. This causes the empty weight and the fuel +weight to change.

+

ALTERNATE: Requires a pre-sized aircraft. It holds the design gross +weight and empty weight constant. It then varies the fuel weight +and actual gross weight until the range closes to the off-design +range.

+

FALLOUT: Requires a pre-sized aircraft. It holds the design gross +weight and empty weight constant. Using the specified actual +gross weight, it will then find the maximum distance the off-design +aircraft can fly.

+
+
+ALTERNATE = 'alternate'
+
+ +
+
+FALLOUT = 'fallout'
+
+ +
+
+SIZING = 'sizing'
+
+ +
+ +
+
+class aviary.variable_info.enums.SpeedType(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

SpeedType is used to specify the type of speed being used. +EAS is equivalent airspeed. +TAS is true airspeed. +MACH is mach

+
+
+EAS = 1
+
+ +
+
+MACH = 3
+
+ +
+
+TAS = 2
+
+ +
+ +
+
+class aviary.variable_info.enums.Verbosity(value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]
+

Bases: Enum

+

Sets how much information Aviary outputs when run

+

Verbosity levels are based on ubuntu’s standard: +https://discourse.ubuntu.com/t/cli-verbosity-levels/26973

+
+
+BRIEF = 1
+
+ +
+
+DEBUG = 3
+
+ +
+
+QUIET = 0
+
+ +
+
+VERBOSE = 2
+
+ +
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info/functions.html b/_srcdocs/packages/variable_info/functions.html new file mode 100644 index 000000000..83bf948ca --- /dev/null +++ b/_srcdocs/packages/variable_info/functions.html @@ -0,0 +1,613 @@ + + + + + + + + + + + + functions.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

functions.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

functions.py#

+
+
+
+aviary.variable_info.functions.add_aviary_input(comp, varname, val=None, units=None, desc=None, shape_by_conn=False, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}})[source]
+

This function provides a clean way to add variables from the +variable hierarchy into components as Aviary inputs. It takes +the standard OpenMDAO inputs of the variable’s name, initial +value, units, and description, as well as the component which +the variable is being added to.

+
+ +
+
+aviary.variable_info.functions.add_aviary_output(comp, varname, val, units=None, desc=None, shape_by_conn=False, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}})[source]
+

This function provides a clean way to add variables from the +variable hierarchy into components as Aviary outputs. It takes +the standard OpenMDAO inputs of the variable’s name, initial +value, units, and description, as well as the component which +the variable is being added to.

+
+ +
+
+aviary.variable_info.functions.get_units(key, meta_data=None) → str[source]
+

Returns the units for the specified variable as defined in the MetaData.

+
+
Parameters:
+
    +

  • key (str) – Name of the variable

    • +

  • meta_data (dict) – Dictionary containing metadata for the variable. If None, Aviary’s built-in +metadata will be used.

    • +
+
+
+
+ +
+
+aviary.variable_info.functions.override_aviary_vars(group, aviary_inputs: AviaryValues, manual_overrides=None, external_overrides=None)[source]
+

This function provides the capability to override output variables +with variables from the aviary_inputs input. The user can also +optionally provide the names of variables that they would like to +override manually. (Manual overriding is simply suppressing the +promotion of the variable to make way for another output variable +of the same name, or to create an unconnected input elsewhere.)

+
+ +
+
+aviary.variable_info.functions.setup_trajectory_params(model: ~openmdao.core.group.Group, traj: ~dymos.trajectory.trajectory.Trajectory, aviary_variables: ~aviary.utils.aviary_values.AviaryValues, phases=['climb', 'cruise', 'descent'], variables_to_add=None, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}}, external_parameters={})[source]
+

This function smoothly sorts through the aviary variables which +are being used in the trajectory, and for the variables which are +not options it adds them as a parameter of the trajectory.

+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info/options.html b/_srcdocs/packages/variable_info/options.html new file mode 100644 index 000000000..402e73f78 --- /dev/null +++ b/_srcdocs/packages/variable_info/options.html @@ -0,0 +1,589 @@ + + + + + + + + + + + + options.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

options.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

options.py#

+
+
+
+aviary.variable_info.options.get_option_defaults(engine=True, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}}) → AviaryValues[source]
+

Returns a deep copy of the collection of all options for which default values exist.

+
+
Parameters:
+
    +

  • engine (bool) – If true, the collection includes the default engine model

    • +

  • meta_data (dict) – Dictionary containing metadata for the options. If None, Aviary’s built-in +metadata will be used.

    • +
+
+
+
+ +
+
+aviary.variable_info.options.is_option(key, meta_data={'aircraft:air_conditioning:mass': {'default_value': None, 'desc': 'air conditioning system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._air_conditioning_group_weight', 'aircraft.outputs.L0_weights_summary.air_conditioning_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:air_conditioning:mass_scaler': {'default_value': 1.0, 'desc': 'air conditioning system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.air_conditioning_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:anti_icing:mass': {'default_value': None, 'desc': 'mass of anti-icing system (auxiliary gear)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_gear_weight', 'aircraft.outputs.L0_weights_summary.aux_gear_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:anti_icing:mass_scaler': {'default_value': 1.0, 'desc': 'anti-icing system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_gear_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:apu:mass': {'default_value': None, 'desc': 'mass of auxiliary power unit', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._aux_power_weight', 'aircraft.outputs.L0_weights_summary.aux_power_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:apu:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for auxiliary power unit', 'historical_name': {'FLOPS': 'WTIN.WAPU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.aux_power_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:avionics:mass': {'default_value': None, 'desc': 'avionics mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._avionics_group_weight', 'aircraft.outputs.L0_weights_summary.avionics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:avionics:mass_scaler': {'default_value': 1.0, 'desc': 'avionics mass scaler', 'historical_name': {'FLOPS': 'WTIN.WAVONC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.avionics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:cabin_area': {'default_value': 0.0, 'desc': 'fixed area of passenger cabin for blended wing body transports', 'historical_name': {'FLOPS': 'FUSEIN.ACABIN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.cabin_area', 'aircraft.cached.L0_blended_wing_body_design.cabin_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:blended_wing_body_design:num_bays': {'default_value': 0, 'desc': 'fixed number of bays', 'historical_name': {'FLOPS': 'FUSEIN.NBAY', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_blended_wing_body_design.bay_count', 'aircraft.cached.L0_blended_wing_body_design.bay_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep': {'default_value': 45.0, 'desc': 'sweep angle of the leading edge of the passenger cabin', 'historical_name': {'FLOPS': 'FUSEIN.SWPLE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_blended_wing_body_design.passenger_leading_edge_sweep'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:canard:area': {'default_value': 0.0, 'desc': 'canard theoretical area', 'historical_name': {'FLOPS': 'WTIN.SCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:aspect_ratio': {'default_value': None, 'desc': 'canard theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the canard', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[-1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:canard:fineness': {'default_value': 0.0, 'desc': 'canard fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[-1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for canard upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:mass': {'default_value': None, 'desc': 'mass of canards', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._canard_weight', 'aircraft.outputs.L0_weights_summary.canard_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:canard:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for canard structure', 'historical_name': {'FLOPS': 'WTIN.FRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.canard_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:taper_ratio': {'default_value': None, 'desc': 'canard theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:thickness_to_chord': {'default_value': 0.0, 'desc': 'canard thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCCAN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_canard.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:canard:wetted_area': {'default_value': None, 'desc': 'canard wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.canard_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[-1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[-1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:canard:wetted_area_scaler': {'default_value': 1.0, 'desc': 'canard wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.canard_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:cockpit_control_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on cockpit controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK15', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:control_mass_increment': {'default_value': 0, 'desc': 'incremental flight controls mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass': {'default_value': 0, 'desc': 'mass of stability augmentation system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSAS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:controls:stability_augmentation_system_mass_scaler': {'default_value': 1, 'desc': 'technology factor on stability augmentation system mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK19', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:controls:total_mass': {'default_value': 0.0, 'desc': 'total mass of cockpit controls, fixed wing controls, and SAS', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass': {'default_value': 0.0, 'desc': 'mass of passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_bag_weight', 'aircraft.outputs.L0_weights_summary.passenger_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:baggage_mass_per_passenger': {'default_value': None, 'desc': 'baggage mass per passenger', 'historical_name': {'FLOPS': 'WTIN.BPP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.baggage_weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass': {'default_value': None, 'desc': 'mass of cargo containers', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cargo_containers_weight', 'aircraft.outputs.L0_weights_summary.cargo_containers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:cargo_container_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for mass of cargo containers', 'historical_name': {'FLOPS': 'WTIN.WCON', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cargo_containers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:cargo_mass': {'default_value': 0.0, 'desc': 'total mass of cargo', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCARGO', 'LEAPS1': ['(WeightABC)self._cargo_weight', 'aircraft.outputs.L0_weights_summary.cargo_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass': {'default_value': None, 'desc': 'total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._flight_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.flight_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WFLCRB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.flight_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:mass_per_passenger': {'default_value': 165.0, 'desc': 'mass per passenger', 'historical_name': {'FLOPS': 'WTIN.WPPASS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.weight_per_passenger'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:misc_cargo': {'default_value': 0.0, 'desc': 'cargo (other than passenger baggage) carried in fuselage', 'historical_name': {'FLOPS': 'WTIN.CARGOF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.misc_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass': {'default_value': None, 'desc': 'total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._cabin_crew_and_bag_weight', 'aircraft.outputs.L0_weights_summary.cabin_crew_and_bag_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:non_flight_crew_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for total mass of the non-flight crew and their baggage', 'historical_name': {'FLOPS': 'WTIN.WSTUAB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.cabin_crew_and_bag_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_business_class': {'default_value': 0, 'desc': 'number of business class passengers', 'historical_name': {'FLOPS': 'WTIN.NPB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.business_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_first_class': {'default_value': 0, 'desc': 'number of first class passengers', 'historical_name': {'FLOPS': 'WTIN.NPF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.first_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_attendants': {'default_value': None, 'desc': 'number of flight attendants', 'historical_name': {'FLOPS': 'WTIN.NSTU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_attendants_count', 'aircraft.cached.L0_crew_and_payload.flight_attendants_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_flight_crew': {'default_value': None, 'desc': 'number of flight crew', 'historical_name': {'FLOPS': 'WTIN.NFLCR', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.flight_crew_count', 'aircraft.cached.L0_crew_and_payload.flight_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_galley_crew': {'default_value': None, 'desc': 'number of galley crew', 'historical_name': {'FLOPS': 'WTIN.NGALC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.galley_crew_count', 'aircraft.cached.L0_crew_and_payload.galley_crew_count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_passengers': {'default_value': 0, 'desc': 'total number of passengers', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PAX', 'LEAPS1': 'aircraft.outputs.L0_crew_and_payload.passenger_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:num_tourist_class': {'default_value': 0, 'desc': 'number of tourist class passengers', 'historical_name': {'FLOPS': 'WTIN.NPT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.tourist_class_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:crew_and_payload:passenger_mass': {'default_value': 0.0, 'desc': 'TBD: total mass of all passengers without their baggage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_weight', 'aircraft.outputs.L0_weights_summary.passenger_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_mass_with_bags': {'default_value': 200, 'desc': 'total mass of one passenger and their bags', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWPAX', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_payload_mass': {'default_value': 0.0, 'desc': 'mass of passenger payload, including passengers, passenger baggage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WPL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass': {'default_value': None, 'desc': 'mass of passenger service equipment', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._passenger_service_weight', 'aircraft.outputs.L0_weights_summary.passenger_service_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:passenger_service_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for mass of passenger service equipment', 'historical_name': {'FLOPS': 'WTIN.WSRV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.passenger_service_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:crew_and_payload:total_payload_mass': {'default_value': 0.0, 'desc': 'total mass of payload, including passengers, passenger baggage, and cargo', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:crew_and_payload:wing_cargo': {'default_value': 0.0, 'desc': 'cargo carried in wing', 'historical_name': {'FLOPS': 'WTIN.CARGOW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_crew_and_payload.wing_cargo'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:base_area': {'default_value': 0.0, 'desc': 'Aircraft base area (total exit cross-section area minus inlet capture areas for internally mounted engines)', 'historical_name': {'FLOPS': 'AERIN.SBASE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.base_area', 'aircraft.outputs.L0_aerodynamics.mission_base_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:cg_delta': {'default_value': 0.0, 'desc': 'allowable center-of-gravity (cg) travel as a fraction of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:characteristic_lengths': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for each component', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:design:cockpit_control_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of cockpit controls', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKCC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:compute_htail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARHX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:compute_vtail_volume_coeff': {'default_value': False, 'desc': 'if true, use empirical tail volume coefficient equation. This is true if VBARVX is 0 in GASP.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:drag_increment': {'default_value': 0.0, 'desc': 'increment to the profile drag coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:drag_polar': {'default_value': 0.0, 'desc': 'Drag polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:empty_mass': {'default_value': 0.0, 'desc': 'fixed operating empty mass', 'historical_name': {'FLOPS': 'MISSIN.DOWE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_mission.fixed_operating_weight_empty'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin': {'default_value': None, 'desc': 'empty mass margin', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._weight_empty_margin'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:empty_mass_margin_scaler': {'default_value': 0.0, 'desc': 'empty mass margin scalar', 'historical_name': {'FLOPS': 'WTIN.EWMARG', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.weight_empty_margin'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:equipment_mass_coefficients': {'default_value': [0.0, 0.0862, 0.1, 0.16, 0.0, 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 0.7, 6.0], 'desc': 'mass trend coefficients of fixed equipment and useful load', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:external_subsystems_mass': {'default_value': 0.0, 'desc': 'total mass of all user-defined external subsystems', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fineness': {'default_value': 0.0, 'desc': 'table of component fineness ratios', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:fixed_equipment_mass': {'default_value': 0.0, 'desc': 'total mass of fixed equipment: APU, Instruments, Hydraulics, Electrical, Avionics, AC, Anti-Icing, Auxilary Equipment, and Furnishings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:fixed_useful_load': {'default_value': 0.0, 'desc': 'total mass of fixed useful load: crew, service items, trapped oil, etc', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFUL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ijeff': {'default_value': 0.0, 'desc': "A flag used by Jeff V. Bowles to debug GASP code during his 53 years supporting the development of GASP.         This flag is planted here to thank him for his hard work and dedication, Aviary wouldn't be what it is today         without his help.", 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ijeff', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_lower': {'default_value': None, 'desc': 'table of percent laminar flow over lower component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_lower_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:laminar_flow_upper': {'default_value': None, 'desc': 'table of percent laminar flow over upper component surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.mission_component_percent_laminar_flow_upper_surface_table'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:landing_to_takeoff_mass_ratio': {'default_value': None, 'desc': 'ratio of maximum landing mass to maximum takeoff mass', 'historical_name': {'FLOPS': 'AERIN.WRATIO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.landing_to_takeoff_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_curve_slope': {'default_value': 0.0, 'desc': 'lift curve slope at cruise mach number', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLALPH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': '1/rad'}, 'aircraft:design:lift_dependent_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for lift-dependent drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDI', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.induced_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:lift_polar': {'default_value': 0.0, 'desc': 'Lift polar computed during Aviary pre-mission.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:max_fuselage_pitch_angle': {'default_value': 15, 'desc': 'maximum fuselage pitch allowed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.THEMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:design:max_structural_speed': {'default_value': 0, 'desc': 'maximum structural design flight speed in miles per hour', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VMLFSL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'mi/h'}, 'aircraft:design:operating_mass': {'default_value': 0.0, 'desc': 'operating mass empty of the aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.OWE', 'LEAPS1': ['(WeightABC)self._operating_weight_empty', 'aircraft.outputs.L0_weights_summary.operating_weight_empty']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:part25_structural_category': {'default_value': 3, 'desc': 'part 25 structural category', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:design:reserves': {'default_value': 0, 'desc': 'required fuel reserves: given either as a proportion of mission fuel(<0) or directly in lbf (>10)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FRESF', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:design:smooth_mass_discontinuities': {'default_value': False, 'desc': 'eliminates discontinuities in GASP-based mass estimation code if true', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:static_margin': {'default_value': 0.0, 'desc': 'aircraft static margin as a fraction of mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STATIC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:structural_mass_increment': {'default_value': 0, 'desc': 'structural mass increment that is added (or removed) after the structural mass is calculated', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELWST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:structure_mass': {'default_value': 0.0, 'desc': 'Total structural group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_structural_weight', 'aircraft.outputs.L0_weights_summary.total_structural_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:subsonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for subsonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUB', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sub_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supercritical_drag_shift': {'default_value': 0.0, 'desc': 'shift in drag divergence Mach number due to supercritical design', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SCFAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:supersonic_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for supersonic drag', 'historical_name': {'FLOPS': 'MISSIN.FCDSUP', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.sup_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:systems_equip_mass': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._equipment_group_weight', 'aircraft.outputs.L0_weights_summary.equipment_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:systems_equip_mass_base': {'default_value': 0.0, 'desc': 'Total systems & equipment group mass without additional 1% of empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:thrust_to_weight_ratio': {'default_value': 0.0, 'desc': 'required thrust-to-weight ratio of aircraft', 'historical_name': {'FLOPS': 'CONFIN.TWR', 'GASP': None, 'LEAPS1': 'ipropulsion.req_thrust_weight_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:design:total_wetted_area': {'default_value': 0.0, 'desc': 'total aircraft wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '~WeightABC._update_cycle.total_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:touchdown_mass': {'default_value': None, 'desc': 'design landing mass', 'historical_name': {'FLOPS': 'WTIN.WLDG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.design_landing_weight', 'aircraft.outputs.L0_landing_gear.design_landing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:ulf_calculated_from_maneuver': {'default_value': False, 'desc': 'if true, ULF (ultimate load factor) is forced to be calculated from the maneuver load factor, even if the gust load factor is larger. This was set to true with a negative CATD in GASP.', 'historical_name': {'FLOPS': None, 'GASP': 'CATD', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:use_alt_mass': {'default_value': False, 'desc': 'control whether the alternate mass equations are to be used or not', 'historical_name': {'FLOPS': 'WTIN.IALTWT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.use_alt_weights'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:design:wetted_areas': {'default_value': 0.0, 'desc': 'table of component wetted areas', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:design:zero_fuel_mass': {'default_value': 0.0, 'desc': 'zero fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._zero_fuel_weight', 'aircraft.outputs.L0_weights.zero_fuel_weight', 'aircraft.outputs.L0_weights_summary.zero_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:design:zero_lift_drag_coeff_factor': {'default_value': 1.0, 'desc': 'Scaling factor for zero-lift drag coefficient', 'historical_name': {'FLOPS': 'MISSIN.FCDO', 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.geom_drag_coeff_fact'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:electrical:has_hybrid_system': {'default_value': True, 'desc': 'if true there is an augmented electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:electrical:hybrid_cable_length': {'default_value': 0.0, 'desc': 'length of cable for hybrid electric augmented system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.LCABLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:electrical:mass': {'default_value': None, 'desc': 'mass of the electrical system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._electrical_group_weight', 'aircraft.outputs.L0_weights_summary.electrical_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:electrical:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for the electrical system', 'historical_name': {'FLOPS': 'WTIN.WELEC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.electrical_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:additional_mass': {'default_value': 0.0, 'desc': 'additional propulsion system mass added to engine control and starter mass, or engine installation mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:additional_mass_fraction': {'default_value': 0.0, 'desc': 'fraction of (scaled) engine mass used to calculate additional propulsion system mass added to engine control and starter mass, or used to calculate engine installation mass', 'historical_name': {'FLOPS': 'WTIN.WPMISC', 'GASP': 'INGASP.SKPEI', 'LEAPS1': 'aircraft.inputs.L0_propulsion.misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:constant_fuel_consumption': {'default_value': 0.0, 'desc': 'Additional constant fuel flow. This value is not scaled with the engine', 'historical_name': {'FLOPS': 'MISSIN.FLEAK', 'GASP': None, 'LEAPS1': ['iengine.fuel_leak', 'aircraft.inputs.L0_engine.fuel_leak']}, 'option': True, 'types': None, 'units': 'lbm/h'}, 'aircraft:engine:controls_mass': {'default_value': 0.0, 'desc': 'estimated mass of the engine controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_ctrl_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:data_file': {'default_value': None, 'desc': 'filepath to data file containing engine performance tables', 'historical_name': {'FLOPS': 'ENGDIN.EIFILE', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': (<class 'str'>, <class 'pathlib.Path'>, None), 'units': 'unitless'}, 'aircraft:engine:flight_idle_max_fraction': {'default_value': 1.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be below a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMAX', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_max_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_min_fraction': {'default_value': 0.08, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, bounds engine performance outputs (other than thrust) at flight idle to be above a decimal fraction of the max value of that output produced by the engine at each flight condition.', 'historical_name': {'FLOPS': 'ENGDIN.FIDMIN', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.idle_min_fract'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:flight_idle_thrust_fraction': {'default_value': 0.0, 'desc': 'If Aircraft.Engine.GENERATE_FLIGHT_IDLE is True, defines idle thrust condition as a decimal fraction of max thrust produced by the engine at each flight condition.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_constant_term': {'default_value': 0.0, 'desc': 'Constant term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.DFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_const_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:fuel_flow_scaler_linear_term': {'default_value': 0.0, 'desc': 'Linear term in fuel flow scaling equation', 'historical_name': {'FLOPS': 'ENGDIN.FFFAC', 'GASP': None, 'LEAPS1': 'ifuel_flow.scaling_linear_term'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:generate_flight_idle': {'default_value': False, 'desc': 'If True, generate flight idle data by extrapolating from engine deck. Flight idle is defined as engine performance when thrust is reduced to the level defined by Aircraft.Engine.FLIGHT_IDLE_THRUST_FRACTION. Engine outputs are extrapolated to this thrust level, bounded by Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT and Aircraft.Engine.FLIGHT_IDLE_MIN_FRACT', 'historical_name': {'FLOPS': 'ENGDIN.IDLE', 'GASP': None, 'LEAPS1': 'engine_model.imodel_info.flight_idle_index'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:geopotential_alt': {'default_value': False, 'desc': 'If True, engine deck altitudes are geopotential and will be converted to geometric altitudes. If False, engine deck altitudes are geometric.', 'historical_name': {'FLOPS': 'ENGDIN.IGEO', 'GASP': None, 'LEAPS1': 'imodel_info.geopotential_alt'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:has_propellers': {'default_value': False, 'desc': 'if True, the aircraft has propellers, otherwise aircraft is assumed to have no propellers. In GASP this depended on NTYE', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:ignore_negative_thrust': {'default_value': False, 'desc': 'If False, all input or generated points are used, otherwise points in the engine deck with negative net thrust are ignored.', 'historical_name': {'FLOPS': 'ENGDIN.NONEG', 'GASP': None, 'LEAPS1': 'imodel_info.ignore_negative_thrust'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:interpolation_method': {'default_value': 'slinear', 'desc': "method used for interpolation on an engine deck's data file, allowable values are table methods from openmdao.components.interp_util.interp", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'str'>, 'units': 'unitless'}, 'aircraft:engine:mass': {'default_value': 0.0, 'desc': 'scaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_weights_summary.Engine.WEIGHT'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:mass_scaler': {'default_value': 0.0, 'desc': 'scaler for engine mass', 'historical_name': {'FLOPS': 'WTIN.EEXP', 'GASP': 'INGASP.CK5', 'LEAPS1': 'aircraft.inputs.L0_propulsion.engine_weight_scale'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:mass_specific': {'default_value': 0.0, 'desc': 'specific mass of one engine (engine weight/SLS thrust)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWSLS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/lbf'}, 'aircraft:engine:num_engines': {'default_value': 2, 'desc': 'total number of engines per model on the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ENP', 'LEAPS1': 'aircraft.outputs.L0_propulsion.total_engine_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_fuselage_engines': {'default_value': 0, 'desc': 'number of fuselage mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:num_wing_engines': {'default_value': 0, 'desc': 'number of wing mounted engines per model', 'historical_name': {'FLOPS': 'WTIN.NEW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.engines_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:engine:pod_mass': {'default_value': 0.0, 'desc': 'engine pod mass including nacelles', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._engine_pod_weight_list'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:pod_mass_scaler': {'default_value': 1.0, 'desc': 'technology factor on mass of engine pods', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK14', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:position_factor': {'default_value': 0, 'desc': 'engine position factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKEPOS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:pylon_factor': {'default_value': 0.7, 'desc': 'factor for turbofan engine pylon mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FPYL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:reference_diameter': {'default_value': 0.0, 'desc': 'engine reference diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DIAM_REF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:engine:reference_mass': {'default_value': None, 'desc': 'unscaled mass of a single engine or bare engine if inlet and nozzle mass are supplied', 'historical_name': {'FLOPS': 'WTIN.WENG', 'GASP': None, 'LEAPS1': '(WeightABC)self._Engine.WEIGHT'}, 'option': True, 'types': None, 'units': 'lbm'}, 'aircraft:engine:reference_sls_thrust': {'default_value': None, 'desc': 'maximum thrust of an engine provided in engine model files', 'historical_name': {'FLOPS': 'WTIN.THRSO', 'GASP': 'INGASP.FN_REF', 'LEAPS1': 'aircraft.inputs.L0_engine*.thrust'}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:engine:scale_factor': {'default_value': 1.0, 'desc': 'Thrust-based scaling factor used to scale engine performance data during mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:scale_mass': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(types)EngineScaleModes.WEIGHT'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scale_performance': {'default_value': True, 'desc': 'Toggle for enabling scaling of engine performance including thrust, fuel flow, and electric power', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['iengine.scale_mode', '(types)EngineScaleModes.DEFAULT']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:engine:scaled_sls_thrust': {'default_value': 0.0, 'desc': 'maximum thrust of an engine after scaling', 'historical_name': {'FLOPS': 'CONFIN.THRUST', 'GASP': 'INGASP.THIN', 'LEAPS1': ['aircraft.outputs.L0_propulsion.max_rated_thrust', 'aircraft.cached.L0_propulsion.max_rated_thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:engine:starter_mass': {'default_value': 0.0, 'desc': 'starter mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._starter_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:subsonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is subsonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUB', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.subsonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:supersonic_fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scaling factor on fuel flow when Mach number is supersonic', 'historical_name': {'FLOPS': 'ENGDIN.FFFSUP', 'GASP': None, 'LEAPS1': 'aircraft.L0_fuel_flow.supersonic_factor'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:engine:thrust_reversers_mass': {'default_value': 0.0, 'desc': 'mass of thrust reversers on engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._thrust_reversers_weight', 'aircraft.outputs.L0_weights_summary.thrust_reversers_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:engine:thrust_reversers_mass_scaler': {'default_value': 0.0, 'desc': 'scaler for mass of thrust reversers on engines', 'historical_name': {'FLOPS': 'WTIN.WTHR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.thrust_reversers_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:engine:type': {'default_value': GASPEngineType.TURBOJET, 'desc': 'specifies engine type used for engine mass calculation', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.NTYE', 'LEAPS1': None}, 'option': True, 'types': <enum 'GASPEngineType'>, 'units': 'unitless'}, 'aircraft:engine:wing_locations': {'default_value': 0.0, 'desc': 'Engine wing mount locations as fractions of semispan; (engines_count)/2 values are input', 'historical_name': {'FLOPS': 'WTIN.ETAE', 'GASP': 'INGASP.YP', 'LEAPS1': 'aircraft.inputs.L0_propulsion.wing_engine_locations'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:area': {'default_value': 0.0, 'desc': 'vertical fin theoretical area', 'historical_name': {'FLOPS': 'WTIN.SFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fins:mass': {'default_value': None, 'desc': 'mass of vertical fins', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._wing_vertical_fin_weight', 'aircraft.outputs.L0_weights_summary.wing_vertical_fin_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fins:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler for fin structure', 'historical_name': {'FLOPS': 'WTIN.FRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_vertical_fin_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fins:num_fins': {'default_value': 0, 'desc': 'number of fins', 'historical_name': {'FLOPS': 'WTIN.NFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.fin_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fins:taper_ratio': {'default_value': None, 'desc': 'vertical fin theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRFIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fins.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:auxiliary_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULAUX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.aux_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:burn_per_passenger_mile': {'default_value': 0.0, 'desc': 'average fuel burn per passenger per mile flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/NM'}, 'aircraft:fuel:capacity_factor': {'default_value': 23.0, 'desc': 'fuel capacity factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._wing_fuel_capacity_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:density': {'default_value': 6.687, 'desc': 'fuel density', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FUELD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/galUS'}, 'aircraft:fuel:density_ratio': {'default_value': 1.0, 'desc': 'Fuel density ratio for alternate fuels compared to jet fuel (typical density of 6.7 lbm/gal), used in the calculation of wing_capacity (if wing_capacity is not input) and in the calculation of fuel system weight.', 'historical_name': {'FLOPS': 'WTIN.FULDEN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.density_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_margin': {'default_value': 0.0, 'desc': 'excess fuel volume required, essentially the amount of fuel above the design point that there has to be volume to carry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOL_MRG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass': {'default_value': None, 'desc': 'fuel system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuel_sys_weight', 'aircraft.outputs.L0_weights_summary.fuel_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:fuel_system_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of fuel system', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuel_system_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for fuel system mass', 'historical_name': {'FLOPS': 'WTIN.WFSYS', 'GASP': 'INGASP.CK21', 'LEAPS1': 'aircraft.inputs.L0_overrides.fuel_sys_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:fuselage_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the fuselage', 'historical_name': {'FLOPS': 'WTIN.FULFMX', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.fuselage_capacity', '(WeightABC)self._fuselage_fuel_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:num_tanks': {'default_value': 7, 'desc': 'number of fuel tanks', 'historical_name': {'FLOPS': 'WTIN.NTANK', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.tank_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuel:total_capacity': {'default_value': None, 'desc': 'Total fuel capacity of the aircraft including wing, fuselage and auxiliary tanks. Used in generating payload-range diagram (Default = wing_capacity + fuselage_capacity + aux_capacity)', 'historical_name': {'FLOPS': 'WTIN.FMXTOT', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuel.total_capacity', 'aircraft.cached.L0_fuel.total_capacity']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:total_volume': {'default_value': 0.0, 'desc': 'Total fuel volume', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_fuel_vol', '~WeightABC.calc_unusable_fuel.total_fuel_vol', '~WeightABC._pre_unusable_fuel.total_fuel_vol', '~BasicTransportWeight._pre_unusable_fuel.total_fuel_vol']}, 'option': False, 'types': None, 'units': 'galUS'}, 'aircraft:fuel:unusable_fuel_mass': {'default_value': None, 'desc': 'unusable fuel mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._unusable_fuel_weight', 'aircraft.outputs.L0_weights_summary.unusable_fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:unusable_fuel_mass_scaler': {'default_value': 1.0, 'desc': 'scaler for Unusable fuel mass', 'historical_name': {'FLOPS': 'WTIN.WUF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.unusable_fuel_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_fuel_capacity': {'default_value': None, 'desc': 'fuel capacity of the auxiliary tank', 'historical_name': {'FLOPS': 'WTIN.FULWMX', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_fuel_fraction': {'default_value': 0.0, 'desc': 'fraction of total theoretical wing volume used for wing fuel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity': {'default_value': 0.0, 'desc': 'reference fuel volume', 'historical_name': {'FLOPS': 'WTIN.FUELRF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuel:wing_ref_capacity_area': {'default_value': 0.0, 'desc': 'reference wing area for fuel capacity', 'historical_name': {'FLOPS': 'WTIN.FSWREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_A': {'default_value': 0.0, 'desc': 'scaling factor A', 'historical_name': {'FLOPS': 'WTIN.FUSCLA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_1_5_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_ref_capacity_term_B': {'default_value': 0.0, 'desc': 'scaling factor B', 'historical_name': {'FLOPS': 'WTIN.FUSCLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuel.wing_ref_capacity_linear_term'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuel:wing_volume_design': {'default_value': 0.0, 'desc': 'wing tank fuel volume when carrying design fuel plus fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_DES', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_geometric_max': {'default_value': 0.0, 'desc': 'wing tank fuel volume based on geometry', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_GEOM', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:fuel:wing_volume_structural_max': {'default_value': 0.0, 'desc': 'wing tank volume based on maximum wing fuel weight', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FVOLW_MAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**3'}, 'aircraft:furnishings:mass': {'default_value': None, 'desc': 'Total furnishings system mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._furnishings_group_weight', 'aircraft.outputs.L0_weights_summary.furnishings_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_base': {'default_value': 0.0, 'desc': 'Base furnishings system mass without additional 1% empty mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:furnishings:mass_scaler': {'default_value': 1.0, 'desc': 'Furnishings system mass scaler', 'historical_name': {'FLOPS': 'WTIN.WFURN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.furnishings_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:aisle_width': {'default_value': 24, 'desc': 'width of the aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WAS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:avg_diameter': {'default_value': 0.0, 'desc': 'average fuselage diameter', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WC', 'INGASP.SWF'], 'LEAPS1': 'aircraft.outputs.L0_fuselage.avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the fuselage', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[3]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:cross_section': {'default_value': 0.0, 'desc': 'fuselage cross sectional area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_cross_sect_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:delta_diameter': {'default_value': 4.5, 'desc': 'mean fuselage cabin diameter minus mean fuselage nose diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HCK', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:diameter_to_wing_span': {'default_value': 0.0, 'desc': 'fuselage diameter to wing span ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_diam_to_wing_span_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:fineness': {'default_value': 0.0, 'desc': 'fuselage fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[3]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[3]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:flat_plate_area_increment': {'default_value': 0.0, 'desc': 'increment to fuselage flat plate area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELFE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:form_factor': {'default_value': 0.0, 'desc': 'fuselage form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for fuselage upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUB', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:length': {'default_value': 0.0, 'desc': 'Define the Fuselage total length. If total_length is not input for a passenger transport, LEAPS will calculate the fuselage length, width and depth and the length of the passenger compartment.', 'historical_name': {'FLOPS': 'WTIN.XL', 'GASP': 'INGASP.ELF', 'LEAPS1': ['aircraft.inputs.L0_fuselage.total_length', 'aircraft.outputs.L0_fuselage.total_length', 'aircraft.cached.L0_fuselage.total_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:length_to_diameter': {'default_value': 0.0, 'desc': 'fuselage length to diameter ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_fuselage.mission_len_to_diam_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass': {'default_value': None, 'desc': 'mass of the fuselage structure', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._fuselage_weight', 'aircraft.outputs.L0_weights_summary.fuselage_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:fuselage:mass_coefficient': {'default_value': 136, 'desc': 'mass trend coefficient of fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the fuselage structure', 'historical_name': {'FLOPS': 'WTIN.FRFU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.fuselage_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:max_height': {'default_value': 0.0, 'desc': 'maximum fuselage height', 'historical_name': {'FLOPS': 'WTIN.DF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_fuselage.max_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:max_width': {'default_value': 0.0, 'desc': 'maximum fuselage width', 'historical_name': {'FLOPS': 'WTIN.WF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.max_width', 'aircraft.outputs.L0_fuselage.max_width', 'aircraft.cached.L0_fuselage.max_width']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:military_cargo_floor': {'default_value': False, 'desc': 'indicate whether or not there is a military cargo aircraft floor', 'historical_name': {'FLOPS': 'WTIN.CARGF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_crew_and_payload.military_cargo', 'aircraft.cached.L0_crew_and_payload.military_cargo']}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:nose_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of nose cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:num_aisles': {'default_value': 1, 'desc': 'number of aisles in the passenger cabin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.AS', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_fuselages': {'default_value': 1, 'desc': 'number of fuselages', 'historical_name': {'FLOPS': 'WTIN.NFUSE', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.count', 'aircraft.cached.L0_fuselage.count']}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:num_seats_abreast': {'default_value': 6, 'desc': 'seats abreast in fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SAB', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:fuselage:passenger_compartment_length': {'default_value': 0.0, 'desc': 'length of passenger compartment', 'historical_name': {'FLOPS': 'WTIN.XLP', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_fuselage.passenger_compartment_length', 'aircraft.cached.L0_fuselage.passenger_compartment_length']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:pilot_compartment_length': {'default_value': 0.0, 'desc': 'length of the pilot compartment', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELPC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:fuselage:planform_area': {'default_value': 0.0, 'desc': 'fuselage planform area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._fuselage_planform_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:pressure_differential': {'default_value': 7.5, 'desc': 'fuselage pressure differential during cruise', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'psi'}, 'aircraft:fuselage:provide_surface_area': {'default_value': True, 'desc': 'if true the fuselage surface area is set to be fus_SA_factor, otherwise it is calculated.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:fuselage:seat_pitch': {'default_value': 29, 'desc': 'pitch of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.PS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:seat_width': {'default_value': 20, 'desc': 'width of the economy class seats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WS', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'inch'}, 'aircraft:fuselage:tail_fineness': {'default_value': 1, 'desc': 'length to diameter ratio of tail cone', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELODT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area': {'default_value': None, 'desc': 'fuselage wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.fuselage_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[3]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[3]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:fuselage:wetted_area_factor': {'default_value': 1, 'desc': 'fuselage wetted area adjustment factor, if this is >10, it is interpreted as the wetted area in ft**2', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SF_FAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:fuselage:wetted_area_scaler': {'default_value': 1.0, 'desc': 'fuselage wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.fuselage_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:area': {'default_value': 0.0, 'desc': 'horizontal tail theoretical area; overridden by vol_coeff, if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SHT', 'GASP': 'INGASP.SHT', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.area', 'aircraft.cached.L0_horizontal_tail.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:aspect_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARHT', 'GASP': 'INGASP.ARHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[1]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:fineness': {'default_value': 0.0, 'desc': 'horizontal tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[1]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[1]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:form_factor': {'default_value': 0.0, 'desc': 'horizontal tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for horizontal tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass': {'default_value': None, 'desc': 'mass of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._horizontal_tail_weight', 'aircraft.outputs.L0_weights_summary.horizontal_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:horizontal_tail:mass_coefficient': {'default_value': 0.18, 'desc': 'mass trend coefficient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the horizontal tail structure', 'historical_name': {'FLOPS': 'WTIN.FRHT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.horizontal_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:moment_ratio': {'default_value': 0.0, 'desc': 'Ratio of wing chord to horizontal tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.COELTH', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:root_chord': {'default_value': 0.0, 'desc': 'horizontal tail root chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:span': {'default_value': 0.0, 'desc': 'span of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BHT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:horizontal_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of horizontal tail', 'historical_name': {'FLOPS': 'WTIN.SWPHT', 'GASP': 'INGASP.DWPQCH', 'LEAPS1': ['aircraft.inputs.L0_horizontal_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_horizontal_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:horizontal_tail:taper_ratio': {'default_value': None, 'desc': 'horizontal tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRHT', 'GASP': 'INGASP.SLMH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'horizontal tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCHT', 'GASP': 'INGASP.TCHT', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:vertical_tail_fraction': {'default_value': None, 'desc': 'Define the decimal fraction of vertical tail span where horizontal tail is mounted. Defaults: 0.0 == for body mounted (default for transport with all engines on wing); 1.0 == for T tail (default for transport with multiple engines on fuselage)', 'historical_name': {'FLOPS': 'WTIN.HHT', 'GASP': 'INGASP.SAH', 'LEAPS1': 'aircraft.inputs.L0_horizontal_tail.vertical_tail_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficicient of horizontal tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARHX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:horizontal_tail:wetted_area': {'default_value': None, 'desc': 'horizontal tail wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.horizontal_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[1]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[1]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:horizontal_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'horizontal tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETH', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.horizontal_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:mass': {'default_value': None, 'desc': 'mass of hydraulic system', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._hydraulics_group_weight', 'aircraft.outputs.L0_weights_summary.hydraulics_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:hydraulics:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the hydraulic system', 'historical_name': {'FLOPS': 'WTIN.WHYD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.hydraulics_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:hydraulics:system_pressure': {'default_value': 3000.0, 'desc': 'hydraulic system pressure', 'historical_name': {'FLOPS': 'WTIN.HYDPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.hydraulic_sys_press'}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:instruments:mass': {'default_value': None, 'desc': 'instrument group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._instrument_group_weight', 'aircraft.outputs.L0_weights_summary.instrument_group_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:instruments:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the instrument group', 'historical_name': {'FLOPS': 'WTIN.WIN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.instrument_group_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:carrier_based': {'default_value': False, 'desc': 'carrier based aircraft switch, affects mass of flight crew, avionics, and nose gear where true is carrier based and false is land based', 'historical_name': {'FLOPS': 'WTIN.CARBAS', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_landing_gear.carrier_based'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:drag_coefficient': {'default_value': 0.0, 'desc': 'landing gear drag coefficient', 'historical_name': {'FLOPS': 'TOLIN.CDGEAR', 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:fixed_gear': {'default_value': True, 'desc': 'Type of landing gear. In GASP, 0 is retractable and 1 is deployed (fixed). Here,           false is retractable and true is deployed (fixed).', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.IGEAR', 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_location': {'default_value': 0, 'desc': 'span fraction of main gear on wing (0=on fuselage, 1=at tip)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass': {'default_value': 0.0, 'desc': 'mass of main landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:main_gear_mass_coefficient': {'default_value': 0.85, 'desc': 'mass trend coefficient of main gear, fraction of total landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKMG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_mass_scaler': {'default_value': 0.0, 'desc': 'mass scaler of the main landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGM', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_main_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:main_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended main landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XMLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_main_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_main_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_mass': {'default_value': None, 'desc': 'mass of nose landing gear', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(WeightABC)self._landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:nose_gear_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nose landing gear structure', 'historical_name': {'FLOPS': 'WTIN.FRLGN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.landing_gear_nose_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:nose_gear_oleo_length': {'default_value': 0.0, 'desc': 'length of extended nose landing gear oleo', 'historical_name': {'FLOPS': 'WTIN.XNLG', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.outputs.L0_landing_gear.extend_nose_gear_oleo_len', 'aircraft.cached.L0_landing_gear.extend_nose_gear_oleo_len']}, 'option': False, 'types': None, 'units': 'inch'}, 'aircraft:landing_gear:tail_hook_mass_scaler': {'default_value': 1, 'desc': 'factor on tail mass for arresting hook', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKTL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:landing_gear:total_mass': {'default_value': 0, 'desc': 'total mass of landing gear', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WLG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:landing_gear:total_mass_scaler': {'default_value': 1, 'desc': 'technology factor on landing gear mass', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CK12', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:avg_diameter': {'default_value': 0.0, 'desc': 'Average diameter of engine nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.DNAC', 'GASP': 'INGASP.DBARN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_diam'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:avg_length': {'default_value': 0.0, 'desc': 'Average length of nacelles for each engine model', 'historical_name': {'FLOPS': 'WTIN.XNAC', 'GASP': 'INGASP.ELN', 'LEAPS1': 'aircraft.inputs.L0_engine.nacelle_avg_length'}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[4]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:nacelle:clearance_ratio': {'default_value': 0.2, 'desc': 'the minimum number of nacelle diameters above the ground that the bottom of the nacelle must be', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEARqDN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:core_diameter_ratio': {'default_value': 1.25, 'desc': 'ratio of nacelle diameter to engine core diameter', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DNQDE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:fineness': {'default_value': 0.0, 'desc': 'nacelle fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLQDE', 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[4]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[4]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:form_factor': {'default_value': 0.0, 'desc': 'nacelle form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle lower surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRLN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for nacelle upper surface for each engine model', 'historical_name': {'FLOPS': 'AERIN.TRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass': {'default_value': None, 'desc': 'estimated mass of the nacelles for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._nacelle_weight', 'aircraft.outputs.L0_weights_summary.nacelle_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:nacelle:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the nacelle structure for each engine model', 'historical_name': {'FLOPS': 'WTIN.FRNA', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.nacelle_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:nacelle:mass_specific': {'default_value': 0.0, 'desc': 'nacelle mass/nacelle surface area; lbm per sq ft.', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.UWNAC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:nacelle:surface_area': {'default_value': 0.0, 'desc': 'surface area of the outside of one entire nacelle, not just the wetted area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:total_wetted_area': {'default_value': 0.0, 'desc': 'total nacelles wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area': {'default_value': 0.0, 'desc': 'wetted area of a single nacelle for each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[4]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[4]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:nacelle:wetted_area_scaler': {'default_value': 1.0, 'desc': 'nacelle wetted area scaler for each engine model', 'historical_name': {'FLOPS': 'AERIN.SWETN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.nacelle_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:paint:mass': {'default_value': 0.0, 'desc': 'mass of paint for all wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_paint_weight', 'aircraft.outputs.L0_weights_summary.total_paint_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:paint:mass_per_unit_area': {'default_value': 0.0, 'desc': 'mass of paint per unit area for all wetted area', 'historical_name': {'FLOPS': 'WTIN.WPAINT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_weights.paint_per_unit_area'}, 'option': False, 'types': None, 'units': 'lbm/ft**2'}, 'aircraft:propulsion:engine_oil_mass_scaler': {'default_value': 1.0, 'desc': 'Scaler for engine oil mass', 'historical_name': {'FLOPS': 'WTIN.WOIL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.engine_oil_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:mass': {'default_value': 0.0, 'desc': 'Total propulsion group mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._prop_sys_weight', 'aircraft.outputs.L0_weights_summary.prop_sys_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:misc_mass_scaler': {'default_value': 1.0, 'desc': 'scaler applied to miscellaneous engine mass (sum of engine control, starter, and additional mass)', 'historical_name': {'FLOPS': 'WTIN.WPMSC', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_overrides.misc_propulsion_weight']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:propulsion:total_engine_controls_mass': {'default_value': 0.0, 'desc': 'total estimated mass of the engine controls for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_mass': {'default_value': 0.0, 'desc': 'total mass of all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WEP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_oil_mass': {'default_value': None, 'desc': 'engine oil mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._engine_oil_weight', 'aircraft.outputs.L0_weights_summary.engine_oil_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_engine_pod_mass': {'default_value': 0.0, 'desc': 'total engine pod mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_misc_mass': {'default_value': None, 'desc': 'sum of engine control, starter, and additional mass for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_num_engines': {'default_value': None, 'desc': 'total number of engines for the aircraft (fuselage, wing, or otherwise)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_fuselage_engines': {'default_value': None, 'desc': 'total number of fuselage-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_num_wing_engines': {'default_value': None, 'desc': 'total number of wing-mounted engines for the aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:propulsion:total_reference_sls_thrust': {'default_value': None, 'desc': 'total maximum thrust of all unscalsed engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_scaled_sls_thrust': {'default_value': 0.0, 'desc': 'total maximum thrust of all scaled engines on aircraft, sea-level static', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'aircraft:propulsion:total_starter_mass': {'default_value': 0.0, 'desc': 'total mass of starters for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:propulsion:total_thrust_reversers_mass': {'default_value': None, 'desc': 'total mass of thrust reversers for all engines on aircraft', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:area': {'default_value': 0, 'desc': 'strut area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTWS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:strut:area_ratio': {'default_value': 0.0, 'desc': 'ratio of strut area to wing area', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SSTQSW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:attachment_location': {'default_value': 0.0, 'desc': 'attachment location of strut the full attachment-to-attachment span', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.STRUT', 'INGASP.STRUTX', 'INGASP.XSTRUT'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:attachment_location_dimensionless': {'default_value': 0.0, 'desc': 'attachment location of strut as fraction of the half-span', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:chord': {'default_value': 0.0, 'desc': 'chord of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTCHD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:dimensional_location_specified': {'default_value': True, 'desc': 'if true the location of the strut is given dimensionally, otherwise it is given non-dimensionally. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:strut:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'strut/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:length': {'default_value': 0, 'desc': 'length of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.STRTLNG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:strut:mass': {'default_value': 0, 'desc': 'mass of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:strut:mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKSTRUT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:strut:thickness_to_chord': {'default_value': 0, 'desc': 'thickness to chord ratio of the strut', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCSTRT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:tail_boom:length': {'default_value': 0.0, 'desc': 'cabin length for the tail boom fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELFFC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:area': {'default_value': 0.0, 'desc': 'vertical tail theoretical area (per tail); overridden by vol_coeff if vol_coeff > 0.0', 'historical_name': {'FLOPS': 'WTIN.SVT', 'GASP': 'INGASP.SVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.area', 'aircraft.cached.L0_vertical_tails.area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:aspect_ratio': {'default_value': None, 'desc': 'vertical tail theoretical aspect ratio', 'historical_name': {'FLOPS': 'WTIN.ARVT', 'GASP': 'INGASP.ARVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.aspect_ratio', 'aircraft.cached.L0_vertical_tails.aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[2]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:fineness': {'default_value': 0.0, 'desc': 'vertical tail fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[2]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[2]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:form_factor': {'default_value': 0.0, 'desc': 'vertical tail form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for vertical tail upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass': {'default_value': None, 'desc': 'mass of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._vertical_tail_weight', 'aircraft.outputs.L0_weights_summary.vertical_tail_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:vertical_tail:mass_coefficient': {'default_value': 0.22, 'desc': 'mass trend coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKZ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the vertical tail structure', 'historical_name': {'FLOPS': 'WTIN.FRVT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.vertical_tail_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:moment_arm': {'default_value': 0.0, 'desc': 'moment arm of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:moment_ratio': {'default_value': 0.0, 'desc': 'ratio of wing span to vertical tail moment arm', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BOELTV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:num_tails': {'default_value': 1, 'desc': 'number of vertical tails', 'historical_name': {'FLOPS': 'WTIN.NVERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:vertical_tail:root_chord': {'default_value': 0.0, 'desc': 'root chord of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:span': {'default_value': 0.0, 'desc': 'span of vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BVT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:vertical_tail:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep of vertical tail', 'historical_name': {'FLOPS': 'WTIN.SWPVT', 'GASP': 'INGASP.DWPQCV', 'LEAPS1': ['aircraft.inputs.L0_vertical_tail.sweep_at_quarter_chord', 'aircraft.cached.L0_vertical_tail.sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:vertical_tail:taper_ratio': {'default_value': None, 'desc': 'vertical tail theoretical taper ratio', 'historical_name': {'FLOPS': 'WTIN.TRVT', 'GASP': 'INGASP.SLMV', 'LEAPS1': 'aircraft.inputs.L0_vertical_tails.taper_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:thickness_to_chord': {'default_value': 0.0, 'desc': 'vertical tail thickness-chord ratio', 'historical_name': {'FLOPS': 'WTIN.TCVT', 'GASP': 'INGASP.TCVT', 'LEAPS1': ['aircraft.inputs.L0_vertical_tails.thickness_to_chord_ratio', 'aircraft.cached.L0_vertical_tails.thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:volume_coefficient': {'default_value': 0.0, 'desc': 'tail volume coefficient of the vertical tail', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VBARVX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:vertical_tail:wetted_area': {'default_value': None, 'desc': 'vertical tails wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.vertical_tail_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[2]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[2]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:vertical_tail:wetted_area_scaler': {'default_value': 1.0, 'desc': 'vertical tail wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.vertical_tail_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aeroelastic_tailoring_factor': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of aeroelastic tailoring used in design of wing where: 0.0 == no aeroelastic tailoring; 1.0 == maximum aeroelastic tailoring.', 'historical_name': {'FLOPS': 'WTIN.FAERT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.aeroelastic_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:airfoil_technology': {'default_value': 1.0, 'desc': 'Airfoil technology parameter. Limiting values are: 1.0 represents conventional technology wing (Default); 2.0 represents advanced technology wing.', 'historical_name': {'FLOPS': 'AERIN.AITEK', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.airfoil', 'aircraft.outputs.L0_aerodynamics.mission_airfoil', 'aircraft.cached.L0_aerodynamics.mission_airfoil']}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:area': {'default_value': 0.0, 'desc': 'reference wing area', 'historical_name': {'FLOPS': 'CONFIN.SW', 'GASP': 'INGASP.SW', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.wing_ref_area', 'aircraft.outputs.L0_design_variables.mission_wing_ref_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:aspect_ratio': {'default_value': 0.0, 'desc': 'ratio of the wing span to its mean chord', 'historical_name': {'FLOPS': 'CONFIN.AR', 'GASP': 'INGASP.AR', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.wing_aspect_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_aspect_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:aspect_ratio_reference': {'default_value': 0.0, 'desc': 'Reference aspect ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.ARREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_aspect_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:average_chord': {'default_value': 0.0, 'desc': 'mean aerodynamic chord of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CBARW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:bending_factor': {'default_value': 0.0, 'desc': 'wing bending factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_material_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bending_mass': {'default_value': None, 'desc': 'wing mass breakdown term 1', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bending_mat_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bending_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the bending wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI1', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_bending_mat_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:bwb_aft_body_mass': {'default_value': None, 'desc': 'wing mass breakdown term 4', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:bwb_aft_body_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the blended-wing-body aft-body wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI4', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.bwb_aft_body_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:center_chord': {'default_value': 0.0, 'desc': 'wing chord at fuselage centerline', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRCLW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:center_distance': {'default_value': 0.0, 'desc': 'distance (percent fuselage length) from nose to the wing aerodynamic center', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XWQLF', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:characteristic_length': {'default_value': 0.0, 'desc': 'Reynolds characteristic length for the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_component_char_len_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_char_len_table[0]']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:choose_fold_location': {'default_value': True, 'desc': 'if true, fold location is based on your chosen value, otherwise it is based on strut location. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:chord_per_semispan': {'default_value': None, 'desc': 'chord lengths as fractions of semispan at station locations; overwrites station_chord_lengths', 'historical_name': {'FLOPS': 'WTIN.CHD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_chord_lengths'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:composite_fraction': {'default_value': 0.0, 'desc': 'Define the decimal fraction of amount of composites used in wing structure where: 0.0 == no composites; 1.0 == maximum use of composites, approximately equivalent bending_mat_weight=.6, struct_weights=.83, misc_weight=.7 (not necessarily all composite).', 'historical_name': {'FLOPS': 'WTIN.FCOMP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.composite_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:control_surface_area': {'default_value': 0.0, 'desc': 'area of wing control surfaces', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['~WeightABC._pre_surface_ctrls.surface_flap_area', '~WeightABC.calc_surface_ctrls.surface_flap_area']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:control_surface_area_ratio': {'default_value': 0.333, 'desc': 'Defines the ratio of total moveable wing control surface areas (flaps, elevators, spoilers, etc.) to reference wing area.', 'historical_name': {'FLOPS': 'WTIN.FLAPR', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.flap_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:detailed_wing': {'default_value': False, 'desc': 'use a detailed wing model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:dihedral': {'default_value': 0.0, 'desc': 'wing dihedral (positive) or anhedral (negative) angle', 'historical_name': {'FLOPS': 'WTIN.DIH', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_wing.dihedral', 'aircraft.cached.L0_wing.dihedral']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:eng_pod_inertia_factor': {'default_value': 0.0, 'desc': 'engine inertia relief factor', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.engine_inertia_relief_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fineness': {'default_value': 0.0, 'desc': 'wing fineness ratio', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.mission_fineness_ratio_table[0]', 'aircraft.cached.L0_aerodynamics.mission_fineness_ratio_table[0]']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_chord_ratio': {'default_value': 0.0, 'desc': 'ratio of flap chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CFOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_deflection_landing': {'default_value': 0.0, 'desc': 'Deflection of flaps for landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_deflection_takeoff': {'default_value': 0.0, 'desc': 'Deflection of flaps for takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DFLPTO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:flap_drag_increment_optimum': {'default_value': 0.0, 'desc': 'drag coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCDOTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected trailing edge flaps (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMTE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_span_ratio': {'default_value': 0.65, 'desc': 'fraction of wing trailing edge with flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BTEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:flap_type': {'default_value': FlapType.DOUBLE_SLOTTED, 'desc': 'Set the flap type. Available choices are: plain, split, single_slotted, double_slotted, triple_slotted, fowler, and double_slotted_fowler. In GASP this was JFLTYP and was provided as an int from 1-7', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.JFLTYP', 'LEAPS1': None}, 'option': True, 'types': <enum 'FlapType'>, 'units': 'unitless'}, 'aircraft:wing:fold_dimensional_location_specified': {'default_value': False, 'desc': 'if true, fold location from the chosen input is an actual fold span, if false it is normalized to the half span. In GASP this depended on STRUT or YWFOLD', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:fold_mass': {'default_value': 0, 'desc': 'mass of the folding area of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:fold_mass_coefficient': {'default_value': 0, 'desc': 'mass trend coefficient of the wing fold', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folded_span': {'default_value': 118, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.YWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:folded_span_dimensionless': {'default_value': 1, 'desc': 'folded wingspan', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:folding_area': {'default_value': 0.0, 'desc': 'wing area of folding part of wings', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWFOLD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:form_factor': {'default_value': 0.0, 'desc': 'wing form factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:fuselage_interference_factor': {'default_value': 0.0, 'desc': 'wing/fuselage interference factor', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CKI', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:glove_and_bat': {'default_value': 0.0, 'desc': 'total glove and bat area beyond theoretical wing', 'historical_name': {'FLOPS': 'WTIN.GLOV', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.glove_and_bat'}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:has_fold': {'default_value': False, 'desc': 'if true a fold will be included in the wing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:has_strut': {'default_value': False, 'desc': 'if true then aircraft has a strut. In GASP this depended on STRUT', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:height': {'default_value': 0.0, 'desc': 'wing height above ground during ground run, measured at roughly location of mean aerodynamic chord at the mid plane of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HTG', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:high_lift_mass': {'default_value': 0.0, 'desc': 'mass of the high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WHLDEV', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:high_lift_mass_coefficient': {'default_value': 0.0, 'desc': 'mass trend coefficient of high lift devices (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WCFLAP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:incidence': {'default_value': 0.0, 'desc': 'incidence angle of the wings with respect to the fuselage', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.EYEW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:input_station_dist': {'default_value': None, 'desc': 'wing station locations as fractions of semispan; overwrites station_locations', 'historical_name': {'FLOPS': 'WTIN.ETAW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_locations'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_lower': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing lower surface', 'historical_name': {'FLOPS': 'AERIN.TRLW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_lower_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:laminar_flow_upper': {'default_value': 0.0, 'desc': 'define percent laminar flow for wing upper surface', 'historical_name': {'FLOPS': 'AERIN.TRUW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_percent_laminar_flow_upper_surface'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:leading_edge_sweep': {'default_value': 0.0, 'desc': 'sweep angle at leading edge of wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SWPLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'aircraft:wing:load_distribution_control': {'default_value': 2.0, 'desc': 'controls spatial distribution of integratin stations for detailed wing', 'historical_name': {'FLOPS': 'WTIN.PDIST', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.pressure_dist'}, 'option': True, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_fraction': {'default_value': 1.0, 'desc': 'fraction of load carried by defined wing', 'historical_name': {'FLOPS': 'WTIN.PCTL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.carried_load_fraction'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:load_path_sweep_dist': {'default_value': None, 'desc': 'Define the sweep of load path at station locations. Typically parallel to rear spar tending toward max t/c of airfoil. The Ith value is used between wing stations I and I+1.', 'historical_name': {'FLOPS': 'WTIN.SWL', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_load_path_sweeps'}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:loading': {'default_value': 0.0, 'desc': 'wing loading', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.WGS', 'INGASP.WOS'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'aircraft:wing:loading_above_20': {'default_value': True, 'desc': 'if true the wing loading is stated to be above 20 psf. In GASP this depended on WGS', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:mass': {'default_value': None, 'desc': 'wing total mass', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._total_wing_weight', 'aircraft.outputs.L0_weights_summary.total_wing_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:mass_coefficient': {'default_value': 133.4, 'desc': 'mass trend coefficient of the wing without high lift devices', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKWW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the overall wing', 'historical_name': {'FLOPS': 'WTIN.FRWI', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.total_wing_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:material_factor': {'default_value': 0, 'desc': 'correction factor for the use of non optimum material', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKNO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_camber_at_70_semispan': {'default_value': 0.0, 'desc': 'Maximum camber at 70 percent semispan, percent of local chord', 'historical_name': {'FLOPS': 'AERIN.CAM', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.max_camber_at_70_semispan', 'aircraft.outputs.L0_aerodynamics.mission_max_camber_at_70_semispan']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_lift_ref': {'default_value': 0.0, 'desc': 'input reference maximum lift coefficient for basic wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RCLMAX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:max_slat_deflection_landing': {'default_value': 10, 'desc': 'leading edge slat deflection during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_slat_deflection_takeoff': {'default_value': 10, 'desc': 'leading edge slat deflection during takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLED', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:max_thickness_location': {'default_value': 0.0, 'desc': 'location (percent chord) of max wing thickness', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCTCMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:min_pressure_location': {'default_value': 0.0, 'desc': 'location (percent chord) of peak suction', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XCPS', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:misc_mass': {'default_value': None, 'desc': 'wing mass breakdown term 3', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.misc_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:misc_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the miscellaneous wing mass term', 'historical_name': {'FLOPS': 'WTIN.FRWI3', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_misc_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:mounting_type': {'default_value': 0.0, 'desc': 'wing location on fuselage (0 = low wing, 1 = high wing)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HWING', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:num_flap_segments': {'default_value': 2, 'desc': 'number of flap segments per wing panel', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.FLAPN', 'LEAPS1': None}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:num_integration_stations': {'default_value': 50, 'desc': 'number of integration stations', 'historical_name': {'FLOPS': 'WTIN.NSTD', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.integration_station_count'}, 'option': True, 'types': <class 'int'>, 'units': 'unitless'}, 'aircraft:wing:optimum_flap_deflection': {'default_value': 0.0, 'desc': 'optimum flap deflection angle (default depends on flap type)', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:optimum_slat_deflection': {'default_value': 20, 'desc': 'optimum slat deflection angle', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELLEO', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:root_chord': {'default_value': 0.0, 'desc': 'wing chord length at wing root', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CROOT', 'INGASP.CROOTW'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:shear_control_mass': {'default_value': None, 'desc': 'wing mass breakdown term 2', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': 'aircraft.outputs.L0_wing.struct_weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:shear_control_mass_scaler': {'default_value': 1.0, 'desc': 'mass scaler of the shear and control term', 'historical_name': {'FLOPS': 'WTIN.FRWI2', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.wing_struct_weights'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_chord_ratio': {'default_value': 0.15, 'desc': 'ratio of slat chord to wing chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CLEOC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_lift_increment_optimum': {'default_value': 0.0, 'desc': 'lift coefficient increment due to optimally deflected LE slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCLMLE', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:slat_span_ratio': {'default_value': 0.9, 'desc': 'fraction of wing leading edge with slats', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.BLEOB', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span': {'default_value': 0.0, 'desc': 'span of main wing', 'historical_name': {'FLOPS': 'WTIN.SPAN', 'GASP': 'INGASP.B', 'LEAPS1': ['aircraft.inputs.L0_wing.span', 'aircraft.outputs.L0_wing.span', 'BasicTransportWeight.wing_span']}, 'option': False, 'types': None, 'units': 'ft'}, 'aircraft:wing:span_efficiency_factor': {'default_value': 1.0, 'desc': 'coefficient for calculating span efficiency for extreme taper ratios', 'historical_name': {'FLOPS': 'AERIN.E', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:span_efficiency_reduction': {'default_value': False, 'desc': 'Define a switch for span efficiency reduction for extreme taper ratios: True == a span efficiency factor (*wing_span_efficiency_factor0*) is calculated based on wing taper ratio and aspect ratio; False == a span efficiency factor (*wing_span_efficiency_factor0*) is set to 1.0.', 'historical_name': {'FLOPS': 'AERIN.MIKE', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_span_efficiency_reduction'}, 'option': True, 'types': <class 'bool'>, 'units': 'unitless'}, 'aircraft:wing:strut_bracing_factor': {'default_value': 0.0, 'desc': 'Define the wing strut-bracing factor where: 0.0 == no wing-strut; 1.0 == full benefit from strut bracing.', 'historical_name': {'FLOPS': 'WTIN.FSTRT', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.struct_bracing_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass': {'default_value': None, 'desc': 'mass of surface controls', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['(WeightABC)self._surface_ctrls_weight', 'aircraft.outputs.L0_weights_summary.surface_ctrls_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'aircraft:wing:surface_ctrl_mass_coefficient': {'default_value': 0.404, 'desc': 'Surface controls weight coefficient', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SKFW', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:surface_ctrl_mass_scaler': {'default_value': 1.0, 'desc': 'Surface controls mass scaler', 'historical_name': {'FLOPS': 'WTIN.FRSC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_overrides.surface_ctrls_weight'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:sweep': {'default_value': 0.0, 'desc': 'quarter-chord sweep angle of the wing', 'historical_name': {'FLOPS': 'CONFIN.SWEEP', 'GASP': 'INGASP.DLMC4', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.wing_sweep_at_quarter_chord', 'aircraft.outputs.L0_design_variables.mission_wing_sweep_at_quarter_chord']}, 'option': False, 'types': None, 'units': 'deg'}, 'aircraft:wing:taper_ratio': {'default_value': 0.0, 'desc': 'taper ratio of the wing', 'historical_name': {'FLOPS': 'CONFIN.TR', 'GASP': 'INGASP.SLM', 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.wing_taper_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_taper_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio (weighted average)', 'historical_name': {'FLOPS': 'CONFIN.TCA', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.wing_thickness_to_chord_ratio', 'aircraft.outputs.L0_design_variables.mission_wing_thickness_to_chord_ratio']}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_dist': {'default_value': None, 'desc': 'the thickeness-chord ratios at station locations', 'historical_name': {'FLOPS': 'WTIN.TOC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.wing_station_thickness_to_chord_ratios'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_reference': {'default_value': 0.0, 'desc': 'Reference thickness-to-chord ratio, used for detailed wing bending.', 'historical_name': {'FLOPS': 'WTIN.TCREF', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_detailed_wing.ref_thickness_to_chord_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_root': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the root of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_tip': {'default_value': 0.0, 'desc': 'thickness-to-chord ratio at the tip of the wing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TCT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:thickness_to_chord_unweighted': {'default_value': 0.0, 'desc': 'wing thickness-chord ratio at the wing station of the mean aerodynamic chord', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TC', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:ultimate_load_factor': {'default_value': 3.75, 'desc': 'structural ultimate load factor', 'historical_name': {'FLOPS': 'WTIN.ULF', 'GASP': 'INGASP.ULF', 'LEAPS1': 'aircraft.inputs.L0_weights.struct_ult_load_factor'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:var_sweep_mass_penalty': {'default_value': 0.0, 'desc': 'Define the fraction of wing variable sweep mass penalty where: 0.0 == fixed-geometry wing; 1.0 == full variable-sweep wing.', 'historical_name': {'FLOPS': 'WTIN.VARSWP', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_wing.var_sweep_weight_penalty'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:wetted_area': {'default_value': None, 'desc': 'wing wetted area', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': ['aircraft.outputs.L0_aerodynamics.wing_wetted_area', 'aircraft.outputs.L0_aerodynamics.mission_component_wetted_area_table[0]', 'aircraft.cached.L0_aerodynamics.mission_component_wetted_area_table[0]']}, 'option': False, 'types': None, 'units': 'ft**2'}, 'aircraft:wing:wetted_area_scaler': {'default_value': 1.0, 'desc': 'wing wetted area scaler', 'historical_name': {'FLOPS': 'AERIN.SWETW', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_aerodynamics.wing_wetted_area'}, 'option': False, 'types': None, 'units': 'unitless'}, 'aircraft:wing:zero_lift_angle': {'default_value': 0.0, 'desc': 'zero lift angle of attack', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALPHL0', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg'}, 'altitude': {'default_value': 0.0, 'desc': 'Current altitude of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'altitude_rate': {'default_value': 0.0, 'desc': 'Current rate of altitude change (climb rate) of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'altitude_rate_max': {'default_value': 0.0, 'desc': 'Current maximum possible rate of altitude change (climb rate) of the vehicle (at hypothetical maximum thrust condition)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'density': {'default_value': 0.0, 'desc': "Atmospheric density at the vehicle's current altitude", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/ft**3'}, 'distance': {'default_value': 0.0, 'desc': 'The total distance the vehicle has traveled since brake release at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'distance_rate': {'default_value': 0.0, 'desc': 'The rate at which the distance traveled is changing at the current time', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM/s'}, 'drag': {'default_value': 0.0, 'desc': 'Current total drag experienced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'dynamic_pressure': {'default_value': 0.0, 'desc': "Atmospheric dynamic pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 'electric_power': {'default_value': 0.0, 'desc': 'Current electric power consumption of the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'electric_power_total': {'default_value': 0.0, 'desc': 'Current total electric power consumption of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kW'}, 'flight_path_angle': {'default_value': 0.0, 'desc': 'Current flight path angle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad'}, 'flight_path_angle_rate': {'default_value': 0.0, 'desc': 'Current rate at which flight path angle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'rad/s'}, 'fuel_flow_rate': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative': {'default_value': 0.0, 'desc': 'Current rate of fuel consumption of the vehicle, per single instance of each engine model. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_negative_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as negative.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'fuel_flow_rate_total': {'default_value': 0.0, 'desc': 'Current rate of total fuel consumption of the vehicle. Consumption (i.e. mass reduction) of fuel is defined as positive.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'hybrid_throttle': {'default_value': 0.0, 'desc': 'Current secondary throttle setting of each individual engine model on the vehicle, used as an additional degree of control for hybrid engines', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'lift': {'default_value': 0.0, 'desc': 'Current total lift produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'mach': {'default_value': 0.0, 'desc': 'Current Mach number of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mass': {'default_value': 0.0, 'desc': 'Current total mass of the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mass_rate': {'default_value': 0.0, 'desc': 'Current rate at which the mass of the vehicle is changing', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/s'}, 'mission:constraints:mass_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft mass closes on actual gross takeoff mass, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:constraints:max_mach': {'default_value': None, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'WTIN.VMMO', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_weights.max_mach', 'aircraft.outputs.L0_weights.max_mach']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:constraints:range_residual': {'default_value': 0.0, 'desc': 'residual to make sure aircraft range is equal to the targeted range, value should be zero at convergence (within acceptable tolerance)', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:cruise_altitude': {'default_value': 25000, 'desc': 'design mission cruise altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.CRALT', 'LEAPS1': None}, 'option': True, 'types': [<class 'int'>, <class 'float'>], 'units': 'ft'}, 'mission:design:cruise_range': {'default_value': 0.0, 'desc': 'the distance flown by the aircraft during cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:fuel_mass': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFADES', 'LEAPS1': ['(WeightABC)self._fuel_weight', 'aircraft.outputs.L0_weights_summary.fuel_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:fuel_mass_required': {'default_value': 0.0, 'desc': 'fuel carried by the aircraft when it is on the ramp at the beginning of the design mission', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFAREQ', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:gross_mass': {'default_value': None, 'desc': 'design gross mass of the aircraft', 'historical_name': {'FLOPS': 'WTIN.DGW', 'GASP': 'INGASP.WG', 'LEAPS1': ['aircraft.inputs.L0_weights.design_ramp_weight', '(weightABC)self._design_gross_weight']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:lift_coefficient': {'default_value': None, 'desc': 'Fixed design lift coefficient. If input, overrides design lift coefficient computed by EDET.', 'historical_name': {'FLOPS': 'AERIN.FCLDES', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_aerodynamics.design_lift_coeff', 'aircraft.outputs.L0_aerodynamics.design_lift_coeff']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:lift_coefficient_max_flaps_up': {'default_value': 0.0, 'desc': 'maximum lift coefficient from flaps model when flaps are up (not deployed)', 'historical_name': {'FLOPS': None, 'GASP': ['INGASP.CLMWFU', 'INGASP.CLMAX'], 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:mach': {'default_value': 0.0, 'desc': 'aircraft design Mach number', 'historical_name': {'FLOPS': 'AERIN.FMDES', 'GASP': 'INGASP.CRMACH', 'LEAPS1': ['aircraft.inputs.L0_design_variables.design_mach', 'aircraft.outputs.L0_design_variables.design_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:design:range': {'default_value': 0.0, 'desc': 'the aircraft target distance', 'historical_name': {'FLOPS': 'CONFIN.DESRNG', 'GASP': 'INGASP.ARNGE', 'LEAPS1': 'aircraft.inputs.L0_configuration.design_range'}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:design:rate_of_climb_at_top_of_climb': {'default_value': 0.0, 'desc': 'The required rate of climb at top of climb', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ROCTOC', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft/min'}, 'mission:design:reserve_fuel': {'default_value': 0, 'desc': 'the total fuel reserves in lbm available during the mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:design:thrust_takeoff_per_eng': {'default_value': 0.0, 'desc': 'thrust on the aircraft for takeoff', 'historical_name': {'FLOPS': 'AERIN.THROFF', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_engine.thrust_takeoff', '(SimpleTakeoff)self.thrust']}, 'option': False, 'types': None, 'units': 'lbf'}, 'mission:landing:airport_altitude': {'default_value': 0, 'desc': 'altitude of airport where aircraft lands', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.ALTLND', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:braking_delay': {'default_value': 1, 'desc': 'time delay between touchdown and the application of brakes', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.TDELAY', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:landing:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'landing coefficient of friction, with brakes on', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:field_length': {'default_value': 0.0, 'desc': 'FAR landing field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.landing_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:flare_rate': {'default_value': 2.0, 'desc': 'flare rate in detailed landing', 'historical_name': {'FLOPS': 'TOLIN.VANGLD', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'deg/s'}, 'mission:landing:glide_to_stall_ratio': {'default_value': 1.3, 'desc': 'ratio of glide (approach) speed to stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VRATT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:ground_distance': {'default_value': 0.0, 'desc': 'distance covered over the ground during landing', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DLT', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_altitude': {'default_value': 0.0, 'desc': 'altitude where landing calculations begin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HIN', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:initial_mach': {'default_value': 0.1, 'desc': 'approach mach number', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:initial_velocity': {'default_value': 0.0, 'desc': 'approach velocity', 'historical_name': {'FLOPS': 'AERIN.VAPPR', 'GASP': 'INGASP.VGL', 'LEAPS1': '(SimpleLanding)self.vapp'}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at landing due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:lift_coefficient_max': {'default_value': 3.0, 'desc': 'maximum lift coefficient for landing', 'historical_name': {'FLOPS': 'AERIN.CLLDM', 'GASP': 'INGASP.CLMWLD', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_landing_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_flare_load_factor': {'default_value': 1.15, 'desc': 'maximum load factor during landing flare', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.XLFMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:maximum_sink_rate': {'default_value': 1000, 'desc': 'maximum rate of sink during glide', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.RSMX', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/min'}, 'mission:landing:obstacle_height': {'default_value': 50, 'desc': 'landing obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.HAPP', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:landing:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during landing rollout', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:landing:stall_velocity': {'default_value': 0.0, 'desc': 'stall speed during approach', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VST', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:landing:touchdown_mass': {'default_value': 0.0, 'desc': 'computed mass of aircraft for landing, is onlyrequired to be equal to Aircraft.Design.TOUCHDOWN_MASSwhen the design case is being run', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleLanding)self.weight'}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:landing:touchdown_sink_rate': {'default_value': 3, 'desc': 'sink rate at touchdown', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.SINKTD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'mission:objectives:fuel': {'default_value': 0.0, 'desc': 'regularized objective that minimizes total fuel mass subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:objectives:range': {'default_value': 0.0, 'desc': 'regularized objective that maximizes range subject to other necessary additions', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mach': {'default_value': 0.0, 'desc': 'aircraft cruise mach number', 'historical_name': {'FLOPS': 'CONFIN.VCMN', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.cruise_mach', 'aircraft.outputs.L0_design_variables.mission_cruise_mach']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:summary:cruise_mass_final': {'default_value': 0.0, 'desc': 'mass of the aircraft at the end of cruise', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:fuel_flow_scaler': {'default_value': 1.0, 'desc': 'scale factor on overall fuel flow', 'historical_name': {'FLOPS': 'MISSIN.FACT', 'GASP': 'INGASP.CKFF', 'LEAPS1': ['aircraft.inputs.L0_fuel_flow.overall_factor']}, 'option': True, 'types': None, 'units': 'unitless'}, 'mission:summary:gross_mass': {'default_value': 0.0, 'desc': 'gross takeoff mass of aircraft for that specific mission, notnecessarily the value for the aircraft`s design mission', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:summary:range': {'default_value': 0.0, 'desc': 'actual range that the aircraft flies, whetherit is a design case or an off design case. Equalto Mission.Design.RANGE value in the design case.', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'NM'}, 'mission:summary:total_fuel_mass': {'default_value': 0.0, 'desc': 'total fuel carried at the beginnning of a missionincludes fuel burned in the mission, reserve fueland fuel margin', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.WFA', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:airport_altitude': {'default_value': 0.0, 'desc': 'altitude of airport where aircraft takes off', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:angle_of_attack_runway': {'default_value': 0.0, 'desc': 'angle of attack on ground', 'historical_name': {'FLOPS': 'TOLIN.ALPRUN', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.alpha_runway'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:takeoff:ascent_duration': {'default_value': 0.0, 'desc': 'duration of the ascent phase of takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:ascent_t_initial': {'default_value': 10, 'desc': 'time that the ascent phase of takeoff starts at', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 's'}, 'mission:takeoff:braking_friction_coefficient': {'default_value': 0.3, 'desc': 'takeoff coefficient of friction, with brakes on', 'historical_name': {'FLOPS': 'TOLIN.BRAKMU', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.braking_mu'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:decision_speed_increment': {'default_value': 5, 'desc': 'increment of engine failure decision speed above stall speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DV1', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:drag_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'drag coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCD', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:drag_coefficient_min': {'default_value': 0.0, 'desc': 'Minimum drag coefficient for takeoff. Typically this is CD at zero lift.', 'historical_name': {'FLOPS': 'AERIN.CDMTO', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:field_length': {'default_value': 0.0, 'desc': 'FAR takeoff field length', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.takeoff_distance'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_altitude': {'default_value': 35.0, 'desc': 'altitude of aircraft at the end of takeoff', 'historical_name': {'FLOPS': 'TOLIN.OBSTO', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.obstacle_height'}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:final_mass': {'default_value': 0.0, 'desc': 'mass after aircraft has cleared 35 ft obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:final_velocity': {'default_value': 0.0, 'desc': 'velocity of aircraft after taking off and clearing a 35 foot obstacle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(ClimbToObstacle)self.V2'}, 'option': False, 'types': None, 'units': 'm/s'}, 'mission:takeoff:fuel_simple': {'default_value': None, 'desc': 'fuel burned during simple takeoff calculation', 'historical_name': {'FLOPS': 'MISSIN.FTKOFL', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_mission.fixed_takeoff_fuel', 'aircraft.outputs.L0_takeoff_and_landing.takeoff_fuel']}, 'option': False, 'types': None, 'units': 'lbm'}, 'mission:takeoff:ground_distance': {'default_value': 0.0, 'desc': 'ground distance covered by takeoff with all engines operating', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft'}, 'mission:takeoff:lift_coefficient_flap_increment': {'default_value': 0.0, 'desc': 'lift coefficient increment at takeoff due to flaps', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DCL', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_coefficient_max': {'default_value': 2.0, 'desc': 'maximum lift coefficient for takeoff', 'historical_name': {'FLOPS': 'AERIN.CLTOM', 'GASP': 'INGASP.CLMWTO', 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.max_takeoff_lift_coeff'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:lift_over_drag': {'default_value': 0.0, 'desc': 'ratio of lift to drag at takeoff', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': '(SimpleTakeoff)self.lift_over_drag_ratio'}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:obstacle_height': {'default_value': 35.0, 'desc': 'takeoff obstacle height above the ground at airport altitude', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'ft'}, 'mission:takeoff:rolling_friction_coefficient': {'default_value': 0.025, 'desc': 'coefficient of rolling friction for groundrollportion of takeoff', 'historical_name': {'FLOPS': 'TOLIN.ROLLMU', 'GASP': None, 'LEAPS1': ['aircraft.inputs.L0_takeoff_and_landing.rolling_mu', '(GroundRoll)self.mu', '(Rotate)self.mu', '(GroundBrake)self.rolling_mu']}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:rotation_speed_increment': {'default_value': 5, 'desc': 'increment of takeoff rotation speed above engine failure decision speed', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DVR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:rotation_velocity': {'default_value': 0.0, 'desc': 'rotation velocity', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.VR', 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'kn'}, 'mission:takeoff:spoiler_drag_coefficient': {'default_value': 0.0, 'desc': 'drag coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CDSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:spoiler_lift_coefficient': {'default_value': 0.0, 'desc': 'lift coefficient for spoilers during takeoff abort', 'historical_name': {'FLOPS': 'TOLIN.CLSPOL', 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'mission:takeoff:thrust_incidence': {'default_value': 0.0, 'desc': 'thrust incidence on ground', 'historical_name': {'FLOPS': 'TOLIN.TINC', 'GASP': None, 'LEAPS1': 'aircraft.inputs.L0_takeoff_and_landing.thrust_incidence_angle'}, 'option': True, 'types': None, 'units': 'deg'}, 'mission:taxi:duration': {'default_value': 0.167, 'desc': 'time spent taxiing before takeoff', 'historical_name': {'FLOPS': None, 'GASP': 'INGASP.DELTT', 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'h'}, 'mission:taxi:mach': {'default_value': 0.0001, 'desc': 'speed during taxi, must be nonzero if pycycle is enabled', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': None, 'units': 'unitless'}, 'nox_rate': {'default_value': 0.0, 'desc': 'Current rate of nitrous oxide (NOx) production by the vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'nox_rate_total': {'default_value': 0.0, 'desc': 'Current total rate of nitrous oxide (NOx) production by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbm/h'}, 'range': {'default_value': 0.0, 'desc': 'Current cumulative ground distance the vehicle has flown', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm'}, 'range_rate': {'default_value': 0.0, 'desc': 'Current rate of change in cumulative ground distance (ground velocity) for the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'nm/s'}, 'settings:equations_of_motion': {'default_value': None, 'desc': 'Sets which equations of motion Aviary will use in mission analysis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'EquationsOfMotion'>, 'units': 'unitless'}, 'settings:mass_method': {'default_value': None, 'desc': "Sets which legacy code's methods will be used for mass estimation", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'LegacyCode'>, 'units': 'unitless'}, 'settings:verbosity': {'default_value': Verbosity.BRIEF, 'desc': 'Sets how much information Aviary outputs when run. Options include:0. QUIET: All output except errors are suppressed1. BRIEF: Only important information is output, in human-readable format2. VERBOSE: All avaliable informating is output, in human-readable format3. DEBUG: Intermediate status and calculation outputs, no formatting requirement', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': True, 'types': <enum 'Verbosity'>, 'units': 'unitless'}, 'specific_energy_rate': {'default_value': 0.0, 'desc': 'Rate of change in specific energy (specific power) of the vehicle at current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'specific_energy_rate_excess': {'default_value': 0.0, 'desc': 'Specific excess power of the vehicle at current flight condition and at hypothetical maximum thrust', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'm/s'}, 'speed_of_sound': {'default_value': 0.0, 'desc': "Atmospheric speed of sound at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'static_pressure': {'default_value': 0.0, 'desc': "Atmospheric static pressure at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf/ft**2'}, 't4': {'default_value': 0.0, 'desc': 'Current turbine exit temperature (T4) of turbine engines on vehicle, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'temperature': {'default_value': 0.0, 'desc': "Atmospheric temperature at vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'degR'}, 'throttle': {'default_value': 0.0, 'desc': 'Current throttle setting for each individual engine model on the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'unitless'}, 'thrust_net': {'default_value': 0.0, 'desc': 'Current net thrust produced by engines, per single instance of each engine model', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max': {'default_value': 0.0, 'desc': "Hypothetical maximum possible net thrust that can be produced per single instance of each engine model at the vehicle's current flight condition", 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_max_total': {'default_value': 0.0, 'desc': 'Hypothetical maximum possible net thrust produced by the vehicle at its current flight condition', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'thrust_net_total': {'default_value': 0.0, 'desc': 'Current total net thrust produced by the vehicle', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'lbf'}, 'velocity': {'default_value': 0.0, 'desc': 'Current velocity of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s'}, 'velocity_rate': {'default_value': 0.0, 'desc': 'Current rate of change in velocity (acceleration) of the vehicle along its body axis', 'historical_name': {'FLOPS': None, 'GASP': None, 'LEAPS1': None}, 'option': False, 'types': None, 'units': 'ft/s**2'}}) → bool[source]
+

Returns True if the variable is defined as an option in the MetaData.

+
+
Parameters:
+
    +

  • key (str) – Name of the variable to be checked

    • +

  • meta_data (dict) – Dictionary containing metadata for the variable. If None, Aviary’s built-in +metadata will be used.

    • +
+
+
+
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info/variable_meta_data.html b/_srcdocs/packages/variable_info/variable_meta_data.html new file mode 100644 index 000000000..b1a057687 --- /dev/null +++ b/_srcdocs/packages/variable_info/variable_meta_data.html @@ -0,0 +1,560 @@ + + + + + + + + + + + + variable_meta_data.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

variable_meta_data.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

variable_meta_data.py#

+
+

Define meta data associated with variables in the Aviary data hierarchy.

+
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info/variables.html b/_srcdocs/packages/variable_info/variables.html new file mode 100644 index 000000000..8aac33409 --- /dev/null +++ b/_srcdocs/packages/variable_info/variables.html @@ -0,0 +1,3439 @@ + + + + + + + + + + + + variables.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

variables.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

variables.py#

+
+

This is a variable hierarchy that is for a single mission. Each mission +gets a copy of this hierarchy.

+
+
+class aviary.variable_info.variables.Aircraft[source]
+

Bases: object

+
+
+class APU[source]
+

Bases: object

+
+
+MASS = 'aircraft:apu:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:apu:mass_scaler'
+
+ +
+ +
+
+class AirConditioning[source]
+

Bases: object

+
+
+MASS = 'aircraft:air_conditioning:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:air_conditioning:mass_scaler'
+
+ +
+ +
+
+class AntiIcing[source]
+

Bases: object

+
+
+MASS = 'aircraft:anti_icing:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:anti_icing:mass_scaler'
+
+ +
+ +
+
+class Avionics[source]
+

Bases: object

+
+
+MASS = 'aircraft:avionics:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:avionics:mass_scaler'
+
+ +
+ +
+
+class BWB[source]
+

Bases: object

+
+
+CABIN_AREA = 'aircraft:blended_wing_body_design:cabin_area'
+
+ +
+
+NUM_BAYS = 'aircraft:blended_wing_body_design:num_bays'
+
+ +
+
+PASSENGER_LEADING_EDGE_SWEEP = 'aircraft:blended_wing_body_design:passenger_leading_edge_sweep'
+
+ +
+ +
+
+class Canard[source]
+

Bases: object

+
+
+AREA = 'aircraft:canard:area'
+
+ +
+
+ASPECT_RATIO = 'aircraft:canard:aspect_ratio'
+
+ +
+
+CHARACTERISTIC_LENGTH = 'aircraft:canard:characteristic_length'
+
+ +
+
+FINENESS = 'aircraft:canard:fineness'
+
+ +
+
+LAMINAR_FLOW_LOWER = 'aircraft:canard:laminar_flow_lower'
+
+ +
+
+LAMINAR_FLOW_UPPER = 'aircraft:canard:laminar_flow_upper'
+
+ +
+
+MASS = 'aircraft:canard:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:canard:mass_scaler'
+
+ +
+
+TAPER_RATIO = 'aircraft:canard:taper_ratio'
+
+ +
+
+THICKNESS_TO_CHORD = 'aircraft:canard:thickness_to_chord'
+
+ +
+
+WETTED_AREA = 'aircraft:canard:wetted_area'
+
+ +
+
+WETTED_AREA_SCALER = 'aircraft:canard:wetted_area_scaler'
+
+ +
+ +
+
+class Controls[source]
+

Bases: object

+
+
+COCKPIT_CONTROL_MASS_SCALER = 'aircraft:controls:cockpit_control_mass_scaler'
+
+ +
+
+CONTROL_MASS_INCREMENT = 'aircraft:controls:control_mass_increment'
+
+ +
+
+STABILITY_AUGMENTATION_SYSTEM_MASS = 'aircraft:controls:stability_augmentation_system_mass'
+
+ +
+
+STABILITY_AUGMENTATION_SYSTEM_MASS_SCALER = 'aircraft:controls:stability_augmentation_system_mass_scaler'
+
+ +
+
+TOTAL_MASS = 'aircraft:controls:total_mass'
+
+ +
+ +
+
+class CrewPayload[source]
+

Bases: object

+
+
+BAGGAGE_MASS = 'aircraft:crew_and_payload:baggage_mass'
+
+ +
+
+BAGGAGE_MASS_PER_PASSENGER = 'aircraft:crew_and_payload:baggage_mass_per_passenger'
+
+ +
+
+CARGO_CONTAINER_MASS = 'aircraft:crew_and_payload:cargo_container_mass'
+
+ +
+
+CARGO_CONTAINER_MASS_SCALER = 'aircraft:crew_and_payload:cargo_container_mass_scaler'
+
+ +
+
+CARGO_MASS = 'aircraft:crew_and_payload:cargo_mass'
+
+ +
+
+FLIGHT_CREW_MASS = 'aircraft:crew_and_payload:flight_crew_mass'
+
+ +
+
+FLIGHT_CREW_MASS_SCALER = 'aircraft:crew_and_payload:flight_crew_mass_scaler'
+
+ +
+
+MASS_PER_PASSENGER = 'aircraft:crew_and_payload:mass_per_passenger'
+
+ +
+
+MISC_CARGO = 'aircraft:crew_and_payload:misc_cargo'
+
+ +
+
+NON_FLIGHT_CREW_MASS = 'aircraft:crew_and_payload:non_flight_crew_mass'
+
+ +
+
+NON_FLIGHT_CREW_MASS_SCALER = 'aircraft:crew_and_payload:non_flight_crew_mass_scaler'
+
+ +
+
+NUM_BUSINESS_CLASS = 'aircraft:crew_and_payload:num_business_class'
+
+ +
+
+NUM_FIRST_CLASS = 'aircraft:crew_and_payload:num_first_class'
+
+ +
+
+NUM_FLIGHT_ATTENDANTS = 'aircraft:crew_and_payload:num_flight_attendants'
+
+ +
+
+NUM_FLIGHT_CREW = 'aircraft:crew_and_payload:num_flight_crew'
+
+ +
+
+NUM_GALLEY_CREW = 'aircraft:crew_and_payload:num_galley_crew'
+
+ +
+
+NUM_PASSENGERS = 'aircraft:crew_and_payload:num_passengers'
+
+ +
+
+NUM_TOURIST_CLASS = 'aircraft:crew_and_payload:num_tourist_class'
+
+ +
+
+PASSENGER_MASS = 'aircraft:crew_and_payload:passenger_mass'
+
+ +
+
+PASSENGER_MASS_WITH_BAGS = 'aircraft:crew_and_payload:passenger_mass_with_bags'
+
+ +
+
+PASSENGER_PAYLOAD_MASS = 'aircraft:crew_and_payload:passenger_payload_mass'
+
+ +
+
+PASSENGER_SERVICE_MASS = 'aircraft:crew_and_payload:passenger_service_mass'
+
+ +
+
+PASSENGER_SERVICE_MASS_SCALER = 'aircraft:crew_and_payload:passenger_service_mass_scaler'
+
+ +
+
+TOTAL_PAYLOAD_MASS = 'aircraft:crew_and_payload:total_payload_mass'
+
+ +
+
+WING_CARGO = 'aircraft:crew_and_payload:wing_cargo'
+
+ +
+ +
+
+class Design[source]
+

Bases: object

+
+
+BASE_AREA = 'aircraft:design:base_area'
+
+ +
+
+CG_DELTA = 'aircraft:design:cg_delta'
+
+ +
+
+CHARACTERISTIC_LENGTHS = 'aircraft:design:characteristic_lengths'
+
+ +
+
+COCKPIT_CONTROL_MASS_COEFFICIENT = 'aircraft:design:cockpit_control_mass_coefficient'
+
+ +
+
+COMPUTE_HTAIL_VOLUME_COEFF = 'aircraft:design:compute_htail_volume_coeff'
+
+ +
+
+COMPUTE_VTAIL_VOLUME_COEFF = 'aircraft:design:compute_vtail_volume_coeff'
+
+ +
+
+DRAG_COEFFICIENT_INCREMENT = 'aircraft:design:drag_increment'
+
+ +
+
+DRAG_POLAR = 'aircraft:design:drag_polar'
+
+ +
+
+EMPTY_MASS = 'aircraft:design:empty_mass'
+
+ +
+
+EMPTY_MASS_MARGIN = 'aircraft:design:empty_mass_margin'
+
+ +
+
+EMPTY_MASS_MARGIN_SCALER = 'aircraft:design:empty_mass_margin_scaler'
+
+ +
+
+EQUIPMENT_MASS_COEFFICIENTS = 'aircraft:design:equipment_mass_coefficients'
+
+ +
+
+EXTERNAL_SUBSYSTEMS_MASS = 'aircraft:design:external_subsystems_mass'
+
+ +
+
+FINENESS = 'aircraft:design:fineness'
+
+ +
+
+FIXED_EQUIPMENT_MASS = 'aircraft:design:fixed_equipment_mass'
+
+ +
+
+FIXED_USEFUL_LOAD = 'aircraft:design:fixed_useful_load'
+
+ +
+
+IJEFF = 'aircraft:design:ijeff'
+
+ +
+
+LAMINAR_FLOW_LOWER = 'aircraft:design:laminar_flow_lower'
+
+ +
+
+LAMINAR_FLOW_UPPER = 'aircraft:design:laminar_flow_upper'
+
+ +
+
+LANDING_TO_TAKEOFF_MASS_RATIO = 'aircraft:design:landing_to_takeoff_mass_ratio'
+
+ +
+
+LIFT_CURVE_SLOPE = 'aircraft:design:lift_curve_slope'
+
+ +
+
+LIFT_DEPENDENT_DRAG_COEFF_FACTOR = 'aircraft:design:lift_dependent_drag_coeff_factor'
+
+ +
+
+LIFT_POLAR = 'aircraft:design:lift_polar'
+
+ +
+
+MAX_FUSELAGE_PITCH_ANGLE = 'aircraft:design:max_fuselage_pitch_angle'
+
+ +
+
+MAX_STRUCTURAL_SPEED = 'aircraft:design:max_structural_speed'
+
+ +
+
+OPERATING_MASS = 'aircraft:design:operating_mass'
+
+ +
+
+PART25_STRUCTURAL_CATEGORY = 'aircraft:design:part25_structural_category'
+
+ +
+
+RESERVES = 'aircraft:design:reserves'
+
+ +
+
+SMOOTH_MASS_DISCONTINUITIES = 'aircraft:design:smooth_mass_discontinuities'
+
+ +
+
+STATIC_MARGIN = 'aircraft:design:static_margin'
+
+ +
+
+STRUCTURAL_MASS_INCREMENT = 'aircraft:design:structural_mass_increment'
+
+ +
+
+STRUCTURE_MASS = 'aircraft:design:structure_mass'
+
+ +
+
+SUBSONIC_DRAG_COEFF_FACTOR = 'aircraft:design:subsonic_drag_coeff_factor'
+
+ +
+
+SUPERCRITICAL_DIVERGENCE_SHIFT = 'aircraft:design:supercritical_drag_shift'
+
+ +
+
+SUPERSONIC_DRAG_COEFF_FACTOR = 'aircraft:design:supersonic_drag_coeff_factor'
+
+ +
+
+SYSTEMS_EQUIP_MASS = 'aircraft:design:systems_equip_mass'
+
+ +
+
+SYSTEMS_EQUIP_MASS_BASE = 'aircraft:design:systems_equip_mass_base'
+
+ +
+
+THRUST_TO_WEIGHT_RATIO = 'aircraft:design:thrust_to_weight_ratio'
+
+ +
+
+TOTAL_WETTED_AREA = 'aircraft:design:total_wetted_area'
+
+ +
+
+TOUCHDOWN_MASS = 'aircraft:design:touchdown_mass'
+
+ +
+
+ULF_CALCULATED_FROM_MANEUVER = 'aircraft:design:ulf_calculated_from_maneuver'
+
+ +
+
+USE_ALT_MASS = 'aircraft:design:use_alt_mass'
+
+ +
+
+WETTED_AREAS = 'aircraft:design:wetted_areas'
+
+ +
+
+ZERO_FUEL_MASS = 'aircraft:design:zero_fuel_mass'
+
+ +
+
+ZERO_LIFT_DRAG_COEFF_FACTOR = 'aircraft:design:zero_lift_drag_coeff_factor'
+
+ +
+ +
+
+class Electrical[source]
+

Bases: object

+
+
+HAS_HYBRID_SYSTEM = 'aircraft:electrical:has_hybrid_system'
+
+ +
+
+HYBRID_CABLE_LENGTH = 'aircraft:electrical:hybrid_cable_length'
+
+ +
+
+MASS = 'aircraft:electrical:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:electrical:mass_scaler'
+
+ +
+ +
+
+class Engine[source]
+

Bases: object

+
+
+ADDITIONAL_MASS = 'aircraft:engine:additional_mass'
+
+ +
+
+ADDITIONAL_MASS_FRACTION = 'aircraft:engine:additional_mass_fraction'
+
+ +
+
+CONSTANT_FUEL_CONSUMPTION = 'aircraft:engine:constant_fuel_consumption'
+
+ +
+
+CONTROLS_MASS = 'aircraft:engine:controls_mass'
+
+ +
+
+DATA_FILE = 'aircraft:engine:data_file'
+
+ +
+
+FLIGHT_IDLE_MAX_FRACTION = 'aircraft:engine:flight_idle_max_fraction'
+
+ +
+
+FLIGHT_IDLE_MIN_FRACTION = 'aircraft:engine:flight_idle_min_fraction'
+
+ +
+
+FLIGHT_IDLE_THRUST_FRACTION = 'aircraft:engine:flight_idle_thrust_fraction'
+
+ +
+
+FUEL_FLOW_SCALER_CONSTANT_TERM = 'aircraft:engine:fuel_flow_scaler_constant_term'
+
+ +
+
+FUEL_FLOW_SCALER_LINEAR_TERM = 'aircraft:engine:fuel_flow_scaler_linear_term'
+
+ +
+
+GENERATE_FLIGHT_IDLE = 'aircraft:engine:generate_flight_idle'
+
+ +
+
+GEOPOTENTIAL_ALT = 'aircraft:engine:geopotential_alt'
+
+ +
+
+HAS_PROPELLERS = 'aircraft:engine:has_propellers'
+
+ +
+
+IGNORE_NEGATIVE_THRUST = 'aircraft:engine:ignore_negative_thrust'
+
+ +
+
+INTERPOLATION_METHOD = 'aircraft:engine:interpolation_method'
+
+ +
+
+MASS = 'aircraft:engine:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:engine:mass_scaler'
+
+ +
+
+MASS_SPECIFIC = 'aircraft:engine:mass_specific'
+
+ +
+
+MODEL_SLS_THRUST = 'aircraft:engine:model_sls_thrust'
+
+ +
+
+NUM_ENGINES = 'aircraft:engine:num_engines'
+
+ +
+
+NUM_FUSELAGE_ENGINES = 'aircraft:engine:num_fuselage_engines'
+
+ +
+
+NUM_WING_ENGINES = 'aircraft:engine:num_wing_engines'
+
+ +
+
+POD_MASS = 'aircraft:engine:pod_mass'
+
+ +
+
+POD_MASS_SCALER = 'aircraft:engine:pod_mass_scaler'
+
+ +
+
+POSITION_FACTOR = 'aircraft:engine:position_factor'
+
+ +
+
+PYLON_FACTOR = 'aircraft:engine:pylon_factor'
+
+ +
+
+REFERENCE_DIAMETER = 'aircraft:engine:reference_diameter'
+
+ +
+
+REFERENCE_MASS = 'aircraft:engine:reference_mass'
+
+ +
+
+REFERENCE_SLS_THRUST = 'aircraft:engine:reference_sls_thrust'
+
+ +
+
+SCALED_SLS_THRUST = 'aircraft:engine:scaled_sls_thrust'
+
+ +
+
+SCALE_FACTOR = 'aircraft:engine:scale_factor'
+
+ +
+
+SCALE_MASS = 'aircraft:engine:scale_mass'
+
+ +
+
+SCALE_PERFORMANCE = 'aircraft:engine:scale_performance'
+
+ +
+
+STARTER_MASS = 'aircraft:engine:starter_mass'
+
+ +
+
+SUBSONIC_FUEL_FLOW_SCALER = 'aircraft:engine:subsonic_fuel_flow_scaler'
+
+ +
+
+SUPERSONIC_FUEL_FLOW_SCALER = 'aircraft:engine:supersonic_fuel_flow_scaler'
+
+ +
+
+THRUST_REVERSERS_MASS = 'aircraft:engine:thrust_reversers_mass'
+
+ +
+
+THRUST_REVERSERS_MASS_SCALER = 'aircraft:engine:thrust_reversers_mass_scaler'
+
+ +
+
+TYPE = 'aircraft:engine:type'
+
+ +
+
+WING_LOCATIONS = 'aircraft:engine:wing_locations'
+
+ +
+ +
+
+class Fins[source]
+

Bases: object

+
+
+AREA = 'aircraft:fins:area'
+
+ +
+
+MASS = 'aircraft:fins:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:fins:mass_scaler'
+
+ +
+
+NUM_FINS = 'aircraft:fins:num_fins'
+
+ +
+
+TAPER_RATIO = 'aircraft:fins:taper_ratio'
+
+ +
+ +
+
+class Fuel[source]
+

Bases: object

+
+
+AUXILIARY_FUEL_CAPACITY = 'aircraft:fuel:auxiliary_fuel_capacity'
+
+ +
+
+BURN_PER_PASSENGER_MILE = 'aircraft:fuel:burn_per_passenger_mile'
+
+ +
+
+CAPACITY_FACTOR = 'aircraft:fuel:capacity_factor'
+
+ +
+
+DENSITY = 'aircraft:fuel:density'
+
+ +
+
+DENSITY_RATIO = 'aircraft:fuel:density_ratio'
+
+ +
+
+FUEL_MARGIN = 'aircraft:fuel:fuel_margin'
+
+ +
+
+FUEL_SYSTEM_MASS = 'aircraft:fuel:fuel_system_mass'
+
+ +
+
+FUEL_SYSTEM_MASS_COEFFICIENT = 'aircraft:fuel:fuel_system_mass_coefficient'
+
+ +
+
+FUEL_SYSTEM_MASS_SCALER = 'aircraft:fuel:fuel_system_mass_scaler'
+
+ +
+
+FUSELAGE_FUEL_CAPACITY = 'aircraft:fuel:fuselage_fuel_capacity'
+
+ +
+
+NUM_TANKS = 'aircraft:fuel:num_tanks'
+
+ +
+
+TOTAL_CAPACITY = 'aircraft:fuel:total_capacity'
+
+ +
+
+TOTAL_VOLUME = 'aircraft:fuel:total_volume'
+
+ +
+
+UNUSABLE_FUEL_MASS = 'aircraft:fuel:unusable_fuel_mass'
+
+ +
+
+UNUSABLE_FUEL_MASS_SCALER = 'aircraft:fuel:unusable_fuel_mass_scaler'
+
+ +
+
+WING_FUEL_CAPACITY = 'aircraft:fuel:wing_fuel_capacity'
+
+ +
+
+WING_FUEL_FRACTION = 'aircraft:fuel:wing_fuel_fraction'
+
+ +
+
+WING_REF_CAPACITY = 'aircraft:fuel:wing_ref_capacity'
+
+ +
+
+WING_REF_CAPACITY_AREA = 'aircraft:fuel:wing_ref_capacity_area'
+
+ +
+
+WING_REF_CAPACITY_TERM_A = 'aircraft:fuel:wing_ref_capacity_term_A'
+
+ +
+
+WING_REF_CAPACITY_TERM_B = 'aircraft:fuel:wing_ref_capacity_term_B'
+
+ +
+
+WING_VOLUME_DESIGN = 'aircraft:fuel:wing_volume_design'
+
+ +
+
+WING_VOLUME_GEOMETRIC_MAX = 'aircraft:fuel:wing_volume_geometric_max'
+
+ +
+
+WING_VOLUME_STRUCTURAL_MAX = 'aircraft:fuel:wing_volume_structural_max'
+
+ +
+ +
+
+class Furnishings[source]
+

Bases: object

+
+
+MASS = 'aircraft:furnishings:mass'
+
+ +
+
+MASS_BASE = 'aircraft:furnishings:mass_base'
+
+ +
+
+MASS_SCALER = 'aircraft:furnishings:mass_scaler'
+
+ +
+ +
+
+class Fuselage[source]
+

Bases: object

+
+
+AISLE_WIDTH = 'aircraft:fuselage:aisle_width'
+
+ +
+
+AVG_DIAMETER = 'aircraft:fuselage:avg_diameter'
+
+ +
+
+CHARACTERISTIC_LENGTH = 'aircraft:fuselage:characteristic_length'
+
+ +
+
+CROSS_SECTION = 'aircraft:fuselage:cross_section'
+
+ +
+
+DELTA_DIAMETER = 'aircraft:fuselage:delta_diameter'
+
+ +
+
+DIAMETER_TO_WING_SPAN = 'aircraft:fuselage:diameter_to_wing_span'
+
+ +
+
+FINENESS = 'aircraft:fuselage:fineness'
+
+ +
+
+FLAT_PLATE_AREA_INCREMENT = 'aircraft:fuselage:flat_plate_area_increment'
+
+ +
+
+FORM_FACTOR = 'aircraft:fuselage:form_factor'
+
+ +
+
+LAMINAR_FLOW_LOWER = 'aircraft:fuselage:laminar_flow_lower'
+
+ +
+
+LAMINAR_FLOW_UPPER = 'aircraft:fuselage:laminar_flow_upper'
+
+ +
+
+LENGTH = 'aircraft:fuselage:length'
+
+ +
+
+LENGTH_TO_DIAMETER = 'aircraft:fuselage:length_to_diameter'
+
+ +
+
+MASS = 'aircraft:fuselage:mass'
+
+ +
+
+MASS_COEFFICIENT = 'aircraft:fuselage:mass_coefficient'
+
+ +
+
+MASS_SCALER = 'aircraft:fuselage:mass_scaler'
+
+ +
+
+MAX_HEIGHT = 'aircraft:fuselage:max_height'
+
+ +
+
+MAX_WIDTH = 'aircraft:fuselage:max_width'
+
+ +
+
+MILITARY_CARGO_FLOOR = 'aircraft:fuselage:military_cargo_floor'
+
+ +
+
+NOSE_FINENESS = 'aircraft:fuselage:nose_fineness'
+
+ +
+
+NUM_AISLES = 'aircraft:fuselage:num_aisles'
+
+ +
+
+NUM_FUSELAGES = 'aircraft:fuselage:num_fuselages'
+
+ +
+
+NUM_SEATS_ABREAST = 'aircraft:fuselage:num_seats_abreast'
+
+ +
+
+PASSENGER_COMPARTMENT_LENGTH = 'aircraft:fuselage:passenger_compartment_length'
+
+ +
+
+PILOT_COMPARTMENT_LENGTH = 'aircraft:fuselage:pilot_compartment_length'
+
+ +
+
+PLANFORM_AREA = 'aircraft:fuselage:planform_area'
+
+ +
+
+PRESSURE_DIFFERENTIAL = 'aircraft:fuselage:pressure_differential'
+
+ +
+
+PROVIDE_SURFACE_AREA = 'aircraft:fuselage:provide_surface_area'
+
+ +
+
+SEAT_PITCH = 'aircraft:fuselage:seat_pitch'
+
+ +
+
+SEAT_WIDTH = 'aircraft:fuselage:seat_width'
+
+ +
+
+TAIL_FINENESS = 'aircraft:fuselage:tail_fineness'
+
+ +
+
+WETTED_AREA = 'aircraft:fuselage:wetted_area'
+
+ +
+
+WETTED_AREA_FACTOR = 'aircraft:fuselage:wetted_area_factor'
+
+ +
+
+WETTED_AREA_SCALER = 'aircraft:fuselage:wetted_area_scaler'
+
+ +
+ +
+
+class HorizontalTail[source]
+

Bases: object

+
+
+AREA = 'aircraft:horizontal_tail:area'
+
+ +
+
+ASPECT_RATIO = 'aircraft:horizontal_tail:aspect_ratio'
+
+ +
+
+AVERAGE_CHORD = 'aircraft:horizontal_tail:average_chord'
+
+ +
+
+CHARACTERISTIC_LENGTH = 'aircraft:horizontal_tail:characteristic_length'
+
+ +
+
+FINENESS = 'aircraft:horizontal_tail:fineness'
+
+ +
+
+FORM_FACTOR = 'aircraft:horizontal_tail:form_factor'
+
+ +
+
+LAMINAR_FLOW_LOWER = 'aircraft:horizontal_tail:laminar_flow_lower'
+
+ +
+
+LAMINAR_FLOW_UPPER = 'aircraft:horizontal_tail:laminar_flow_upper'
+
+ +
+
+MASS = 'aircraft:horizontal_tail:mass'
+
+ +
+
+MASS_COEFFICIENT = 'aircraft:horizontal_tail:mass_coefficient'
+
+ +
+
+MASS_SCALER = 'aircraft:horizontal_tail:mass_scaler'
+
+ +
+
+MOMENT_ARM = 'aircraft:horizontal_tail:moment_arm'
+
+ +
+
+MOMENT_RATIO = 'aircraft:horizontal_tail:moment_ratio'
+
+ +
+
+ROOT_CHORD = 'aircraft:horizontal_tail:root_chord'
+
+ +
+
+SPAN = 'aircraft:horizontal_tail:span'
+
+ +
+
+SWEEP = 'aircraft:horizontal_tail:sweep'
+
+ +
+
+TAPER_RATIO = 'aircraft:horizontal_tail:taper_ratio'
+
+ +
+
+THICKNESS_TO_CHORD = 'aircraft:horizontal_tail:thickness_to_chord'
+
+ +
+
+VERTICAL_TAIL_FRACTION = 'aircraft:horizontal_tail:vertical_tail_fraction'
+
+ +
+
+VOLUME_COEFFICIENT = 'aircraft:horizontal_tail:volume_coefficient'
+
+ +
+
+WETTED_AREA = 'aircraft:horizontal_tail:wetted_area'
+
+ +
+
+WETTED_AREA_SCALER = 'aircraft:horizontal_tail:wetted_area_scaler'
+
+ +
+ +
+
+class Hydraulics[source]
+

Bases: object

+
+
+MASS = 'aircraft:hydraulics:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:hydraulics:mass_scaler'
+
+ +
+
+SYSTEM_PRESSURE = 'aircraft:hydraulics:system_pressure'
+
+ +
+ +
+
+class Instruments[source]
+

Bases: object

+
+
+MASS = 'aircraft:instruments:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:instruments:mass_scaler'
+
+ +
+ +
+
+class LandingGear[source]
+

Bases: object

+
+
+CARRIER_BASED = 'aircraft:landing_gear:carrier_based'
+
+ +
+
+DRAG_COEFFICIENT = 'aircraft:landing_gear:drag_coefficient'
+
+ +
+
+FIXED_GEAR = 'aircraft:landing_gear:fixed_gear'
+
+ +
+
+MAIN_GEAR_LOCATION = 'aircraft:landing_gear:main_gear_location'
+
+ +
+
+MAIN_GEAR_MASS = 'aircraft:landing_gear:main_gear_mass'
+
+ +
+
+MAIN_GEAR_MASS_COEFFICIENT = 'aircraft:landing_gear:main_gear_mass_coefficient'
+
+ +
+
+MAIN_GEAR_MASS_SCALER = 'aircraft:landing_gear:main_gear_mass_scaler'
+
+ +
+
+MAIN_GEAR_OLEO_LENGTH = 'aircraft:landing_gear:main_gear_oleo_length'
+
+ +
+
+MASS_COEFFICIENT = 'aircraft:landing_gear:mass_coefficient'
+
+ +
+
+NOSE_GEAR_MASS = 'aircraft:landing_gear:nose_gear_mass'
+
+ +
+
+NOSE_GEAR_MASS_SCALER = 'aircraft:landing_gear:nose_gear_mass_scaler'
+
+ +
+
+NOSE_GEAR_OLEO_LENGTH = 'aircraft:landing_gear:nose_gear_oleo_length'
+
+ +
+
+TAIL_HOOK_MASS_SCALER = 'aircraft:landing_gear:tail_hook_mass_scaler'
+
+ +
+
+TOTAL_MASS = 'aircraft:landing_gear:total_mass'
+
+ +
+
+TOTAL_MASS_SCALER = 'aircraft:landing_gear:total_mass_scaler'
+
+ +
+ +
+
+class Nacelle[source]
+

Bases: object

+
+
+AVG_DIAMETER = 'aircraft:nacelle:avg_diameter'
+
+ +
+
+AVG_LENGTH = 'aircraft:nacelle:avg_length'
+
+ +
+
+CHARACTERISTIC_LENGTH = 'aircraft:nacelle:characteristic_length'
+
+ +
+
+CLEARANCE_RATIO = 'aircraft:nacelle:clearance_ratio'
+
+ +
+
+CORE_DIAMETER_RATIO = 'aircraft:nacelle:core_diameter_ratio'
+
+ +
+
+FINENESS = 'aircraft:nacelle:fineness'
+
+ +
+
+FORM_FACTOR = 'aircraft:nacelle:form_factor'
+
+ +
+
+LAMINAR_FLOW_LOWER = 'aircraft:nacelle:laminar_flow_lower'
+
+ +
+
+LAMINAR_FLOW_UPPER = 'aircraft:nacelle:laminar_flow_upper'
+
+ +
+
+MASS = 'aircraft:nacelle:mass'
+
+ +
+
+MASS_SCALER = 'aircraft:nacelle:mass_scaler'
+
+ +
+
+MASS_SPECIFIC = 'aircraft:nacelle:mass_specific'
+
+ +
+
+SURFACE_AREA = 'aircraft:nacelle:surface_area'
+
+ +
+
+TOTAL_WETTED_AREA = 'aircraft:nacelle:total_wetted_area'
+
+ +
+
+WETTED_AREA = 'aircraft:nacelle:wetted_area'
+
+ +
+
+WETTED_AREA_SCALER = 'aircraft:nacelle:wetted_area_scaler'
+
+ +
+ +
+
+class Paint[source]
+

Bases: object

+
+
+MASS = 'aircraft:paint:mass'
+
+ +
+
+MASS_PER_UNIT_AREA = 'aircraft:paint:mass_per_unit_area'
+
+ +
+ +
+
+class Propulsion[source]
+

Bases: object

+
+
+ENGINE_OIL_MASS_SCALER = 'aircraft:propulsion:engine_oil_mass_scaler'
+
+ +
+
+MASS = 'aircraft:propulsion:mass'
+
+ +
+
+MISC_MASS_SCALER = 'aircraft:propulsion:misc_mass_scaler'
+
+ +
+
+TOTAL_ENGINE_CONTROLS_MASS = 'aircraft:propulsion:total_engine_controls_mass'
+
+ +
+
+TOTAL_ENGINE_MASS = 'aircraft:propulsion:total_engine_mass'
+
+ +
+
+TOTAL_ENGINE_OIL_MASS = 'aircraft:propulsion:total_engine_oil_mass'
+
+ +
+
+TOTAL_ENGINE_POD_MASS = 'aircraft:propulsion:total_engine_pod_mass'
+
+ +
+
+TOTAL_MISC_MASS = 'aircraft:propulsion:total_misc_mass'
+
+ +
+
+TOTAL_NUM_ENGINES = 'aircraft:propulsion:total_num_engines'
+
+ +
+
+TOTAL_NUM_FUSELAGE_ENGINES = 'aircraft:propulsion:total_num_fuselage_engines'
+
+ +
+
+TOTAL_NUM_WING_ENGINES = 'aircraft:propulsion:total_num_wing_engines'
+
+ +
+
+TOTAL_REFERENCE_SLS_THRUST = 'aircraft:propulsion:total_reference_sls_thrust'
+
+ +
+
+TOTAL_SCALED_SLS_THRUST = 'aircraft:propulsion:total_scaled_sls_thrust'
+
+ +
+
+TOTAL_STARTER_MASS = 'aircraft:propulsion:total_starter_mass'
+
+ +
+
+TOTAL_THRUST_REVERSERS_MASS = 'aircraft:propulsion:total_thrust_reversers_mass'
+
+ +
+ +
+
+class Strut[source]
+

Bases: object

+
+
+AREA = 'aircraft:strut:area'
+
+ +
+
+AREA_RATIO = 'aircraft:strut:area_ratio'
+
+ +
+
+ATTACHMENT_LOCATION = 'aircraft:strut:attachment_location'
+
+ +
+
+ATTACHMENT_LOCATION_DIMENSIONLESS = 'aircraft:strut:attachment_location_dimensionless'
+
+ +
+
+CHORD = 'aircraft:strut:chord'
+
+ +
+
+DIMENSIONAL_LOCATION_SPECIFIED = 'aircraft:strut:dimensional_location_specified'
+
+ +
+
+FUSELAGE_INTERFERENCE_FACTOR = 'aircraft:strut:fuselage_interference_factor'
+
+ +
+
+LENGTH = 'aircraft:strut:length'
+
+ +
+
+MASS = 'aircraft:strut:mass'
+
+ +
+
+MASS_COEFFICIENT = 'aircraft:strut:mass_coefficient'
+
+ +
+
+THICKNESS_TO_CHORD = 'aircraft:strut:thickness_to_chord'
+
+ +
+ +
+
+class TailBoom[source]
+

Bases: object

+
+
+LENGTH = 'aircraft:tail_boom:length'
+
+ +
+ +
+
+class VerticalTail[source]
+

Bases: object

+
+
+AREA = 'aircraft:vertical_tail:area'
+
+ +
+
+ASPECT_RATIO = 'aircraft:vertical_tail:aspect_ratio'
+
+ +
+
+AVERAGE_CHORD = 'aircraft:vertical_tail:average_chord'
+
+ +
+
+CHARACTERISTIC_LENGTH = 'aircraft:vertical_tail:characteristic_length'
+
+ +
+
+FINENESS = 'aircraft:vertical_tail:fineness'
+
+ +
+
+FORM_FACTOR = 'aircraft:vertical_tail:form_factor'
+
+ +
+
+LAMINAR_FLOW_LOWER = 'aircraft:vertical_tail:laminar_flow_lower'
+
+ +
+
+LAMINAR_FLOW_UPPER = 'aircraft:vertical_tail:laminar_flow_upper'
+
+ +
+
+MASS = 'aircraft:vertical_tail:mass'
+
+ +
+
+MASS_COEFFICIENT = 'aircraft:vertical_tail:mass_coefficient'
+
+ +
+
+MASS_SCALER = 'aircraft:vertical_tail:mass_scaler'
+
+ +
+
+MOMENT_ARM = 'aircraft:vertical_tail:moment_arm'
+
+ +
+
+MOMENT_RATIO = 'aircraft:vertical_tail:moment_ratio'
+
+ +
+
+NUM_TAILS = 'aircraft:vertical_tail:num_tails'
+
+ +
+
+ROOT_CHORD = 'aircraft:vertical_tail:root_chord'
+
+ +
+
+SPAN = 'aircraft:vertical_tail:span'
+
+ +
+
+SWEEP = 'aircraft:vertical_tail:sweep'
+
+ +
+
+TAPER_RATIO = 'aircraft:vertical_tail:taper_ratio'
+
+ +
+
+THICKNESS_TO_CHORD = 'aircraft:vertical_tail:thickness_to_chord'
+
+ +
+
+VOLUME_COEFFICIENT = 'aircraft:vertical_tail:volume_coefficient'
+
+ +
+
+WETTED_AREA = 'aircraft:vertical_tail:wetted_area'
+
+ +
+
+WETTED_AREA_SCALER = 'aircraft:vertical_tail:wetted_area_scaler'
+
+ +
+ +
+
+class Wing[source]
+

Bases: object

+
+
+AEROELASTIC_TAILORING_FACTOR = 'aircraft:wing:aeroelastic_tailoring_factor'
+
+ +
+
+AIRFOIL_TECHNOLOGY = 'aircraft:wing:airfoil_technology'
+
+ +
+
+AREA = 'aircraft:wing:area'
+
+ +
+
+ASPECT_RATIO = 'aircraft:wing:aspect_ratio'
+
+ +
+
+ASPECT_RATIO_REF = 'aircraft:wing:aspect_ratio_reference'
+
+ +
+
+AVERAGE_CHORD = 'aircraft:wing:average_chord'
+
+ +
+
+BENDING_FACTOR = 'aircraft:wing:bending_factor'
+
+ +
+
+BENDING_MASS = 'aircraft:wing:bending_mass'
+
+ +
+
+BENDING_MASS_NO_INERTIA = 'aircraft:wing:bending_mass_no_inertia'
+
+ +
+
+BENDING_MASS_SCALER = 'aircraft:wing:bending_mass_scaler'
+
+ +
+
+BWB_AFTBODY_MASS = 'aircraft:wing:bwb_aft_body_mass'
+
+ +
+
+BWB_AFTBODY_MASS_SCALER = 'aircraft:wing:bwb_aft_body_mass_scaler'
+
+ +
+
+CENTER_CHORD = 'aircraft:wing:center_chord'
+
+ +
+
+CENTER_DISTANCE = 'aircraft:wing:center_distance'
+
+ +
+
+CHARACTERISTIC_LENGTH = 'aircraft:wing:characteristic_length'
+
+ +
+
+CHOOSE_FOLD_LOCATION = 'aircraft:wing:choose_fold_location'
+
+ +
+
+CHORD_PER_SEMISPAN_DIST = 'aircraft:wing:chord_per_semispan'
+
+ +
+
+COMPOSITE_FRACTION = 'aircraft:wing:composite_fraction'
+
+ +
+
+CONTROL_SURFACE_AREA = 'aircraft:wing:control_surface_area'
+
+ +
+
+CONTROL_SURFACE_AREA_RATIO = 'aircraft:wing:control_surface_area_ratio'
+
+ +
+
+DETAILED_WING = 'aircraft:wing:detailed_wing'
+
+ +
+
+DIHEDRAL = 'aircraft:wing:dihedral'
+
+ +
+
+ENG_POD_INERTIA_FACTOR = 'aircraft:wing:eng_pod_inertia_factor'
+
+ +
+
+FINENESS = 'aircraft:wing:fineness'
+
+ +
+
+FLAP_CHORD_RATIO = 'aircraft:wing:flap_chord_ratio'
+
+ +
+
+FLAP_DEFLECTION_LANDING = 'aircraft:wing:flap_deflection_landing'
+
+ +
+
+FLAP_DEFLECTION_TAKEOFF = 'aircraft:wing:flap_deflection_takeoff'
+
+ +
+
+FLAP_DRAG_INCREMENT_OPTIMUM = 'aircraft:wing:flap_drag_increment_optimum'
+
+ +
+
+FLAP_LIFT_INCREMENT_OPTIMUM = 'aircraft:wing:flap_lift_increment_optimum'
+
+ +
+
+FLAP_SPAN_RATIO = 'aircraft:wing:flap_span_ratio'
+
+ +
+
+FLAP_TYPE = 'aircraft:wing:flap_type'
+
+ +
+
+FOLDED_SPAN = 'aircraft:wing:folded_span'
+
+ +
+
+FOLDED_SPAN_DIMENSIONLESS = 'aircraft:wing:folded_span_dimensionless'
+
+ +
+
+FOLDING_AREA = 'aircraft:wing:folding_area'
+
+ +
+
+FOLD_DIMENSIONAL_LOCATION_SPECIFIED = 'aircraft:wing:fold_dimensional_location_specified'
+
+ +
+
+FOLD_MASS = 'aircraft:wing:fold_mass'
+
+ +
+
+FOLD_MASS_COEFFICIENT = 'aircraft:wing:fold_mass_coefficient'
+
+ +
+
+FORM_FACTOR = 'aircraft:wing:form_factor'
+
+ +
+
+FUSELAGE_INTERFERENCE_FACTOR = 'aircraft:wing:fuselage_interference_factor'
+
+ +
+
+GLOVE_AND_BAT = 'aircraft:wing:glove_and_bat'
+
+ +
+
+HAS_FOLD = 'aircraft:wing:has_fold'
+
+ +
+
+HAS_STRUT = 'aircraft:wing:has_strut'
+
+ +
+
+HEIGHT = 'aircraft:wing:height'
+
+ +
+
+HIGH_LIFT_MASS = 'aircraft:wing:high_lift_mass'
+
+ +
+
+HIGH_LIFT_MASS_COEFFICIENT = 'aircraft:wing:high_lift_mass_coefficient'
+
+ +
+
+INCIDENCE = 'aircraft:wing:incidence'
+
+ +
+
+INPUT_STATION_DIST = 'aircraft:wing:input_station_dist'
+
+ +
+
+LAMINAR_FLOW_LOWER = 'aircraft:wing:laminar_flow_lower'
+
+ +
+
+LAMINAR_FLOW_UPPER = 'aircraft:wing:laminar_flow_upper'
+
+ +
+
+LEADING_EDGE_SWEEP = 'aircraft:wing:leading_edge_sweep'
+
+ +
+
+LOADING = 'aircraft:wing:loading'
+
+ +
+
+LOADING_ABOVE_20 = 'aircraft:wing:loading_above_20'
+
+ +
+
+LOAD_DISTRIBUTION_CONTROL = 'aircraft:wing:load_distribution_control'
+
+ +
+
+LOAD_FRACTION = 'aircraft:wing:load_fraction'
+
+ +
+
+LOAD_PATH_SWEEP_DIST = 'aircraft:wing:load_path_sweep_dist'
+
+ +
+
+MASS = 'aircraft:wing:mass'
+
+ +
+
+MASS_COEFFICIENT = 'aircraft:wing:mass_coefficient'
+
+ +
+
+MASS_SCALER = 'aircraft:wing:mass_scaler'
+
+ +
+
+MATERIAL_FACTOR = 'aircraft:wing:material_factor'
+
+ +
+
+MAX_CAMBER_AT_70_SEMISPAN = 'aircraft:wing:max_camber_at_70_semispan'
+
+ +
+
+MAX_LIFT_REF = 'aircraft:wing:max_lift_ref'
+
+ +
+
+MAX_SLAT_DEFLECTION_LANDING = 'aircraft:wing:max_slat_deflection_landing'
+
+ +
+
+MAX_SLAT_DEFLECTION_TAKEOFF = 'aircraft:wing:max_slat_deflection_takeoff'
+
+ +
+
+MAX_THICKNESS_LOCATION = 'aircraft:wing:max_thickness_location'
+
+ +
+
+MIN_PRESSURE_LOCATION = 'aircraft:wing:min_pressure_location'
+
+ +
+
+MISC_MASS = 'aircraft:wing:misc_mass'
+
+ +
+
+MISC_MASS_SCALER = 'aircraft:wing:misc_mass_scaler'
+
+ +
+
+MOUNTING_TYPE = 'aircraft:wing:mounting_type'
+
+ +
+
+NUM_FLAP_SEGMENTS = 'aircraft:wing:num_flap_segments'
+
+ +
+
+NUM_INTEGRATION_STATIONS = 'aircraft:wing:num_integration_stations'
+
+ +
+
+OPTIMUM_FLAP_DEFLECTION = 'aircraft:wing:optimum_flap_deflection'
+
+ +
+
+OPTIMUM_SLAT_DEFLECTION = 'aircraft:wing:optimum_slat_deflection'
+
+ +
+
+ROOT_CHORD = 'aircraft:wing:root_chord'
+
+ +
+
+SHEAR_CONTROL_MASS = 'aircraft:wing:shear_control_mass'
+
+ +
+
+SHEAR_CONTROL_MASS_SCALER = 'aircraft:wing:shear_control_mass_scaler'
+
+ +
+
+SLAT_CHORD_RATIO = 'aircraft:wing:slat_chord_ratio'
+
+ +
+
+SLAT_LIFT_INCREMENT_OPTIMUM = 'aircraft:wing:slat_lift_increment_optimum'
+
+ +
+
+SLAT_SPAN_RATIO = 'aircraft:wing:slat_span_ratio'
+
+ +
+
+SPAN = 'aircraft:wing:span'
+
+ +
+
+SPAN_EFFICIENCY_FACTOR = 'aircraft:wing:span_efficiency_factor'
+
+ +
+
+SPAN_EFFICIENCY_REDUCTION = 'aircraft:wing:span_efficiency_reduction'
+
+ +
+
+STRUT_BRACING_FACTOR = 'aircraft:wing:strut_bracing_factor'
+
+ +
+
+SURFACE_CONTROL_MASS = 'aircraft:wing:surface_ctrl_mass'
+
+ +
+
+SURFACE_CONTROL_MASS_COEFFICIENT = 'aircraft:wing:surface_ctrl_mass_coefficient'
+
+ +
+
+SURFACE_CONTROL_MASS_SCALER = 'aircraft:wing:surface_ctrl_mass_scaler'
+
+ +
+
+SWEEP = 'aircraft:wing:sweep'
+
+ +
+
+TAPER_RATIO = 'aircraft:wing:taper_ratio'
+
+ +
+
+THICKNESS_TO_CHORD = 'aircraft:wing:thickness_to_chord'
+
+ +
+
+THICKNESS_TO_CHORD_DIST = 'aircraft:wing:thickness_to_chord_dist'
+
+ +
+
+THICKNESS_TO_CHORD_REF = 'aircraft:wing:thickness_to_chord_reference'
+
+ +
+
+THICKNESS_TO_CHORD_ROOT = 'aircraft:wing:thickness_to_chord_root'
+
+ +
+
+THICKNESS_TO_CHORD_TIP = 'aircraft:wing:thickness_to_chord_tip'
+
+ +
+
+THICKNESS_TO_CHORD_UNWEIGHTED = 'aircraft:wing:thickness_to_chord_unweighted'
+
+ +
+
+ULTIMATE_LOAD_FACTOR = 'aircraft:wing:ultimate_load_factor'
+
+ +
+
+VAR_SWEEP_MASS_PENALTY = 'aircraft:wing:var_sweep_mass_penalty'
+
+ +
+
+WETTED_AREA = 'aircraft:wing:wetted_area'
+
+ +
+
+WETTED_AREA_SCALER = 'aircraft:wing:wetted_area_scaler'
+
+ +
+
+ZERO_LIFT_ANGLE = 'aircraft:wing:zero_lift_angle'
+
+ +
+ +
+ +
+
+class aviary.variable_info.variables.Dynamic[source]
+

Bases: object

+
+
+class Mission[source]
+

Bases: object

+
+
+ALTITUDE = 'altitude'
+
+ +
+
+ALTITUDE_RATE = 'altitude_rate'
+
+ +
+
+ALTITUDE_RATE_MAX = 'altitude_rate_max'
+
+ +
+
+DENSITY = 'density'
+
+ +
+
+DISTANCE = 'distance'
+
+ +
+
+DISTANCE_RATE = 'distance_rate'
+
+ +
+
+DRAG = 'drag'
+
+ +
+
+DYNAMIC_PRESSURE = 'dynamic_pressure'
+
+ +
+
+ELECTRIC_POWER = 'electric_power'
+
+ +
+
+ELECTRIC_POWER_TOTAL = 'electric_power_total'
+
+ +
+
+FLIGHT_PATH_ANGLE = 'flight_path_angle'
+
+ +
+
+FLIGHT_PATH_ANGLE_RATE = 'flight_path_angle_rate'
+
+ +
+
+FUEL_FLOW_RATE = 'fuel_flow_rate'
+
+ +
+
+FUEL_FLOW_RATE_NEGATIVE = 'fuel_flow_rate_negative'
+
+ +
+
+FUEL_FLOW_RATE_NEGATIVE_TOTAL = 'fuel_flow_rate_negative_total'
+
+ +
+
+FUEL_FLOW_RATE_TOTAL = 'fuel_flow_rate_total'
+
+ +
+
+HYBRID_THROTTLE = 'hybrid_throttle'
+
+ +
+
+LIFT = 'lift'
+
+ +
+
+MACH = 'mach'
+
+ +
+
+MACH_RATE = 'mach_rate'
+
+ +
+
+MASS = 'mass'
+
+ +
+
+MASS_RATE = 'mass_rate'
+
+ +
+
+NOX_RATE = 'nox_rate'
+
+ +
+
+NOX_RATE_TOTAL = 'nox_rate_total'
+
+ +
+
+RANGE = 'range'
+
+ +
+
+RANGE_RATE = 'range_rate'
+
+ +
+
+SPECIFIC_ENERGY = 'specific_energy'
+
+ +
+
+SPECIFIC_ENERGY_RATE = 'specific_energy_rate'
+
+ +
+
+SPECIFIC_ENERGY_RATE_EXCESS = 'specific_energy_rate_excess'
+
+ +
+
+SPEED_OF_SOUND = 'speed_of_sound'
+
+ +
+
+STATIC_PRESSURE = 'static_pressure'
+
+ +
+
+TEMPERATURE = 'temperature'
+
+ +
+
+TEMPERATURE_ENGINE_T4 = 't4'
+
+ +
+
+THROTTLE = 'throttle'
+
+ +
+
+THRUST = 'thrust_net'
+
+ +
+
+THRUST_MAX = 'thrust_net_max'
+
+ +
+
+THRUST_MAX_TOTAL = 'thrust_net_max_total'
+
+ +
+
+THRUST_TOTAL = 'thrust_net_total'
+
+ +
+
+VELOCITY = 'velocity'
+
+ +
+
+VELOCITY_RATE = 'velocity_rate'
+
+ +
+ +
+ +
+
+class aviary.variable_info.variables.Mission[source]
+

Bases: object

+
+
+class Constraints[source]
+

Bases: object

+
+
+MASS_RESIDUAL = 'mission:constraints:mass_residual'
+
+ +
+
+MAX_MACH = 'mission:constraints:max_mach'
+
+ +
+
+RANGE_RESIDUAL = 'mission:constraints:range_residual'
+
+ +
+ +
+
+class Design[source]
+

Bases: object

+
+
+CRUISE_ALTITUDE = 'mission:design:cruise_altitude'
+
+ +
+
+CRUISE_RANGE = 'mission:design:cruise_range'
+
+ +
+
+FUEL_MASS = 'mission:design:fuel_mass'
+
+ +
+
+FUEL_MASS_REQUIRED = 'mission:design:fuel_mass_required'
+
+ +
+
+GROSS_MASS = 'mission:design:gross_mass'
+
+ +
+
+LIFT_COEFFICIENT = 'mission:design:lift_coefficient'
+
+ +
+
+LIFT_COEFFICIENT_MAX_FLAPS_UP = 'mission:design:lift_coefficient_max_flaps_up'
+
+ +
+
+MACH = 'mission:design:mach'
+
+ +
+
+RANGE = 'mission:design:range'
+
+ +
+
+RATE_OF_CLIMB_AT_TOP_OF_CLIMB = 'mission:design:rate_of_climb_at_top_of_climb'
+
+ +
+
+RESERVE_FUEL = 'mission:design:reserve_fuel'
+
+ +
+
+THRUST_TAKEOFF_PER_ENG = 'mission:design:thrust_takeoff_per_eng'
+
+ +
+ +
+
+class Landing[source]
+

Bases: object

+
+
+AIRPORT_ALTITUDE = 'mission:landing:airport_altitude'
+
+ +
+
+BRAKING_DELAY = 'mission:landing:braking_delay'
+
+ +
+
+BRAKING_FRICTION_COEFFICIENT = 'mission:landing:braking_friction_coefficient'
+
+ +
+
+DRAG_COEFFICIENT = 'mission:landing:drag_coefficient'
+
+ +
+
+DRAG_COEFFICIENT_FLAP_INCREMENT = 'mission:landing:drag_coefficient_flap_increment'
+
+ +
+
+FIELD_LENGTH = 'mission:landing:field_length'
+
+ +
+
+FLARE_RATE = 'mission:landing:flare_rate'
+
+ +
+
+GLIDE_TO_STALL_RATIO = 'mission:landing:glide_to_stall_ratio'
+
+ +
+
+GROUND_DISTANCE = 'mission:landing:ground_distance'
+
+ +
+
+INITIAL_ALTITUDE = 'mission:landing:initial_altitude'
+
+ +
+
+INITIAL_MACH = 'mission:landing:initial_mach'
+
+ +
+
+INITIAL_VELOCITY = 'mission:landing:initial_velocity'
+
+ +
+
+LIFT_COEFFICIENT_FLAP_INCREMENT = 'mission:landing:lift_coefficient_flap_increment'
+
+ +
+
+LIFT_COEFFICIENT_MAX = 'mission:landing:lift_coefficient_max'
+
+ +
+
+MAXIMUM_FLARE_LOAD_FACTOR = 'mission:landing:maximum_flare_load_factor'
+
+ +
+
+MAXIMUM_SINK_RATE = 'mission:landing:maximum_sink_rate'
+
+ +
+
+OBSTACLE_HEIGHT = 'mission:landing:obstacle_height'
+
+ +
+
+ROLLING_FRICTION_COEFFICIENT = 'mission:landing:rolling_friction_coefficient'
+
+ +
+
+SPOILER_DRAG_COEFFICIENT = 'mission:landing:spoiler_drag_coefficient'
+
+ +
+
+SPOILER_LIFT_COEFFICIENT = 'mission:landing:spoiler_lift_coefficient'
+
+ +
+
+STALL_VELOCITY = 'mission:landing:stall_velocity'
+
+ +
+
+TOUCHDOWN_MASS = 'mission:landing:touchdown_mass'
+
+ +
+
+TOUCHDOWN_SINK_RATE = 'mission:landing:touchdown_sink_rate'
+
+ +
+ +
+
+class Objectives[source]
+

Bases: object

+
+
+FUEL = 'mission:objectives:fuel'
+
+ +
+
+RANGE = 'mission:objectives:range'
+
+ +
+ +
+
+class Summary[source]
+

Bases: object

+
+
+CRUISE_MACH = 'mission:summary:cruise_mach'
+
+ +
+
+CRUISE_MASS_FINAL = 'mission:summary:cruise_mass_final'
+
+ +
+
+FUEL_FLOW_SCALER = 'mission:summary:fuel_flow_scaler'
+
+ +
+
+GROSS_MASS = 'mission:summary:gross_mass'
+
+ +
+
+RANGE = 'mission:summary:range'
+
+ +
+
+TOTAL_FUEL_MASS = 'mission:summary:total_fuel_mass'
+
+ +
+ +
+
+class Takeoff[source]
+

Bases: object

+
+
+AIRPORT_ALTITUDE = 'mission:takeoff:airport_altitude'
+
+ +
+
+ANGLE_OF_ATTACK_RUNWAY = 'mission:takeoff:angle_of_attack_runway'
+
+ +
+
+ASCENT_DURATION = 'mission:takeoff:ascent_duration'
+
+ +
+
+ASCENT_T_INTIIAL = 'mission:takeoff:ascent_t_initial'
+
+ +
+
+BRAKING_FRICTION_COEFFICIENT = 'mission:takeoff:braking_friction_coefficient'
+
+ +
+
+DECISION_SPEED_INCREMENT = 'mission:takeoff:decision_speed_increment'
+
+ +
+
+DRAG_COEFFICIENT_FLAP_INCREMENT = 'mission:takeoff:drag_coefficient_flap_increment'
+
+ +
+
+DRAG_COEFFICIENT_MIN = 'mission:takeoff:drag_coefficient_min'
+
+ +
+
+FIELD_LENGTH = 'mission:takeoff:field_length'
+
+ +
+
+FINAL_ALTITUDE = 'mission:takeoff:final_altitude'
+
+ +
+
+FINAL_MASS = 'mission:takeoff:final_mass'
+
+ +
+
+FINAL_VELOCITY = 'mission:takeoff:final_velocity'
+
+ +
+
+FUEL_SIMPLE = 'mission:takeoff:fuel_simple'
+
+ +
+
+GROUND_DISTANCE = 'mission:takeoff:ground_distance'
+
+ +
+
+LIFT_COEFFICIENT_FLAP_INCREMENT = 'mission:takeoff:lift_coefficient_flap_increment'
+
+ +
+
+LIFT_COEFFICIENT_MAX = 'mission:takeoff:lift_coefficient_max'
+
+ +
+
+LIFT_OVER_DRAG = 'mission:takeoff:lift_over_drag'
+
+ +
+
+OBSTACLE_HEIGHT = 'mission:takeoff:obstacle_height'
+
+ +
+
+ROLLING_FRICTION_COEFFICIENT = 'mission:takeoff:rolling_friction_coefficient'
+
+ +
+
+ROTATION_SPEED_INCREMENT = 'mission:takeoff:rotation_speed_increment'
+
+ +
+
+ROTATION_VELOCITY = 'mission:takeoff:rotation_velocity'
+
+ +
+
+SPOILER_DRAG_COEFFICIENT = 'mission:takeoff:spoiler_drag_coefficient'
+
+ +
+
+SPOILER_LIFT_COEFFICIENT = 'mission:takeoff:spoiler_lift_coefficient'
+
+ +
+
+THRUST_INCIDENCE = 'mission:takeoff:thrust_incidence'
+
+ +
+ +
+
+class Taxi[source]
+

Bases: object

+
+
+DURATION = 'mission:taxi:duration'
+
+ +
+
+MACH = 'mission:taxi:mach'
+
+ +
+ +
+ +
+
+class aviary.variable_info.variables.Settings[source]
+

Bases: object

+
+
+EQUATIONS_OF_MOTION = 'settings:equations_of_motion'
+
+ +
+
+MASS_METHOD = 'settings:mass_method'
+
+ +
+
+VERBOSITY = 'settings:verbosity'
+
+ +
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_srcdocs/packages/variable_info/variables_in.html b/_srcdocs/packages/variable_info/variables_in.html new file mode 100644 index 000000000..b341cb690 --- /dev/null +++ b/_srcdocs/packages/variable_info/variables_in.html @@ -0,0 +1,588 @@ + + + + + + + + + + + + variables_in.py + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + +
+
+
+
+ + + Ctrl+K +
+
+ +
+ +
+
+ +
+ +
+
+ + + + + +
+ + + +
+ + + + +
+ +
+
+ + + +
+
+
+ + +
+
+ + + + +
+ +
+ + + +
+ +
+
+ +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + + + + +
+ + +
+ + + + + + +
+ + +
+ + + + + + + + + + + + + +
+ +
+ +
+
+ + + +
+

variables_in.py

+ +
+
+ +
+
+
+ + + + +
+ +
+

variables_in.py#

+
+

Dummy explicit component which serves as an input port for all variables in +the aircraft and mission hierarchy.

+
+
+class aviary.variable_info.variables_in.VariablesIn(**kwargs)[source]
+

Bases: ExplicitComponent

+

Provides a central place to connect input variable information to a component +but doesn’t actually do anything on its own.

+
+
+initialize()[source]
+

Perform any one-time initialization run at instantiation.

+
+ +
+
+setup()[source]
+

Declare inputs and outputs.

+
+
Available attributes:

name +pathname +comm +options

+
+
+
+ +
+ +
+
+ + + + +
+ + + + + + +
+ +
+
+
+ +
+ + + +
+ + +
+
+ +
+ +
+ +

+By Aviary team at NASA +

+ +
+ +
+ + +

+ + © Copyright 2023. +
+ +

+ +
+ +
+ +
+ +
+ +
+ +
+
+ + +
+
+
+ + + + + +
+
+ + \ No newline at end of file diff --git a/_static/_sphinx_javascript_frameworks_compat.js b/_static/_sphinx_javascript_frameworks_compat.js new file mode 100644 index 000000000..8549469dc --- /dev/null +++ b/_static/_sphinx_javascript_frameworks_compat.js @@ -0,0 +1,134 @@ +/* + * _sphinx_javascript_frameworks_compat.js + * ~~~~~~~~~~ + * + * Compatability shim for jQuery and underscores.js. + * + * WILL BE REMOVED IN Sphinx 6.0 + * xref RemovedInSphinx60Warning + * + */ + +/** + * select a different prefix for underscore + */ +$u = _.noConflict(); + + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} diff --git a/_static/aviary.png b/_static/aviary.png new file mode 100644 index 000000000..ac94faa6c Binary files /dev/null and b/_static/aviary.png differ diff --git a/_static/aviary_logo.png b/_static/aviary_logo.png new file mode 100644 index 000000000..caf94cc0d Binary files /dev/null and b/_static/aviary_logo.png differ diff --git a/_static/basic.css b/_static/basic.css new file mode 100644 index 000000000..9e364ed34 --- /dev/null +++ b/_static/basic.css @@ -0,0 +1,930 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 270px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 360px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} +nav.contents, +aside.topic, + +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ +nav.contents, +aside.topic, + +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +nav.contents > :last-child, +aside.topic > :last-child, + +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +nav.contents::after, +aside.topic::after, + +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +/* Docutils 0.17 and older (footnotes & citations) */ +dl.footnote > dt, +dl.citation > dt { + float: left; + margin-right: 0.5em; +} + +dl.footnote > dd, +dl.citation > dd { + margin-bottom: 0em; +} + +dl.footnote > dd:after, +dl.citation > dd:after { + content: ""; + clear: both; +} + +/* Docutils 0.18+ (footnotes & citations) */ +aside.footnote > span, +div.citation > span { + float: left; +} +aside.footnote > span:last-of-type, +div.citation > span:last-of-type { + padding-right: 0.5em; +} +aside.footnote > p { + margin-left: 2em; +} +div.citation > p { + margin-left: 4em; +} +aside.footnote > p:last-of-type, +div.citation > p:last-of-type { + margin-bottom: 0em; +} +aside.footnote > p:last-of-type:after, +div.citation > p:last-of-type:after { + content: ""; + clear: both; +} + +/* Footnotes & citations ends */ + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dt:after { + content: ":"; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; + white-space: nowrap; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/_static/check-solid.svg b/_static/check-solid.svg new file mode 100644 index 000000000..92fad4b5c --- /dev/null +++ b/_static/check-solid.svg @@ -0,0 +1,4 @@ + + + + diff --git a/_static/clipboard.min.js b/_static/clipboard.min.js new file mode 100644 index 000000000..54b3c4638 --- /dev/null +++ b/_static/clipboard.min.js @@ -0,0 +1,7 @@ +/*! + * clipboard.js v2.0.8 + * https://clipboardjs.com/ + * + * Licensed MIT © Zeno Rocha + */ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return n={686:function(t,e,n){"use strict";n.d(e,{default:function(){return o}});var e=n(279),i=n.n(e),e=n(370),u=n.n(e),e=n(817),c=n.n(e);function a(t){try{return document.execCommand(t)}catch(t){return}}var f=function(t){t=c()(t);return a("cut"),t};var l=function(t){var e,n,o,r=1 + + + + diff --git a/_static/copybutton.css b/_static/copybutton.css new file mode 100644 index 000000000..f1916ec7d --- /dev/null +++ b/_static/copybutton.css @@ -0,0 +1,94 @@ +/* Copy buttons */ +button.copybtn { + position: absolute; + display: flex; + top: .3em; + right: .3em; + width: 1.7em; + height: 1.7em; + opacity: 0; + transition: opacity 0.3s, border .3s, background-color .3s; + user-select: none; + padding: 0; + border: none; + outline: none; + border-radius: 0.4em; + /* The colors that GitHub uses */ + border: #1b1f2426 1px solid; + background-color: #f6f8fa; + color: #57606a; +} + +button.copybtn.success { + border-color: #22863a; + color: #22863a; +} + +button.copybtn svg { + stroke: currentColor; + width: 1.5em; + height: 1.5em; + padding: 0.1em; +} + +div.highlight { + position: relative; +} + +/* Show the copybutton */ +.highlight:hover button.copybtn, button.copybtn.success { + opacity: 1; +} + +.highlight button.copybtn:hover { + background-color: rgb(235, 235, 235); +} + +.highlight button.copybtn:active { + background-color: rgb(187, 187, 187); +} + +/** + * A minimal CSS-only tooltip copied from: + * https://codepen.io/mildrenben/pen/rVBrpK + * + * To use, write HTML like the following: + * + *

Short

+ */ + .o-tooltip--left { + position: relative; + } + + .o-tooltip--left:after { + opacity: 0; + visibility: hidden; + position: absolute; + content: attr(data-tooltip); + padding: .2em; + font-size: .8em; + left: -.2em; + background: grey; + color: white; + white-space: nowrap; + z-index: 2; + border-radius: 2px; + transform: translateX(-102%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); +} + +.o-tooltip--left:hover:after { + display: block; + opacity: 1; + visibility: visible; + transform: translateX(-100%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); + transition-delay: .5s; +} + +/* By default the copy button shouldn't show up when printing a page */ +@media print { + button.copybtn { + display: none; + } +} diff --git a/_static/copybutton.js b/_static/copybutton.js new file mode 100644 index 000000000..2ea7ff3e2 --- /dev/null +++ b/_static/copybutton.js @@ -0,0 +1,248 @@ +// Localization support +const messages = { + 'en': { + 'copy': 'Copy', + 'copy_to_clipboard': 'Copy to clipboard', + 'copy_success': 'Copied!', + 'copy_failure': 'Failed to copy', + }, + 'es' : { + 'copy': 'Copiar', + 'copy_to_clipboard': 'Copiar al portapapeles', + 'copy_success': '¡Copiado!', + 'copy_failure': 'Error al copiar', + }, + 'de' : { + 'copy': 'Kopieren', + 'copy_to_clipboard': 'In die Zwischenablage kopieren', + 'copy_success': 'Kopiert!', + 'copy_failure': 'Fehler beim Kopieren', + }, + 'fr' : { + 'copy': 'Copier', + 'copy_to_clipboard': 'Copier dans le presse-papier', + 'copy_success': 'Copié !', + 'copy_failure': 'Échec de la copie', + }, + 'ru': { + 'copy': 'Скопировать', + 'copy_to_clipboard': 'Скопировать в буфер', + 'copy_success': 'Скопировано!', + 'copy_failure': 'Не удалось скопировать', + }, + 'zh-CN': { + 'copy': '复制', + 'copy_to_clipboard': '复制到剪贴板', + 'copy_success': '复制成功!', + 'copy_failure': '复制失败', + }, + 'it' : { + 'copy': 'Copiare', + 'copy_to_clipboard': 'Copiato negli appunti', + 'copy_success': 'Copiato!', + 'copy_failure': 'Errore durante la copia', + } +} + +let locale = 'en' +if( document.documentElement.lang !== undefined + && messages[document.documentElement.lang] !== undefined ) { + locale = document.documentElement.lang +} + +let doc_url_root = DOCUMENTATION_OPTIONS.URL_ROOT; +if (doc_url_root == '#') { + doc_url_root = ''; +} + +/** + * SVG files for our copy buttons + */ +let iconCheck = ` + ${messages[locale]['copy_success']} + + +` + +// If the user specified their own SVG use that, otherwise use the default +let iconCopy = ``; +if (!iconCopy) { + iconCopy = ` + ${messages[locale]['copy_to_clipboard']} + + + +` +} + +/** + * Set up copy/paste for code blocks + */ + +const runWhenDOMLoaded = cb => { + if (document.readyState != 'loading') { + cb() + } else if (document.addEventListener) { + document.addEventListener('DOMContentLoaded', cb) + } else { + document.attachEvent('onreadystatechange', function() { + if (document.readyState == 'complete') cb() + }) + } +} + +const codeCellId = index => `codecell${index}` + +// Clears selected text since ClipboardJS will select the text when copying +const clearSelection = () => { + if (window.getSelection) { + window.getSelection().removeAllRanges() + } else if (document.selection) { + document.selection.empty() + } +} + +// Changes tooltip text for a moment, then changes it back +// We want the timeout of our `success` class to be a bit shorter than the +// tooltip and icon change, so that we can hide the icon before changing back. +var timeoutIcon = 2000; +var timeoutSuccessClass = 1500; + +const temporarilyChangeTooltip = (el, oldText, newText) => { + el.setAttribute('data-tooltip', newText) + el.classList.add('success') + // Remove success a little bit sooner than we change the tooltip + // So that we can use CSS to hide the copybutton first + setTimeout(() => el.classList.remove('success'), timeoutSuccessClass) + setTimeout(() => el.setAttribute('data-tooltip', oldText), timeoutIcon) +} + +// Changes the copy button icon for two seconds, then changes it back +const temporarilyChangeIcon = (el) => { + el.innerHTML = iconCheck; + setTimeout(() => {el.innerHTML = iconCopy}, timeoutIcon) +} + +const addCopyButtonToCodeCells = () => { + // If ClipboardJS hasn't loaded, wait a bit and try again. This + // happens because we load ClipboardJS asynchronously. + if (window.ClipboardJS === undefined) { + setTimeout(addCopyButtonToCodeCells, 250) + return + } + + // Add copybuttons to all of our code cells + const COPYBUTTON_SELECTOR = 'div.highlight pre'; + const codeCells = document.querySelectorAll(COPYBUTTON_SELECTOR) + codeCells.forEach((codeCell, index) => { + const id = codeCellId(index) + codeCell.setAttribute('id', id) + + const clipboardButton = id => + `` + codeCell.insertAdjacentHTML('afterend', clipboardButton(id)) + }) + +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} + + +var copyTargetText = (trigger) => { + var target = document.querySelector(trigger.attributes['data-clipboard-target'].value); + + // get filtered text + let exclude = '.linenos'; + + let text = filterText(target, exclude); + return formatCopyText(text, '', false, true, true, true, '', '') +} + + // Initialize with a callback so we can modify the text before copy + const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText}) + + // Update UI with error/success messages + clipboard.on('success', event => { + clearSelection() + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_success']) + temporarilyChangeIcon(event.trigger) + }) + + clipboard.on('error', event => { + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_failure']) + }) +} + +runWhenDOMLoaded(addCopyButtonToCodeCells) \ No newline at end of file diff --git a/_static/copybutton_funcs.js b/_static/copybutton_funcs.js new file mode 100644 index 000000000..dbe1aaad7 --- /dev/null +++ b/_static/copybutton_funcs.js @@ -0,0 +1,73 @@ +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +export function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +export function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} diff --git a/_static/design-style.4045f2051d55cab465a707391d5b2007.min.css b/_static/design-style.4045f2051d55cab465a707391d5b2007.min.css new file mode 100644 index 000000000..3225661c2 --- /dev/null +++ b/_static/design-style.4045f2051d55cab465a707391d5b2007.min.css @@ -0,0 +1 @@ +.sd-bg-primary{background-color:var(--sd-color-primary) !important}.sd-bg-text-primary{color:var(--sd-color-primary-text) !important}button.sd-bg-primary:focus,button.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}a.sd-bg-primary:focus,a.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}.sd-bg-secondary{background-color:var(--sd-color-secondary) !important}.sd-bg-text-secondary{color:var(--sd-color-secondary-text) !important}button.sd-bg-secondary:focus,button.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}a.sd-bg-secondary:focus,a.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}.sd-bg-success{background-color:var(--sd-color-success) !important}.sd-bg-text-success{color:var(--sd-color-success-text) !important}button.sd-bg-success:focus,button.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}a.sd-bg-success:focus,a.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}.sd-bg-info{background-color:var(--sd-color-info) !important}.sd-bg-text-info{color:var(--sd-color-info-text) !important}button.sd-bg-info:focus,button.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}a.sd-bg-info:focus,a.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}.sd-bg-warning{background-color:var(--sd-color-warning) !important}.sd-bg-text-warning{color:var(--sd-color-warning-text) !important}button.sd-bg-warning:focus,button.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}a.sd-bg-warning:focus,a.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}.sd-bg-danger{background-color:var(--sd-color-danger) !important}.sd-bg-text-danger{color:var(--sd-color-danger-text) !important}button.sd-bg-danger:focus,button.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}a.sd-bg-danger:focus,a.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}.sd-bg-light{background-color:var(--sd-color-light) !important}.sd-bg-text-light{color:var(--sd-color-light-text) !important}button.sd-bg-light:focus,button.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}a.sd-bg-light:focus,a.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}.sd-bg-muted{background-color:var(--sd-color-muted) !important}.sd-bg-text-muted{color:var(--sd-color-muted-text) !important}button.sd-bg-muted:focus,button.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}a.sd-bg-muted:focus,a.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}.sd-bg-dark{background-color:var(--sd-color-dark) !important}.sd-bg-text-dark{color:var(--sd-color-dark-text) !important}button.sd-bg-dark:focus,button.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}a.sd-bg-dark:focus,a.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}.sd-bg-black{background-color:var(--sd-color-black) !important}.sd-bg-text-black{color:var(--sd-color-black-text) !important}button.sd-bg-black:focus,button.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}a.sd-bg-black:focus,a.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}.sd-bg-white{background-color:var(--sd-color-white) !important}.sd-bg-text-white{color:var(--sd-color-white-text) !important}button.sd-bg-white:focus,button.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}a.sd-bg-white:focus,a.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}.sd-text-primary,.sd-text-primary>p{color:var(--sd-color-primary) !important}a.sd-text-primary:focus,a.sd-text-primary:hover{color:var(--sd-color-primary-highlight) !important}.sd-text-secondary,.sd-text-secondary>p{color:var(--sd-color-secondary) !important}a.sd-text-secondary:focus,a.sd-text-secondary:hover{color:var(--sd-color-secondary-highlight) !important}.sd-text-success,.sd-text-success>p{color:var(--sd-color-success) !important}a.sd-text-success:focus,a.sd-text-success:hover{color:var(--sd-color-success-highlight) !important}.sd-text-info,.sd-text-info>p{color:var(--sd-color-info) !important}a.sd-text-info:focus,a.sd-text-info:hover{color:var(--sd-color-info-highlight) !important}.sd-text-warning,.sd-text-warning>p{color:var(--sd-color-warning) !important}a.sd-text-warning:focus,a.sd-text-warning:hover{color:var(--sd-color-warning-highlight) !important}.sd-text-danger,.sd-text-danger>p{color:var(--sd-color-danger) !important}a.sd-text-danger:focus,a.sd-text-danger:hover{color:var(--sd-color-danger-highlight) !important}.sd-text-light,.sd-text-light>p{color:var(--sd-color-light) !important}a.sd-text-light:focus,a.sd-text-light:hover{color:var(--sd-color-light-highlight) !important}.sd-text-muted,.sd-text-muted>p{color:var(--sd-color-muted) !important}a.sd-text-muted:focus,a.sd-text-muted:hover{color:var(--sd-color-muted-highlight) !important}.sd-text-dark,.sd-text-dark>p{color:var(--sd-color-dark) !important}a.sd-text-dark:focus,a.sd-text-dark:hover{color:var(--sd-color-dark-highlight) !important}.sd-text-black,.sd-text-black>p{color:var(--sd-color-black) !important}a.sd-text-black:focus,a.sd-text-black:hover{color:var(--sd-color-black-highlight) !important}.sd-text-white,.sd-text-white>p{color:var(--sd-color-white) !important}a.sd-text-white:focus,a.sd-text-white:hover{color:var(--sd-color-white-highlight) !important}.sd-outline-primary{border-color:var(--sd-color-primary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-primary:focus,a.sd-outline-primary:hover{border-color:var(--sd-color-primary-highlight) !important}.sd-outline-secondary{border-color:var(--sd-color-secondary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-secondary:focus,a.sd-outline-secondary:hover{border-color:var(--sd-color-secondary-highlight) !important}.sd-outline-success{border-color:var(--sd-color-success) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-success:focus,a.sd-outline-success:hover{border-color:var(--sd-color-success-highlight) !important}.sd-outline-info{border-color:var(--sd-color-info) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-info:focus,a.sd-outline-info:hover{border-color:var(--sd-color-info-highlight) !important}.sd-outline-warning{border-color:var(--sd-color-warning) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-warning:focus,a.sd-outline-warning:hover{border-color:var(--sd-color-warning-highlight) !important}.sd-outline-danger{border-color:var(--sd-color-danger) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-danger:focus,a.sd-outline-danger:hover{border-color:var(--sd-color-danger-highlight) !important}.sd-outline-light{border-color:var(--sd-color-light) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-light:focus,a.sd-outline-light:hover{border-color:var(--sd-color-light-highlight) !important}.sd-outline-muted{border-color:var(--sd-color-muted) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-muted:focus,a.sd-outline-muted:hover{border-color:var(--sd-color-muted-highlight) !important}.sd-outline-dark{border-color:var(--sd-color-dark) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-dark:focus,a.sd-outline-dark:hover{border-color:var(--sd-color-dark-highlight) !important}.sd-outline-black{border-color:var(--sd-color-black) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-black:focus,a.sd-outline-black:hover{border-color:var(--sd-color-black-highlight) !important}.sd-outline-white{border-color:var(--sd-color-white) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-white:focus,a.sd-outline-white:hover{border-color:var(--sd-color-white-highlight) !important}.sd-bg-transparent{background-color:transparent !important}.sd-outline-transparent{border-color:transparent !important}.sd-text-transparent{color:transparent !important}.sd-p-0{padding:0 !important}.sd-pt-0,.sd-py-0{padding-top:0 !important}.sd-pr-0,.sd-px-0{padding-right:0 !important}.sd-pb-0,.sd-py-0{padding-bottom:0 !important}.sd-pl-0,.sd-px-0{padding-left:0 !important}.sd-p-1{padding:.25rem !important}.sd-pt-1,.sd-py-1{padding-top:.25rem !important}.sd-pr-1,.sd-px-1{padding-right:.25rem !important}.sd-pb-1,.sd-py-1{padding-bottom:.25rem !important}.sd-pl-1,.sd-px-1{padding-left:.25rem !important}.sd-p-2{padding:.5rem !important}.sd-pt-2,.sd-py-2{padding-top:.5rem !important}.sd-pr-2,.sd-px-2{padding-right:.5rem !important}.sd-pb-2,.sd-py-2{padding-bottom:.5rem !important}.sd-pl-2,.sd-px-2{padding-left:.5rem !important}.sd-p-3{padding:1rem !important}.sd-pt-3,.sd-py-3{padding-top:1rem !important}.sd-pr-3,.sd-px-3{padding-right:1rem !important}.sd-pb-3,.sd-py-3{padding-bottom:1rem !important}.sd-pl-3,.sd-px-3{padding-left:1rem !important}.sd-p-4{padding:1.5rem !important}.sd-pt-4,.sd-py-4{padding-top:1.5rem !important}.sd-pr-4,.sd-px-4{padding-right:1.5rem !important}.sd-pb-4,.sd-py-4{padding-bottom:1.5rem !important}.sd-pl-4,.sd-px-4{padding-left:1.5rem !important}.sd-p-5{padding:3rem !important}.sd-pt-5,.sd-py-5{padding-top:3rem !important}.sd-pr-5,.sd-px-5{padding-right:3rem !important}.sd-pb-5,.sd-py-5{padding-bottom:3rem !important}.sd-pl-5,.sd-px-5{padding-left:3rem !important}.sd-m-auto{margin:auto !important}.sd-mt-auto,.sd-my-auto{margin-top:auto !important}.sd-mr-auto,.sd-mx-auto{margin-right:auto !important}.sd-mb-auto,.sd-my-auto{margin-bottom:auto !important}.sd-ml-auto,.sd-mx-auto{margin-left:auto !important}.sd-m-0{margin:0 !important}.sd-mt-0,.sd-my-0{margin-top:0 !important}.sd-mr-0,.sd-mx-0{margin-right:0 !important}.sd-mb-0,.sd-my-0{margin-bottom:0 !important}.sd-ml-0,.sd-mx-0{margin-left:0 !important}.sd-m-1{margin:.25rem !important}.sd-mt-1,.sd-my-1{margin-top:.25rem !important}.sd-mr-1,.sd-mx-1{margin-right:.25rem !important}.sd-mb-1,.sd-my-1{margin-bottom:.25rem !important}.sd-ml-1,.sd-mx-1{margin-left:.25rem !important}.sd-m-2{margin:.5rem !important}.sd-mt-2,.sd-my-2{margin-top:.5rem !important}.sd-mr-2,.sd-mx-2{margin-right:.5rem !important}.sd-mb-2,.sd-my-2{margin-bottom:.5rem !important}.sd-ml-2,.sd-mx-2{margin-left:.5rem !important}.sd-m-3{margin:1rem !important}.sd-mt-3,.sd-my-3{margin-top:1rem !important}.sd-mr-3,.sd-mx-3{margin-right:1rem !important}.sd-mb-3,.sd-my-3{margin-bottom:1rem !important}.sd-ml-3,.sd-mx-3{margin-left:1rem !important}.sd-m-4{margin:1.5rem !important}.sd-mt-4,.sd-my-4{margin-top:1.5rem !important}.sd-mr-4,.sd-mx-4{margin-right:1.5rem !important}.sd-mb-4,.sd-my-4{margin-bottom:1.5rem !important}.sd-ml-4,.sd-mx-4{margin-left:1.5rem !important}.sd-m-5{margin:3rem !important}.sd-mt-5,.sd-my-5{margin-top:3rem !important}.sd-mr-5,.sd-mx-5{margin-right:3rem !important}.sd-mb-5,.sd-my-5{margin-bottom:3rem !important}.sd-ml-5,.sd-mx-5{margin-left:3rem !important}.sd-w-25{width:25% !important}.sd-w-50{width:50% !important}.sd-w-75{width:75% !important}.sd-w-100{width:100% !important}.sd-w-auto{width:auto !important}.sd-h-25{height:25% !important}.sd-h-50{height:50% !important}.sd-h-75{height:75% !important}.sd-h-100{height:100% !important}.sd-h-auto{height:auto !important}.sd-d-none{display:none !important}.sd-d-inline{display:inline !important}.sd-d-inline-block{display:inline-block !important}.sd-d-block{display:block !important}.sd-d-grid{display:grid !important}.sd-d-flex-row{display:-ms-flexbox !important;display:flex !important;flex-direction:row !important}.sd-d-flex-column{display:-ms-flexbox !important;display:flex !important;flex-direction:column !important}.sd-d-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}@media(min-width: 576px){.sd-d-sm-none{display:none !important}.sd-d-sm-inline{display:inline !important}.sd-d-sm-inline-block{display:inline-block !important}.sd-d-sm-block{display:block !important}.sd-d-sm-grid{display:grid !important}.sd-d-sm-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-sm-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 768px){.sd-d-md-none{display:none !important}.sd-d-md-inline{display:inline !important}.sd-d-md-inline-block{display:inline-block !important}.sd-d-md-block{display:block !important}.sd-d-md-grid{display:grid !important}.sd-d-md-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-md-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 992px){.sd-d-lg-none{display:none !important}.sd-d-lg-inline{display:inline !important}.sd-d-lg-inline-block{display:inline-block !important}.sd-d-lg-block{display:block !important}.sd-d-lg-grid{display:grid !important}.sd-d-lg-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-lg-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 1200px){.sd-d-xl-none{display:none !important}.sd-d-xl-inline{display:inline !important}.sd-d-xl-inline-block{display:inline-block !important}.sd-d-xl-block{display:block !important}.sd-d-xl-grid{display:grid !important}.sd-d-xl-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-xl-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}.sd-align-major-start{justify-content:flex-start !important}.sd-align-major-end{justify-content:flex-end !important}.sd-align-major-center{justify-content:center !important}.sd-align-major-justify{justify-content:space-between !important}.sd-align-major-spaced{justify-content:space-evenly !important}.sd-align-minor-start{align-items:flex-start !important}.sd-align-minor-end{align-items:flex-end !important}.sd-align-minor-center{align-items:center !important}.sd-align-minor-stretch{align-items:stretch !important}.sd-text-justify{text-align:justify !important}.sd-text-left{text-align:left !important}.sd-text-right{text-align:right !important}.sd-text-center{text-align:center !important}.sd-font-weight-light{font-weight:300 !important}.sd-font-weight-lighter{font-weight:lighter !important}.sd-font-weight-normal{font-weight:400 !important}.sd-font-weight-bold{font-weight:700 !important}.sd-font-weight-bolder{font-weight:bolder !important}.sd-font-italic{font-style:italic !important}.sd-text-decoration-none{text-decoration:none !important}.sd-text-lowercase{text-transform:lowercase !important}.sd-text-uppercase{text-transform:uppercase !important}.sd-text-capitalize{text-transform:capitalize !important}.sd-text-wrap{white-space:normal !important}.sd-text-nowrap{white-space:nowrap !important}.sd-text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sd-fs-1,.sd-fs-1>p{font-size:calc(1.375rem + 1.5vw) !important;line-height:unset !important}.sd-fs-2,.sd-fs-2>p{font-size:calc(1.325rem + 0.9vw) !important;line-height:unset !important}.sd-fs-3,.sd-fs-3>p{font-size:calc(1.3rem + 0.6vw) !important;line-height:unset !important}.sd-fs-4,.sd-fs-4>p{font-size:calc(1.275rem + 0.3vw) !important;line-height:unset !important}.sd-fs-5,.sd-fs-5>p{font-size:1.25rem !important;line-height:unset !important}.sd-fs-6,.sd-fs-6>p{font-size:1rem !important;line-height:unset !important}.sd-border-0{border:0 solid !important}.sd-border-top-0{border-top:0 solid !important}.sd-border-bottom-0{border-bottom:0 solid !important}.sd-border-right-0{border-right:0 solid !important}.sd-border-left-0{border-left:0 solid !important}.sd-border-1{border:1px solid !important}.sd-border-top-1{border-top:1px solid !important}.sd-border-bottom-1{border-bottom:1px solid !important}.sd-border-right-1{border-right:1px solid !important}.sd-border-left-1{border-left:1px solid !important}.sd-border-2{border:2px solid !important}.sd-border-top-2{border-top:2px solid !important}.sd-border-bottom-2{border-bottom:2px solid !important}.sd-border-right-2{border-right:2px solid !important}.sd-border-left-2{border-left:2px solid !important}.sd-border-3{border:3px solid !important}.sd-border-top-3{border-top:3px solid !important}.sd-border-bottom-3{border-bottom:3px solid !important}.sd-border-right-3{border-right:3px solid !important}.sd-border-left-3{border-left:3px solid !important}.sd-border-4{border:4px solid !important}.sd-border-top-4{border-top:4px solid !important}.sd-border-bottom-4{border-bottom:4px solid !important}.sd-border-right-4{border-right:4px solid !important}.sd-border-left-4{border-left:4px solid !important}.sd-border-5{border:5px solid !important}.sd-border-top-5{border-top:5px solid !important}.sd-border-bottom-5{border-bottom:5px solid !important}.sd-border-right-5{border-right:5px solid !important}.sd-border-left-5{border-left:5px solid !important}.sd-rounded-0{border-radius:0 !important}.sd-rounded-1{border-radius:.2rem !important}.sd-rounded-2{border-radius:.3rem !important}.sd-rounded-3{border-radius:.5rem !important}.sd-rounded-pill{border-radius:50rem !important}.sd-rounded-circle{border-radius:50% !important}.shadow-none{box-shadow:none !important}.sd-shadow-sm{box-shadow:0 .125rem .25rem var(--sd-color-shadow) !important}.sd-shadow-md{box-shadow:0 .5rem 1rem var(--sd-color-shadow) !important}.sd-shadow-lg{box-shadow:0 1rem 3rem var(--sd-color-shadow) !important}@keyframes sd-slide-from-left{0%{transform:translateX(-100%)}100%{transform:translateX(0)}}@keyframes sd-slide-from-right{0%{transform:translateX(200%)}100%{transform:translateX(0)}}@keyframes sd-grow100{0%{transform:scale(0);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50{0%{transform:scale(0.5);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50-rot20{0%{transform:scale(0.5) rotateZ(-20deg);opacity:.5}75%{transform:scale(1) rotateZ(5deg);opacity:1}95%{transform:scale(1) rotateZ(-1deg);opacity:1}100%{transform:scale(1) rotateZ(0);opacity:1}}.sd-animate-slide-from-left{animation:1s ease-out 0s 1 normal none running sd-slide-from-left}.sd-animate-slide-from-right{animation:1s ease-out 0s 1 normal none running sd-slide-from-right}.sd-animate-grow100{animation:1s ease-out 0s 1 normal none running sd-grow100}.sd-animate-grow50{animation:1s ease-out 0s 1 normal none running sd-grow50}.sd-animate-grow50-rot20{animation:1s ease-out 0s 1 normal none running sd-grow50-rot20}.sd-badge{display:inline-block;padding:.35em .65em;font-size:.75em;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.sd-badge:empty{display:none}a.sd-badge{text-decoration:none}.sd-btn .sd-badge{position:relative;top:-1px}.sd-btn{background-color:transparent;border:1px solid transparent;border-radius:.25rem;cursor:pointer;display:inline-block;font-weight:400;font-size:1rem;line-height:1.5;padding:.375rem .75rem;text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;vertical-align:middle;user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none}.sd-btn:hover{text-decoration:none}@media(prefers-reduced-motion: reduce){.sd-btn{transition:none}}.sd-btn-primary,.sd-btn-outline-primary:hover,.sd-btn-outline-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-primary:hover,.sd-btn-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary-highlight) !important;border-color:var(--sd-color-primary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-primary{color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary,.sd-btn-outline-secondary:hover,.sd-btn-outline-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary:hover,.sd-btn-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary-highlight) !important;border-color:var(--sd-color-secondary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-secondary{color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success,.sd-btn-outline-success:hover,.sd-btn-outline-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success:hover,.sd-btn-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success-highlight) !important;border-color:var(--sd-color-success-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-success{color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info,.sd-btn-outline-info:hover,.sd-btn-outline-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info:hover,.sd-btn-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info-highlight) !important;border-color:var(--sd-color-info-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-info{color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning,.sd-btn-outline-warning:hover,.sd-btn-outline-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning:hover,.sd-btn-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning-highlight) !important;border-color:var(--sd-color-warning-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-warning{color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger,.sd-btn-outline-danger:hover,.sd-btn-outline-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger:hover,.sd-btn-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger-highlight) !important;border-color:var(--sd-color-danger-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-danger{color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light,.sd-btn-outline-light:hover,.sd-btn-outline-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light:hover,.sd-btn-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light-highlight) !important;border-color:var(--sd-color-light-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-light{color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted,.sd-btn-outline-muted:hover,.sd-btn-outline-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted:hover,.sd-btn-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted-highlight) !important;border-color:var(--sd-color-muted-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-muted{color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark,.sd-btn-outline-dark:hover,.sd-btn-outline-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark:hover,.sd-btn-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark-highlight) !important;border-color:var(--sd-color-dark-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-dark{color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black,.sd-btn-outline-black:hover,.sd-btn-outline-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black:hover,.sd-btn-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black-highlight) !important;border-color:var(--sd-color-black-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-black{color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white,.sd-btn-outline-white:hover,.sd-btn-outline-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white:hover,.sd-btn-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white-highlight) !important;border-color:var(--sd-color-white-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-white{color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.sd-hide-link-text{font-size:0}.sd-octicon,.sd-material-icon{display:inline-block;fill:currentColor;vertical-align:middle}.sd-avatar-xs{border-radius:50%;object-fit:cover;object-position:center;width:1rem;height:1rem}.sd-avatar-sm{border-radius:50%;object-fit:cover;object-position:center;width:3rem;height:3rem}.sd-avatar-md{border-radius:50%;object-fit:cover;object-position:center;width:5rem;height:5rem}.sd-avatar-lg{border-radius:50%;object-fit:cover;object-position:center;width:7rem;height:7rem}.sd-avatar-xl{border-radius:50%;object-fit:cover;object-position:center;width:10rem;height:10rem}.sd-avatar-inherit{border-radius:50%;object-fit:cover;object-position:center;width:inherit;height:inherit}.sd-avatar-initial{border-radius:50%;object-fit:cover;object-position:center;width:initial;height:initial}.sd-card{background-clip:border-box;background-color:var(--sd-color-card-background);border:1px solid var(--sd-color-card-border);border-radius:.25rem;color:var(--sd-color-card-text);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;min-width:0;position:relative;word-wrap:break-word}.sd-card>hr{margin-left:0;margin-right:0}.sd-card-hover:hover{border-color:var(--sd-color-card-border-hover);transform:scale(1.01)}.sd-card-body{-ms-flex:1 1 auto;flex:1 1 auto;padding:1rem 1rem}.sd-card-title{margin-bottom:.5rem}.sd-card-subtitle{margin-top:-0.25rem;margin-bottom:0}.sd-card-text:last-child{margin-bottom:0}.sd-card-link:hover{text-decoration:none}.sd-card-link+.card-link{margin-left:1rem}.sd-card-header{padding:.5rem 1rem;margin-bottom:0;background-color:var(--sd-color-card-header);border-bottom:1px solid var(--sd-color-card-border)}.sd-card-header:first-child{border-radius:calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0}.sd-card-footer{padding:.5rem 1rem;background-color:var(--sd-color-card-footer);border-top:1px solid var(--sd-color-card-border)}.sd-card-footer:last-child{border-radius:0 0 calc(0.25rem - 1px) calc(0.25rem - 1px)}.sd-card-header-tabs{margin-right:-0.5rem;margin-bottom:-0.5rem;margin-left:-0.5rem;border-bottom:0}.sd-card-header-pills{margin-right:-0.5rem;margin-left:-0.5rem}.sd-card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1rem;border-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom,.sd-card-img-top{width:100%}.sd-card-img,.sd-card-img-top{border-top-left-radius:calc(0.25rem - 1px);border-top-right-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom{border-bottom-left-radius:calc(0.25rem - 1px);border-bottom-right-radius:calc(0.25rem - 1px)}.sd-cards-carousel{width:100%;display:flex;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row;overflow-x:hidden;scroll-snap-type:x mandatory}.sd-cards-carousel.sd-show-scrollbar{overflow-x:auto}.sd-cards-carousel:hover,.sd-cards-carousel:focus{overflow-x:auto}.sd-cards-carousel>.sd-card{flex-shrink:0;scroll-snap-align:start}.sd-cards-carousel>.sd-card:not(:last-child){margin-right:3px}.sd-card-cols-1>.sd-card{width:90%}.sd-card-cols-2>.sd-card{width:45%}.sd-card-cols-3>.sd-card{width:30%}.sd-card-cols-4>.sd-card{width:22.5%}.sd-card-cols-5>.sd-card{width:18%}.sd-card-cols-6>.sd-card{width:15%}.sd-card-cols-7>.sd-card{width:12.8571428571%}.sd-card-cols-8>.sd-card{width:11.25%}.sd-card-cols-9>.sd-card{width:10%}.sd-card-cols-10>.sd-card{width:9%}.sd-card-cols-11>.sd-card{width:8.1818181818%}.sd-card-cols-12>.sd-card{width:7.5%}.sd-container,.sd-container-fluid,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container-xl{margin-left:auto;margin-right:auto;padding-left:var(--sd-gutter-x, 0.75rem);padding-right:var(--sd-gutter-x, 0.75rem);width:100%}@media(min-width: 576px){.sd-container-sm,.sd-container{max-width:540px}}@media(min-width: 768px){.sd-container-md,.sd-container-sm,.sd-container{max-width:720px}}@media(min-width: 992px){.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:960px}}@media(min-width: 1200px){.sd-container-xl,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:1140px}}.sd-row{--sd-gutter-x: 1.5rem;--sd-gutter-y: 0;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-top:calc(var(--sd-gutter-y) * -1);margin-right:calc(var(--sd-gutter-x) * -0.5);margin-left:calc(var(--sd-gutter-x) * -0.5)}.sd-row>*{box-sizing:border-box;flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--sd-gutter-x) * 0.5);padding-left:calc(var(--sd-gutter-x) * 0.5);margin-top:var(--sd-gutter-y)}.sd-col{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-auto>*{flex:0 0 auto;width:auto}.sd-row-cols-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}@media(min-width: 576px){.sd-col-sm{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-sm-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-sm-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-sm-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-sm-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-sm-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-sm-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-sm-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-sm-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-sm-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-sm-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-sm-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-sm-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-sm-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 768px){.sd-col-md{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-md-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-md-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-md-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-md-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-md-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-md-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-md-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-md-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-md-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-md-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-md-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-md-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-md-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 992px){.sd-col-lg{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-lg-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-lg-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-lg-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-lg-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-lg-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-lg-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-lg-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-lg-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-lg-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-lg-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-lg-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-lg-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-lg-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 1200px){.sd-col-xl{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-xl-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-xl-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-xl-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-xl-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-xl-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-xl-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-xl-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-xl-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-xl-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-xl-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-xl-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-xl-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-xl-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}.sd-col-auto{flex:0 0 auto;-ms-flex:0 0 auto;width:auto}.sd-col-1{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}.sd-col-2{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-col-3{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-col-4{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-col-5{flex:0 0 auto;-ms-flex:0 0 auto;width:41.6666666667%}.sd-col-6{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-col-7{flex:0 0 auto;-ms-flex:0 0 auto;width:58.3333333333%}.sd-col-8{flex:0 0 auto;-ms-flex:0 0 auto;width:66.6666666667%}.sd-col-9{flex:0 0 auto;-ms-flex:0 0 auto;width:75%}.sd-col-10{flex:0 0 auto;-ms-flex:0 0 auto;width:83.3333333333%}.sd-col-11{flex:0 0 auto;-ms-flex:0 0 auto;width:91.6666666667%}.sd-col-12{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-g-0,.sd-gy-0{--sd-gutter-y: 0}.sd-g-0,.sd-gx-0{--sd-gutter-x: 0}.sd-g-1,.sd-gy-1{--sd-gutter-y: 0.25rem}.sd-g-1,.sd-gx-1{--sd-gutter-x: 0.25rem}.sd-g-2,.sd-gy-2{--sd-gutter-y: 0.5rem}.sd-g-2,.sd-gx-2{--sd-gutter-x: 0.5rem}.sd-g-3,.sd-gy-3{--sd-gutter-y: 1rem}.sd-g-3,.sd-gx-3{--sd-gutter-x: 1rem}.sd-g-4,.sd-gy-4{--sd-gutter-y: 1.5rem}.sd-g-4,.sd-gx-4{--sd-gutter-x: 1.5rem}.sd-g-5,.sd-gy-5{--sd-gutter-y: 3rem}.sd-g-5,.sd-gx-5{--sd-gutter-x: 3rem}@media(min-width: 576px){.sd-col-sm-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-sm-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-sm-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-sm-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-sm-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-sm-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-sm-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-sm-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-sm-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-sm-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-sm-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-sm-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-sm-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-sm-0,.sd-gy-sm-0{--sd-gutter-y: 0}.sd-g-sm-0,.sd-gx-sm-0{--sd-gutter-x: 0}.sd-g-sm-1,.sd-gy-sm-1{--sd-gutter-y: 0.25rem}.sd-g-sm-1,.sd-gx-sm-1{--sd-gutter-x: 0.25rem}.sd-g-sm-2,.sd-gy-sm-2{--sd-gutter-y: 0.5rem}.sd-g-sm-2,.sd-gx-sm-2{--sd-gutter-x: 0.5rem}.sd-g-sm-3,.sd-gy-sm-3{--sd-gutter-y: 1rem}.sd-g-sm-3,.sd-gx-sm-3{--sd-gutter-x: 1rem}.sd-g-sm-4,.sd-gy-sm-4{--sd-gutter-y: 1.5rem}.sd-g-sm-4,.sd-gx-sm-4{--sd-gutter-x: 1.5rem}.sd-g-sm-5,.sd-gy-sm-5{--sd-gutter-y: 3rem}.sd-g-sm-5,.sd-gx-sm-5{--sd-gutter-x: 3rem}}@media(min-width: 768px){.sd-col-md-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-md-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-md-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-md-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-md-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-md-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-md-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-md-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-md-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-md-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-md-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-md-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-md-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-md-0,.sd-gy-md-0{--sd-gutter-y: 0}.sd-g-md-0,.sd-gx-md-0{--sd-gutter-x: 0}.sd-g-md-1,.sd-gy-md-1{--sd-gutter-y: 0.25rem}.sd-g-md-1,.sd-gx-md-1{--sd-gutter-x: 0.25rem}.sd-g-md-2,.sd-gy-md-2{--sd-gutter-y: 0.5rem}.sd-g-md-2,.sd-gx-md-2{--sd-gutter-x: 0.5rem}.sd-g-md-3,.sd-gy-md-3{--sd-gutter-y: 1rem}.sd-g-md-3,.sd-gx-md-3{--sd-gutter-x: 1rem}.sd-g-md-4,.sd-gy-md-4{--sd-gutter-y: 1.5rem}.sd-g-md-4,.sd-gx-md-4{--sd-gutter-x: 1.5rem}.sd-g-md-5,.sd-gy-md-5{--sd-gutter-y: 3rem}.sd-g-md-5,.sd-gx-md-5{--sd-gutter-x: 3rem}}@media(min-width: 992px){.sd-col-lg-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-lg-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-lg-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-lg-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-lg-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-lg-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-lg-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-lg-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-lg-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-lg-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-lg-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-lg-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-lg-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-lg-0,.sd-gy-lg-0{--sd-gutter-y: 0}.sd-g-lg-0,.sd-gx-lg-0{--sd-gutter-x: 0}.sd-g-lg-1,.sd-gy-lg-1{--sd-gutter-y: 0.25rem}.sd-g-lg-1,.sd-gx-lg-1{--sd-gutter-x: 0.25rem}.sd-g-lg-2,.sd-gy-lg-2{--sd-gutter-y: 0.5rem}.sd-g-lg-2,.sd-gx-lg-2{--sd-gutter-x: 0.5rem}.sd-g-lg-3,.sd-gy-lg-3{--sd-gutter-y: 1rem}.sd-g-lg-3,.sd-gx-lg-3{--sd-gutter-x: 1rem}.sd-g-lg-4,.sd-gy-lg-4{--sd-gutter-y: 1.5rem}.sd-g-lg-4,.sd-gx-lg-4{--sd-gutter-x: 1.5rem}.sd-g-lg-5,.sd-gy-lg-5{--sd-gutter-y: 3rem}.sd-g-lg-5,.sd-gx-lg-5{--sd-gutter-x: 3rem}}@media(min-width: 1200px){.sd-col-xl-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-xl-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-xl-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-xl-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-xl-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-xl-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-xl-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-xl-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-xl-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-xl-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-xl-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-xl-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-xl-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-xl-0,.sd-gy-xl-0{--sd-gutter-y: 0}.sd-g-xl-0,.sd-gx-xl-0{--sd-gutter-x: 0}.sd-g-xl-1,.sd-gy-xl-1{--sd-gutter-y: 0.25rem}.sd-g-xl-1,.sd-gx-xl-1{--sd-gutter-x: 0.25rem}.sd-g-xl-2,.sd-gy-xl-2{--sd-gutter-y: 0.5rem}.sd-g-xl-2,.sd-gx-xl-2{--sd-gutter-x: 0.5rem}.sd-g-xl-3,.sd-gy-xl-3{--sd-gutter-y: 1rem}.sd-g-xl-3,.sd-gx-xl-3{--sd-gutter-x: 1rem}.sd-g-xl-4,.sd-gy-xl-4{--sd-gutter-y: 1.5rem}.sd-g-xl-4,.sd-gx-xl-4{--sd-gutter-x: 1.5rem}.sd-g-xl-5,.sd-gy-xl-5{--sd-gutter-y: 3rem}.sd-g-xl-5,.sd-gx-xl-5{--sd-gutter-x: 3rem}}.sd-flex-row-reverse{flex-direction:row-reverse !important}details.sd-dropdown{position:relative}details.sd-dropdown .sd-summary-title{font-weight:700;padding-right:3em !important;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;user-select:none}details.sd-dropdown:hover{cursor:pointer}details.sd-dropdown .sd-summary-content{cursor:default}details.sd-dropdown summary{list-style:none;padding:1em}details.sd-dropdown summary .sd-octicon.no-title{vertical-align:middle}details.sd-dropdown[open] summary .sd-octicon.no-title{visibility:hidden}details.sd-dropdown summary::-webkit-details-marker{display:none}details.sd-dropdown summary:focus{outline:none}details.sd-dropdown .sd-summary-icon{margin-right:.5em}details.sd-dropdown .sd-summary-icon svg{opacity:.8}details.sd-dropdown summary:hover .sd-summary-up svg,details.sd-dropdown summary:hover .sd-summary-down svg{opacity:1;transform:scale(1.1)}details.sd-dropdown .sd-summary-up svg,details.sd-dropdown .sd-summary-down svg{display:block;opacity:.6}details.sd-dropdown .sd-summary-up,details.sd-dropdown .sd-summary-down{pointer-events:none;position:absolute;right:1em;top:1em}details.sd-dropdown[open]>.sd-summary-title .sd-summary-down{visibility:hidden}details.sd-dropdown:not([open])>.sd-summary-title .sd-summary-up{visibility:hidden}details.sd-dropdown:not([open]).sd-card{border:none}details.sd-dropdown:not([open])>.sd-card-header{border:1px solid var(--sd-color-card-border);border-radius:.25rem}details.sd-dropdown.sd-fade-in[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out;animation:sd-fade-in .5s ease-in-out}details.sd-dropdown.sd-fade-in-slide-down[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out}.sd-col>.sd-dropdown{width:100%}.sd-summary-content>.sd-tab-set:first-child{margin-top:0}@keyframes sd-fade-in{0%{opacity:0}100%{opacity:1}}@keyframes sd-slide-down{0%{transform:translate(0, -10px)}100%{transform:translate(0, 0)}}.sd-tab-set{border-radius:.125rem;display:flex;flex-wrap:wrap;margin:1em 0;position:relative}.sd-tab-set>input{opacity:0;position:absolute}.sd-tab-set>input:checked+label{border-color:var(--sd-color-tabs-underline-active);color:var(--sd-color-tabs-label-active)}.sd-tab-set>input:checked+label+.sd-tab-content{display:block}.sd-tab-set>input:not(:checked)+label:hover{color:var(--sd-color-tabs-label-hover);border-color:var(--sd-color-tabs-underline-hover)}.sd-tab-set>input:focus+label{outline-style:auto}.sd-tab-set>input:not(.focus-visible)+label{outline:none;-webkit-tap-highlight-color:transparent}.sd-tab-set>label{border-bottom:.125rem solid transparent;margin-bottom:0;color:var(--sd-color-tabs-label-inactive);border-color:var(--sd-color-tabs-underline-inactive);cursor:pointer;font-size:var(--sd-fontsize-tabs-label);font-weight:700;padding:1em 1.25em .5em;transition:color 250ms;width:auto;z-index:1}html .sd-tab-set>label:hover{color:var(--sd-color-tabs-label-active)}.sd-col>.sd-tab-set{width:100%}.sd-tab-content{box-shadow:0 -0.0625rem var(--sd-color-tabs-overline),0 .0625rem var(--sd-color-tabs-underline);display:none;order:99;padding-bottom:.75rem;padding-top:.75rem;width:100%}.sd-tab-content>:first-child{margin-top:0 !important}.sd-tab-content>:last-child{margin-bottom:0 !important}.sd-tab-content>.sd-tab-set{margin:0}.sd-sphinx-override,.sd-sphinx-override *{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sd-sphinx-override p{margin-top:0}:root{--sd-color-primary: #007bff;--sd-color-secondary: #6c757d;--sd-color-success: #28a745;--sd-color-info: #17a2b8;--sd-color-warning: #f0b37e;--sd-color-danger: #dc3545;--sd-color-light: #f8f9fa;--sd-color-muted: #6c757d;--sd-color-dark: #212529;--sd-color-black: black;--sd-color-white: white;--sd-color-primary-highlight: #0069d9;--sd-color-secondary-highlight: #5c636a;--sd-color-success-highlight: #228e3b;--sd-color-info-highlight: #148a9c;--sd-color-warning-highlight: #cc986b;--sd-color-danger-highlight: #bb2d3b;--sd-color-light-highlight: #d3d4d5;--sd-color-muted-highlight: #5c636a;--sd-color-dark-highlight: #1c1f23;--sd-color-black-highlight: black;--sd-color-white-highlight: #d9d9d9;--sd-color-primary-text: #fff;--sd-color-secondary-text: #fff;--sd-color-success-text: #fff;--sd-color-info-text: #fff;--sd-color-warning-text: #212529;--sd-color-danger-text: #fff;--sd-color-light-text: #212529;--sd-color-muted-text: #fff;--sd-color-dark-text: #fff;--sd-color-black-text: #fff;--sd-color-white-text: #212529;--sd-color-shadow: rgba(0, 0, 0, 0.15);--sd-color-card-border: rgba(0, 0, 0, 0.125);--sd-color-card-border-hover: hsla(231, 99%, 66%, 1);--sd-color-card-background: transparent;--sd-color-card-text: inherit;--sd-color-card-header: transparent;--sd-color-card-footer: transparent;--sd-color-tabs-label-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-hover: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-inactive: hsl(0, 0%, 66%);--sd-color-tabs-underline-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-underline-hover: rgba(178, 206, 245, 0.62);--sd-color-tabs-underline-inactive: transparent;--sd-color-tabs-overline: rgb(222, 222, 222);--sd-color-tabs-underline: rgb(222, 222, 222);--sd-fontsize-tabs-label: 1rem} diff --git a/_static/design-tabs.js b/_static/design-tabs.js new file mode 100644 index 000000000..36b38cf0d --- /dev/null +++ b/_static/design-tabs.js @@ -0,0 +1,27 @@ +var sd_labels_by_text = {}; + +function ready() { + const li = document.getElementsByClassName("sd-tab-label"); + for (const label of li) { + syncId = label.getAttribute("data-sync-id"); + if (syncId) { + label.onclick = onLabelClick; + if (!sd_labels_by_text[syncId]) { + sd_labels_by_text[syncId] = []; + } + sd_labels_by_text[syncId].push(label); + } + } +} + +function onLabelClick() { + // Activate other inputs with the same sync id. + syncId = this.getAttribute("data-sync-id"); + for (label of sd_labels_by_text[syncId]) { + if (label === this) continue; + label.previousElementSibling.checked = true; + } + window.localStorage.setItem("sphinx-design-last-tab", syncId); +} + +document.addEventListener("DOMContentLoaded", ready, false); diff --git a/_static/doctools.js b/_static/doctools.js new file mode 100644 index 000000000..c3db08d1c --- /dev/null +++ b/_static/doctools.js @@ -0,0 +1,264 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Base JavaScript utilities for all Sphinx HTML documentation. + * + * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +const _ready = (callback) => { + if (document.readyState !== "loading") { + callback(); + } else { + document.addEventListener("DOMContentLoaded", callback); + } +}; + +/** + * highlight a given string on a node by wrapping it in + * span elements with the given class name. + */ +const _highlight = (node, addItems, text, className) => { + if (node.nodeType === Node.TEXT_NODE) { + const val = node.nodeValue; + const parent = node.parentNode; + const pos = val.toLowerCase().indexOf(text); + if ( + pos >= 0 && + !parent.classList.contains(className) && + !parent.classList.contains("nohighlight") + ) { + let span; + + const closestNode = parent.closest("body, svg, foreignObject"); + const isInSVG = closestNode && closestNode.matches("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.classList.add(className); + } + + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + parent.insertBefore( + span, + parent.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling + ) + ); + node.nodeValue = val.substr(0, pos); + + if (isInSVG) { + const rect = document.createElementNS( + "http://www.w3.org/2000/svg", + "rect" + ); + const bbox = parent.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute("class", className); + addItems.push({ parent: parent, target: rect }); + } + } + } else if (node.matches && !node.matches("button, select, textarea")) { + node.childNodes.forEach((el) => _highlight(el, addItems, text, className)); + } +}; +const _highlightText = (thisNode, text, className) => { + let addItems = []; + _highlight(thisNode, addItems, text, className); + addItems.forEach((obj) => + obj.parent.insertAdjacentElement("beforebegin", obj.target) + ); +}; + +/** + * Small JavaScript module for the documentation. + */ +const Documentation = { + init: () => { + Documentation.highlightSearchWords(); + Documentation.initDomainIndexTable(); + Documentation.initOnKeyListeners(); + }, + + /** + * i18n support + */ + TRANSLATIONS: {}, + PLURAL_EXPR: (n) => (n === 1 ? 0 : 1), + LOCALE: "unknown", + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext: (string) => { + const translated = Documentation.TRANSLATIONS[string]; + switch (typeof translated) { + case "undefined": + return string; // no translation + case "string": + return translated; // translation exists + default: + return translated[0]; // (singular, plural) translation tuple exists + } + }, + + ngettext: (singular, plural, n) => { + const translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated !== "undefined") + return translated[Documentation.PLURAL_EXPR(n)]; + return n === 1 ? singular : plural; + }, + + addTranslations: (catalog) => { + Object.assign(Documentation.TRANSLATIONS, catalog.messages); + Documentation.PLURAL_EXPR = new Function( + "n", + `return (${catalog.plural_expr})` + ); + Documentation.LOCALE = catalog.locale; + }, + + /** + * highlight the search words provided in the url in the text + */ + highlightSearchWords: () => { + const highlight = + new URLSearchParams(window.location.search).get("highlight") || ""; + const terms = highlight.toLowerCase().split(/\s+/).filter(x => x); + if (terms.length === 0) return; // nothing to do + + // There should never be more than one element matching "div.body" + const divBody = document.querySelectorAll("div.body"); + const body = divBody.length ? divBody[0] : document.querySelector("body"); + window.setTimeout(() => { + terms.forEach((term) => _highlightText(body, term, "highlighted")); + }, 10); + + const searchBox = document.getElementById("searchbox"); + if (searchBox === null) return; + searchBox.appendChild( + document + .createRange() + .createContextualFragment( + '

' + + '' + + Documentation.gettext("Hide Search Matches") + + "

" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + const url = new URL(window.location); + url.searchParams.delete("highlight"); + window.history.replaceState({}, "", url); + }, + + /** + * helper function to focus on search bar + */ + focusSearchBar: () => { + document.querySelectorAll("input[name=q]")[0]?.focus(); + }, + + /** + * Initialise the domain index toggle buttons + */ + initDomainIndexTable: () => { + const toggler = (el) => { + const idNumber = el.id.substr(7); + const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`); + if (el.src.substr(-9) === "minus.png") { + el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`; + toggledRows.forEach((el) => (el.style.display = "none")); + } else { + el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`; + toggledRows.forEach((el) => (el.style.display = "")); + } + }; + + const togglerElements = document.querySelectorAll("img.toggler"); + togglerElements.forEach((el) => + el.addEventListener("click", (event) => toggler(event.currentTarget)) + ); + togglerElements.forEach((el) => (el.style.display = "")); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler); + }, + + initOnKeyListeners: () => { + // only install a listener if it is really needed + if ( + !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS && + !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS + ) + return; + + const blacklistedElements = new Set([ + "TEXTAREA", + "INPUT", + "SELECT", + "BUTTON", + ]); + document.addEventListener("keydown", (event) => { + if (blacklistedElements.has(document.activeElement.tagName)) return; // bail for input elements + if (event.altKey || event.ctrlKey || event.metaKey) return; // bail with special keys + + if (!event.shiftKey) { + switch (event.key) { + case "ArrowLeft": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const prevLink = document.querySelector('link[rel="prev"]'); + if (prevLink && prevLink.href) { + window.location.href = prevLink.href; + event.preventDefault(); + } + break; + case "ArrowRight": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const nextLink = document.querySelector('link[rel="next"]'); + if (nextLink && nextLink.href) { + window.location.href = nextLink.href; + event.preventDefault(); + } + break; + case "Escape": + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break; + Documentation.hideSearchWords(); + event.preventDefault(); + } + } + + // some keyboard layouts may need Shift to get / + switch (event.key) { + case "/": + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break; + Documentation.focusSearchBar(); + event.preventDefault(); + } + }); + }, +}; + +// quick alias for translations +const _ = Documentation.gettext; + +_ready(Documentation.init); diff --git a/_static/documentation_options.js b/_static/documentation_options.js new file mode 100644 index 000000000..162a6ba8d --- /dev/null +++ b/_static/documentation_options.js @@ -0,0 +1,14 @@ +var DOCUMENTATION_OPTIONS = { + URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'), + VERSION: '', + LANGUAGE: 'en', + COLLAPSE_INDEX: false, + BUILDER: 'html', + FILE_SUFFIX: '.html', + LINK_SUFFIX: '.html', + HAS_SOURCE: true, + SOURCELINK_SUFFIX: '', + NAVIGATION_WITH_KEYS: false, + SHOW_SEARCH_SUMMARY: true, + ENABLE_SEARCH_SHORTCUTS: false, +}; \ No newline at end of file diff --git a/_static/file.png b/_static/file.png new file mode 100644 index 000000000..a858a410e Binary files /dev/null and b/_static/file.png differ diff --git a/_static/images/logo_binder.svg b/_static/images/logo_binder.svg new file mode 100644 index 000000000..45fecf751 --- /dev/null +++ b/_static/images/logo_binder.svg @@ -0,0 +1,19 @@ + + + + +logo + + + + + + + + diff --git a/_static/images/logo_colab.png b/_static/images/logo_colab.png new file mode 100644 index 000000000..b7560ec21 Binary files /dev/null and b/_static/images/logo_colab.png differ diff --git a/_static/images/logo_deepnote.svg b/_static/images/logo_deepnote.svg new file mode 100644 index 000000000..fa77ebfc2 --- /dev/null +++ b/_static/images/logo_deepnote.svg @@ -0,0 +1 @@ + diff --git a/_static/images/logo_jupyterhub.svg b/_static/images/logo_jupyterhub.svg new file mode 100644 index 000000000..60cfe9f22 --- /dev/null +++ b/_static/images/logo_jupyterhub.svg @@ -0,0 +1 @@ +logo_jupyterhubHub diff --git a/_static/jquery-3.6.0.js b/_static/jquery-3.6.0.js new file mode 100644 index 000000000..fc6c299b7 --- /dev/null +++ b/_static/jquery-3.6.0.js @@ -0,0 +1,10881 @@ +/*! + * jQuery JavaScript Library v3.6.0 + * https://jquery.com/ + * + * Includes Sizzle.js + * https://sizzlejs.com/ + * + * Copyright OpenJS Foundation and other contributors + * Released under the MIT license + * https://jquery.org/license + * + * Date: 2021-03-02T17:08Z + */ +( function( global, factory ) { + + "use strict"; + + if ( typeof module === "object" && typeof module.exports === "object" ) { + + // For CommonJS and CommonJS-like environments where a proper `window` + // is present, execute the factory and get jQuery. + // For environments that do not have a `window` with a `document` + // (such as Node.js), expose a factory as module.exports. + // This accentuates the need for the creation of a real `window`. + // e.g. var jQuery = require("jquery")(window); + // See ticket #14549 for more info. + module.exports = global.document ? + factory( global, true ) : + function( w ) { + if ( !w.document ) { + throw new Error( "jQuery requires a window with a document" ); + } + return factory( w ); + }; + } else { + factory( global ); + } + +// Pass this if window is not defined yet +} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { + +// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 +// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode +// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common +// enough that all such attempts are guarded in a try block. +"use strict"; + +var arr = []; + +var getProto = Object.getPrototypeOf; + +var slice = arr.slice; + +var flat = arr.flat ? function( array ) { + return arr.flat.call( array ); +} : function( array ) { + return arr.concat.apply( [], array ); +}; + + +var push = arr.push; + +var indexOf = arr.indexOf; + +var class2type = {}; + +var toString = class2type.toString; + +var hasOwn = class2type.hasOwnProperty; + +var fnToString = hasOwn.toString; + +var ObjectFunctionString = fnToString.call( Object ); + +var support = {}; + +var isFunction = function isFunction( obj ) { + + // Support: Chrome <=57, Firefox <=52 + // In some browsers, typeof returns "function" for HTML elements + // (i.e., `typeof document.createElement( "object" ) === "function"`). + // We don't want to classify *any* DOM node as a function. + // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5 + // Plus for old WebKit, typeof returns "function" for HTML collections + // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756) + return typeof obj === "function" && typeof obj.nodeType !== "number" && + typeof obj.item !== "function"; + }; + + +var isWindow = function isWindow( obj ) { + return obj != null && obj === obj.window; + }; + + +var document = window.document; + + + + var preservedScriptAttributes = { + type: true, + src: true, + nonce: true, + noModule: true + }; + + function DOMEval( code, node, doc ) { + doc = doc || document; + + var i, val, + script = doc.createElement( "script" ); + + script.text = code; + if ( node ) { + for ( i in preservedScriptAttributes ) { + + // Support: Firefox 64+, Edge 18+ + // Some browsers don't support the "nonce" property on scripts. + // On the other hand, just using `getAttribute` is not enough as + // the `nonce` attribute is reset to an empty string whenever it + // becomes browsing-context connected. + // See https://github.com/whatwg/html/issues/2369 + // See https://html.spec.whatwg.org/#nonce-attributes + // The `node.getAttribute` check was added for the sake of + // `jQuery.globalEval` so that it can fake a nonce-containing node + // via an object. + val = node[ i ] || node.getAttribute && node.getAttribute( i ); + if ( val ) { + script.setAttribute( i, val ); + } + } + } + doc.head.appendChild( script ).parentNode.removeChild( script ); + } + + +function toType( obj ) { + if ( obj == null ) { + return obj + ""; + } + + // Support: Android <=2.3 only (functionish RegExp) + return typeof obj === "object" || typeof obj === "function" ? + class2type[ toString.call( obj ) ] || "object" : + typeof obj; +} +/* global Symbol */ +// Defining this global in .eslintrc.json would create a danger of using the global +// unguarded in another place, it seems safer to define global only for this module + + + +var + version = "3.6.0", + + // Define a local copy of jQuery + jQuery = function( selector, context ) { + + // The jQuery object is actually just the init constructor 'enhanced' + // Need init if jQuery is called (just allow error to be thrown if not included) + return new jQuery.fn.init( selector, context ); + }; + +jQuery.fn = jQuery.prototype = { + + // The current version of jQuery being used + jquery: version, + + constructor: jQuery, + + // The default length of a jQuery object is 0 + length: 0, + + toArray: function() { + return slice.call( this ); + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function( num ) { + + // Return all the elements in a clean array + if ( num == null ) { + return slice.call( this ); + } + + // Return just the one element from the set + return num < 0 ? this[ num + this.length ] : this[ num ]; + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function( elems ) { + + // Build a new jQuery matched element set + var ret = jQuery.merge( this.constructor(), elems ); + + // Add the old object onto the stack (as a reference) + ret.prevObject = this; + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched set. + each: function( callback ) { + return jQuery.each( this, callback ); + }, + + map: function( callback ) { + return this.pushStack( jQuery.map( this, function( elem, i ) { + return callback.call( elem, i, elem ); + } ) ); + }, + + slice: function() { + return this.pushStack( slice.apply( this, arguments ) ); + }, + + first: function() { + return this.eq( 0 ); + }, + + last: function() { + return this.eq( -1 ); + }, + + even: function() { + return this.pushStack( jQuery.grep( this, function( _elem, i ) { + return ( i + 1 ) % 2; + } ) ); + }, + + odd: function() { + return this.pushStack( jQuery.grep( this, function( _elem, i ) { + return i % 2; + } ) ); + }, + + eq: function( i ) { + var len = this.length, + j = +i + ( i < 0 ? len : 0 ); + return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); + }, + + end: function() { + return this.prevObject || this.constructor(); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push: push, + sort: arr.sort, + splice: arr.splice +}; + +jQuery.extend = jQuery.fn.extend = function() { + var options, name, src, copy, copyIsArray, clone, + target = arguments[ 0 ] || {}, + i = 1, + length = arguments.length, + deep = false; + + // Handle a deep copy situation + if ( typeof target === "boolean" ) { + deep = target; + + // Skip the boolean and the target + target = arguments[ i ] || {}; + i++; + } + + // Handle case when target is a string or something (possible in deep copy) + if ( typeof target !== "object" && !isFunction( target ) ) { + target = {}; + } + + // Extend jQuery itself if only one argument is passed + if ( i === length ) { + target = this; + i--; + } + + for ( ; i < length; i++ ) { + + // Only deal with non-null/undefined values + if ( ( options = arguments[ i ] ) != null ) { + + // Extend the base object + for ( name in options ) { + copy = options[ name ]; + + // Prevent Object.prototype pollution + // Prevent never-ending loop + if ( name === "__proto__" || target === copy ) { + continue; + } + + // Recurse if we're merging plain objects or arrays + if ( deep && copy && ( jQuery.isPlainObject( copy ) || + ( copyIsArray = Array.isArray( copy ) ) ) ) { + src = target[ name ]; + + // Ensure proper type for the source value + if ( copyIsArray && !Array.isArray( src ) ) { + clone = []; + } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { + clone = {}; + } else { + clone = src; + } + copyIsArray = false; + + // Never move original objects, clone them + target[ name ] = jQuery.extend( deep, clone, copy ); + + // Don't bring in undefined values + } else if ( copy !== undefined ) { + target[ name ] = copy; + } + } + } + } + + // Return the modified object + return target; +}; + +jQuery.extend( { + + // Unique for each copy of jQuery on the page + expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), + + // Assume jQuery is ready without the ready module + isReady: true, + + error: function( msg ) { + throw new Error( msg ); + }, + + noop: function() {}, + + isPlainObject: function( obj ) { + var proto, Ctor; + + // Detect obvious negatives + // Use toString instead of jQuery.type to catch host objects + if ( !obj || toString.call( obj ) !== "[object Object]" ) { + return false; + } + + proto = getProto( obj ); + + // Objects with no prototype (e.g., `Object.create( null )`) are plain + if ( !proto ) { + return true; + } + + // Objects with prototype are plain iff they were constructed by a global Object function + Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; + return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; + }, + + isEmptyObject: function( obj ) { + var name; + + for ( name in obj ) { + return false; + } + return true; + }, + + // Evaluates a script in a provided context; falls back to the global one + // if not specified. + globalEval: function( code, options, doc ) { + DOMEval( code, { nonce: options && options.nonce }, doc ); + }, + + each: function( obj, callback ) { + var length, i = 0; + + if ( isArrayLike( obj ) ) { + length = obj.length; + for ( ; i < length; i++ ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } else { + for ( i in obj ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } + + return obj; + }, + + // results is for internal usage only + makeArray: function( arr, results ) { + var ret = results || []; + + if ( arr != null ) { + if ( isArrayLike( Object( arr ) ) ) { + jQuery.merge( ret, + typeof arr === "string" ? + [ arr ] : arr + ); + } else { + push.call( ret, arr ); + } + } + + return ret; + }, + + inArray: function( elem, arr, i ) { + return arr == null ? -1 : indexOf.call( arr, elem, i ); + }, + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + merge: function( first, second ) { + var len = +second.length, + j = 0, + i = first.length; + + for ( ; j < len; j++ ) { + first[ i++ ] = second[ j ]; + } + + first.length = i; + + return first; + }, + + grep: function( elems, callback, invert ) { + var callbackInverse, + matches = [], + i = 0, + length = elems.length, + callbackExpect = !invert; + + // Go through the array, only saving the items + // that pass the validator function + for ( ; i < length; i++ ) { + callbackInverse = !callback( elems[ i ], i ); + if ( callbackInverse !== callbackExpect ) { + matches.push( elems[ i ] ); + } + } + + return matches; + }, + + // arg is for internal usage only + map: function( elems, callback, arg ) { + var length, value, + i = 0, + ret = []; + + // Go through the array, translating each of the items to their new values + if ( isArrayLike( elems ) ) { + length = elems.length; + for ( ; i < length; i++ ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + + // Go through every key on the object, + } else { + for ( i in elems ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + } + + // Flatten any nested arrays + return flat( ret ); + }, + + // A global GUID counter for objects + guid: 1, + + // jQuery.support is not used in Core but other projects attach their + // properties to it so it needs to exist. + support: support +} ); + +if ( typeof Symbol === "function" ) { + jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; +} + +// Populate the class2type map +jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), + function( _i, name ) { + class2type[ "[object " + name + "]" ] = name.toLowerCase(); + } ); + +function isArrayLike( obj ) { + + // Support: real iOS 8.2 only (not reproducible in simulator) + // `in` check used to prevent JIT error (gh-2145) + // hasOwn isn't used here due to false negatives + // regarding Nodelist length in IE + var length = !!obj && "length" in obj && obj.length, + type = toType( obj ); + + if ( isFunction( obj ) || isWindow( obj ) ) { + return false; + } + + return type === "array" || length === 0 || + typeof length === "number" && length > 0 && ( length - 1 ) in obj; +} +var Sizzle = +/*! + * Sizzle CSS Selector Engine v2.3.6 + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://js.foundation/ + * + * Date: 2021-02-16 + */ +( function( window ) { +var i, + support, + Expr, + getText, + isXML, + tokenize, + compile, + select, + outermostContext, + sortInput, + hasDuplicate, + + // Local document vars + setDocument, + document, + docElem, + documentIsHTML, + rbuggyQSA, + rbuggyMatches, + matches, + contains, + + // Instance-specific data + expando = "sizzle" + 1 * new Date(), + preferredDoc = window.document, + dirruns = 0, + done = 0, + classCache = createCache(), + tokenCache = createCache(), + compilerCache = createCache(), + nonnativeSelectorCache = createCache(), + sortOrder = function( a, b ) { + if ( a === b ) { + hasDuplicate = true; + } + return 0; + }, + + // Instance methods + hasOwn = ( {} ).hasOwnProperty, + arr = [], + pop = arr.pop, + pushNative = arr.push, + push = arr.push, + slice = arr.slice, + + // Use a stripped-down indexOf as it's faster than native + // https://jsperf.com/thor-indexof-vs-for/5 + indexOf = function( list, elem ) { + var i = 0, + len = list.length; + for ( ; i < len; i++ ) { + if ( list[ i ] === elem ) { + return i; + } + } + return -1; + }, + + booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" + + "ismap|loop|multiple|open|readonly|required|scoped", + + // Regular expressions + + // http://www.w3.org/TR/css3-selectors/#whitespace + whitespace = "[\\x20\\t\\r\\n\\f]", + + // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram + identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", + + // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors + attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + + + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + + + // "Attribute values must be CSS identifiers [capture 5] + // or strings [capture 3 or capture 4]" + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + + whitespace + "*\\]", + + pseudos = ":(" + identifier + ")(?:\\((" + + + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: + // 1. quoted (capture 3; capture 4 or capture 5) + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + + + // 2. simple (capture 6) + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + + + // 3. anything else (capture 2) + ".*" + + ")\\)|)", + + // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter + rwhitespace = new RegExp( whitespace + "+", "g" ), + rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + + whitespace + "+$", "g" ), + + rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), + rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + + "*" ), + rdescend = new RegExp( whitespace + "|>" ), + + rpseudo = new RegExp( pseudos ), + ridentifier = new RegExp( "^" + identifier + "$" ), + + matchExpr = { + "ID": new RegExp( "^#(" + identifier + ")" ), + "CLASS": new RegExp( "^\\.(" + identifier + ")" ), + "TAG": new RegExp( "^(" + identifier + "|[*])" ), + "ATTR": new RegExp( "^" + attributes ), + "PSEUDO": new RegExp( "^" + pseudos ), + "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), + "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), + + // For use in libraries implementing .is() + // We use this for POS matching in `select` + "needsContext": new RegExp( "^" + whitespace + + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) + }, + + rhtml = /HTML$/i, + rinputs = /^(?:input|select|textarea|button)$/i, + rheader = /^h\d$/i, + + rnative = /^[^{]+\{\s*\[native \w/, + + // Easily-parseable/retrievable ID or TAG or CLASS selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rsibling = /[+~]/, + + // CSS escapes + // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ), + funescape = function( escape, nonHex ) { + var high = "0x" + escape.slice( 1 ) - 0x10000; + + return nonHex ? + + // Strip the backslash prefix from a non-hex escape sequence + nonHex : + + // Replace a hexadecimal escape sequence with the encoded Unicode code point + // Support: IE <=11+ + // For values outside the Basic Multilingual Plane (BMP), manually construct a + // surrogate pair + high < 0 ? + String.fromCharCode( high + 0x10000 ) : + String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); + }, + + // CSS string/identifier serialization + // https://drafts.csswg.org/cssom/#common-serializing-idioms + rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, + fcssescape = function( ch, asCodePoint ) { + if ( asCodePoint ) { + + // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER + if ( ch === "\0" ) { + return "\uFFFD"; + } + + // Control characters and (dependent upon position) numbers get escaped as code points + return ch.slice( 0, -1 ) + "\\" + + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; + } + + // Other potentially-special ASCII characters get backslash-escaped + return "\\" + ch; + }, + + // Used for iframes + // See setDocument() + // Removing the function wrapper causes a "Permission Denied" + // error in IE + unloadHandler = function() { + setDocument(); + }, + + inDisabledFieldset = addCombinator( + function( elem ) { + return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset"; + }, + { dir: "parentNode", next: "legend" } + ); + +// Optimize for push.apply( _, NodeList ) +try { + push.apply( + ( arr = slice.call( preferredDoc.childNodes ) ), + preferredDoc.childNodes + ); + + // Support: Android<4.0 + // Detect silently failing push.apply + // eslint-disable-next-line no-unused-expressions + arr[ preferredDoc.childNodes.length ].nodeType; +} catch ( e ) { + push = { apply: arr.length ? + + // Leverage slice if possible + function( target, els ) { + pushNative.apply( target, slice.call( els ) ); + } : + + // Support: IE<9 + // Otherwise append directly + function( target, els ) { + var j = target.length, + i = 0; + + // Can't trust NodeList.length + while ( ( target[ j++ ] = els[ i++ ] ) ) {} + target.length = j - 1; + } + }; +} + +function Sizzle( selector, context, results, seed ) { + var m, i, elem, nid, match, groups, newSelector, + newContext = context && context.ownerDocument, + + // nodeType defaults to 9, since context defaults to document + nodeType = context ? context.nodeType : 9; + + results = results || []; + + // Return early from calls with invalid selector or context + if ( typeof selector !== "string" || !selector || + nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { + + return results; + } + + // Try to shortcut find operations (as opposed to filters) in HTML documents + if ( !seed ) { + setDocument( context ); + context = context || document; + + if ( documentIsHTML ) { + + // If the selector is sufficiently simple, try using a "get*By*" DOM method + // (excepting DocumentFragment context, where the methods don't exist) + if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { + + // ID selector + if ( ( m = match[ 1 ] ) ) { + + // Document context + if ( nodeType === 9 ) { + if ( ( elem = context.getElementById( m ) ) ) { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( elem.id === m ) { + results.push( elem ); + return results; + } + } else { + return results; + } + + // Element context + } else { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( newContext && ( elem = newContext.getElementById( m ) ) && + contains( context, elem ) && + elem.id === m ) { + + results.push( elem ); + return results; + } + } + + // Type selector + } else if ( match[ 2 ] ) { + push.apply( results, context.getElementsByTagName( selector ) ); + return results; + + // Class selector + } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName && + context.getElementsByClassName ) { + + push.apply( results, context.getElementsByClassName( m ) ); + return results; + } + } + + // Take advantage of querySelectorAll + if ( support.qsa && + !nonnativeSelectorCache[ selector + " " ] && + ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) && + + // Support: IE 8 only + // Exclude object elements + ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) { + + newSelector = selector; + newContext = context; + + // qSA considers elements outside a scoping root when evaluating child or + // descendant combinators, which is not what we want. + // In such cases, we work around the behavior by prefixing every selector in the + // list with an ID selector referencing the scope context. + // The technique has to be used as well when a leading combinator is used + // as such selectors are not recognized by querySelectorAll. + // Thanks to Andrew Dupont for this technique. + if ( nodeType === 1 && + ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) { + + // Expand context for sibling selectors + newContext = rsibling.test( selector ) && testContext( context.parentNode ) || + context; + + // We can use :scope instead of the ID hack if the browser + // supports it & if we're not changing the context. + if ( newContext !== context || !support.scope ) { + + // Capture the context ID, setting it first if necessary + if ( ( nid = context.getAttribute( "id" ) ) ) { + nid = nid.replace( rcssescape, fcssescape ); + } else { + context.setAttribute( "id", ( nid = expando ) ); + } + } + + // Prefix every selector in the list + groups = tokenize( selector ); + i = groups.length; + while ( i-- ) { + groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + + toSelector( groups[ i ] ); + } + newSelector = groups.join( "," ); + } + + try { + push.apply( results, + newContext.querySelectorAll( newSelector ) + ); + return results; + } catch ( qsaError ) { + nonnativeSelectorCache( selector, true ); + } finally { + if ( nid === expando ) { + context.removeAttribute( "id" ); + } + } + } + } + } + + // All others + return select( selector.replace( rtrim, "$1" ), context, results, seed ); +} + +/** + * Create key-value caches of limited size + * @returns {function(string, object)} Returns the Object data after storing it on itself with + * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) + * deleting the oldest entry + */ +function createCache() { + var keys = []; + + function cache( key, value ) { + + // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) + if ( keys.push( key + " " ) > Expr.cacheLength ) { + + // Only keep the most recent entries + delete cache[ keys.shift() ]; + } + return ( cache[ key + " " ] = value ); + } + return cache; +} + +/** + * Mark a function for special use by Sizzle + * @param {Function} fn The function to mark + */ +function markFunction( fn ) { + fn[ expando ] = true; + return fn; +} + +/** + * Support testing using an element + * @param {Function} fn Passed the created element and returns a boolean result + */ +function assert( fn ) { + var el = document.createElement( "fieldset" ); + + try { + return !!fn( el ); + } catch ( e ) { + return false; + } finally { + + // Remove from its parent by default + if ( el.parentNode ) { + el.parentNode.removeChild( el ); + } + + // release memory in IE + el = null; + } +} + +/** + * Adds the same handler for all of the specified attrs + * @param {String} attrs Pipe-separated list of attributes + * @param {Function} handler The method that will be applied + */ +function addHandle( attrs, handler ) { + var arr = attrs.split( "|" ), + i = arr.length; + + while ( i-- ) { + Expr.attrHandle[ arr[ i ] ] = handler; + } +} + +/** + * Checks document order of two siblings + * @param {Element} a + * @param {Element} b + * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b + */ +function siblingCheck( a, b ) { + var cur = b && a, + diff = cur && a.nodeType === 1 && b.nodeType === 1 && + a.sourceIndex - b.sourceIndex; + + // Use IE sourceIndex if available on both nodes + if ( diff ) { + return diff; + } + + // Check if b follows a + if ( cur ) { + while ( ( cur = cur.nextSibling ) ) { + if ( cur === b ) { + return -1; + } + } + } + + return a ? 1 : -1; +} + +/** + * Returns a function to use in pseudos for input types + * @param {String} type + */ +function createInputPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for buttons + * @param {String} type + */ +function createButtonPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return ( name === "input" || name === "button" ) && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for :enabled/:disabled + * @param {Boolean} disabled true for :disabled; false for :enabled + */ +function createDisabledPseudo( disabled ) { + + // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable + return function( elem ) { + + // Only certain elements can match :enabled or :disabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled + if ( "form" in elem ) { + + // Check for inherited disabledness on relevant non-disabled elements: + // * listed form-associated elements in a disabled fieldset + // https://html.spec.whatwg.org/multipage/forms.html#category-listed + // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled + // * option elements in a disabled optgroup + // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled + // All such elements have a "form" property. + if ( elem.parentNode && elem.disabled === false ) { + + // Option elements defer to a parent optgroup if present + if ( "label" in elem ) { + if ( "label" in elem.parentNode ) { + return elem.parentNode.disabled === disabled; + } else { + return elem.disabled === disabled; + } + } + + // Support: IE 6 - 11 + // Use the isDisabled shortcut property to check for disabled fieldset ancestors + return elem.isDisabled === disabled || + + // Where there is no isDisabled, check manually + /* jshint -W018 */ + elem.isDisabled !== !disabled && + inDisabledFieldset( elem ) === disabled; + } + + return elem.disabled === disabled; + + // Try to winnow out elements that can't be disabled before trusting the disabled property. + // Some victims get caught in our net (label, legend, menu, track), but it shouldn't + // even exist on them, let alone have a boolean value. + } else if ( "label" in elem ) { + return elem.disabled === disabled; + } + + // Remaining elements are neither :enabled nor :disabled + return false; + }; +} + +/** + * Returns a function to use in pseudos for positionals + * @param {Function} fn + */ +function createPositionalPseudo( fn ) { + return markFunction( function( argument ) { + argument = +argument; + return markFunction( function( seed, matches ) { + var j, + matchIndexes = fn( [], seed.length, argument ), + i = matchIndexes.length; + + // Match elements found at the specified indexes + while ( i-- ) { + if ( seed[ ( j = matchIndexes[ i ] ) ] ) { + seed[ j ] = !( matches[ j ] = seed[ j ] ); + } + } + } ); + } ); +} + +/** + * Checks a node for validity as a Sizzle context + * @param {Element|Object=} context + * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value + */ +function testContext( context ) { + return context && typeof context.getElementsByTagName !== "undefined" && context; +} + +// Expose support vars for convenience +support = Sizzle.support = {}; + +/** + * Detects XML nodes + * @param {Element|Object} elem An element or a document + * @returns {Boolean} True iff elem is a non-HTML XML node + */ +isXML = Sizzle.isXML = function( elem ) { + var namespace = elem && elem.namespaceURI, + docElem = elem && ( elem.ownerDocument || elem ).documentElement; + + // Support: IE <=8 + // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes + // https://bugs.jquery.com/ticket/4833 + return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" ); +}; + +/** + * Sets document-related variables once based on the current document + * @param {Element|Object} [doc] An element or document object to use to set the document + * @returns {Object} Returns the current document + */ +setDocument = Sizzle.setDocument = function( node ) { + var hasCompare, subWindow, + doc = node ? node.ownerDocument || node : preferredDoc; + + // Return early if doc is invalid or already selected + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { + return document; + } + + // Update global variables + document = doc; + docElem = document.documentElement; + documentIsHTML = !isXML( document ); + + // Support: IE 9 - 11+, Edge 12 - 18+ + // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( preferredDoc != document && + ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { + + // Support: IE 11, Edge + if ( subWindow.addEventListener ) { + subWindow.addEventListener( "unload", unloadHandler, false ); + + // Support: IE 9 - 10 only + } else if ( subWindow.attachEvent ) { + subWindow.attachEvent( "onunload", unloadHandler ); + } + } + + // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only, + // Safari 4 - 5 only, Opera <=11.6 - 12.x only + // IE/Edge & older browsers don't support the :scope pseudo-class. + // Support: Safari 6.0 only + // Safari 6.0 supports :scope but it's an alias of :root there. + support.scope = assert( function( el ) { + docElem.appendChild( el ).appendChild( document.createElement( "div" ) ); + return typeof el.querySelectorAll !== "undefined" && + !el.querySelectorAll( ":scope fieldset div" ).length; + } ); + + /* Attributes + ---------------------------------------------------------------------- */ + + // Support: IE<8 + // Verify that getAttribute really returns attributes and not properties + // (excepting IE8 booleans) + support.attributes = assert( function( el ) { + el.className = "i"; + return !el.getAttribute( "className" ); + } ); + + /* getElement(s)By* + ---------------------------------------------------------------------- */ + + // Check if getElementsByTagName("*") returns only elements + support.getElementsByTagName = assert( function( el ) { + el.appendChild( document.createComment( "" ) ); + return !el.getElementsByTagName( "*" ).length; + } ); + + // Support: IE<9 + support.getElementsByClassName = rnative.test( document.getElementsByClassName ); + + // Support: IE<10 + // Check if getElementById returns elements by name + // The broken getElementById methods don't pick up programmatically-set names, + // so use a roundabout getElementsByName test + support.getById = assert( function( el ) { + docElem.appendChild( el ).id = expando; + return !document.getElementsByName || !document.getElementsByName( expando ).length; + } ); + + // ID filter and find + if ( support.getById ) { + Expr.filter[ "ID" ] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + return elem.getAttribute( "id" ) === attrId; + }; + }; + Expr.find[ "ID" ] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var elem = context.getElementById( id ); + return elem ? [ elem ] : []; + } + }; + } else { + Expr.filter[ "ID" ] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + var node = typeof elem.getAttributeNode !== "undefined" && + elem.getAttributeNode( "id" ); + return node && node.value === attrId; + }; + }; + + // Support: IE 6 - 7 only + // getElementById is not reliable as a find shortcut + Expr.find[ "ID" ] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var node, i, elems, + elem = context.getElementById( id ); + + if ( elem ) { + + // Verify the id attribute + node = elem.getAttributeNode( "id" ); + if ( node && node.value === id ) { + return [ elem ]; + } + + // Fall back on getElementsByName + elems = context.getElementsByName( id ); + i = 0; + while ( ( elem = elems[ i++ ] ) ) { + node = elem.getAttributeNode( "id" ); + if ( node && node.value === id ) { + return [ elem ]; + } + } + } + + return []; + } + }; + } + + // Tag + Expr.find[ "TAG" ] = support.getElementsByTagName ? + function( tag, context ) { + if ( typeof context.getElementsByTagName !== "undefined" ) { + return context.getElementsByTagName( tag ); + + // DocumentFragment nodes don't have gEBTN + } else if ( support.qsa ) { + return context.querySelectorAll( tag ); + } + } : + + function( tag, context ) { + var elem, + tmp = [], + i = 0, + + // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too + results = context.getElementsByTagName( tag ); + + // Filter out possible comments + if ( tag === "*" ) { + while ( ( elem = results[ i++ ] ) ) { + if ( elem.nodeType === 1 ) { + tmp.push( elem ); + } + } + + return tmp; + } + return results; + }; + + // Class + Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) { + if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { + return context.getElementsByClassName( className ); + } + }; + + /* QSA/matchesSelector + ---------------------------------------------------------------------- */ + + // QSA and matchesSelector support + + // matchesSelector(:active) reports false when true (IE9/Opera 11.5) + rbuggyMatches = []; + + // qSa(:focus) reports false when true (Chrome 21) + // We allow this because of a bug in IE8/9 that throws an error + // whenever `document.activeElement` is accessed on an iframe + // So, we allow :focus to pass through QSA all the time to avoid the IE error + // See https://bugs.jquery.com/ticket/13378 + rbuggyQSA = []; + + if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) { + + // Build QSA regex + // Regex strategy adopted from Diego Perini + assert( function( el ) { + + var input; + + // Select is set to empty string on purpose + // This is to test IE's treatment of not explicitly + // setting a boolean content attribute, + // since its presence should be enough + // https://bugs.jquery.com/ticket/12359 + docElem.appendChild( el ).innerHTML = "" + + ""; + + // Support: IE8, Opera 11-12.16 + // Nothing should be selected when empty strings follow ^= or $= or *= + // The test attribute must be unknown in Opera but "safe" for WinRT + // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section + if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) { + rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); + } + + // Support: IE8 + // Boolean attributes and "value" are not treated correctly + if ( !el.querySelectorAll( "[selected]" ).length ) { + rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); + } + + // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ + if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { + rbuggyQSA.push( "~=" ); + } + + // Support: IE 11+, Edge 15 - 18+ + // IE 11/Edge don't find elements on a `[name='']` query in some cases. + // Adding a temporary attribute to the document before the selection works + // around the issue. + // Interestingly, IE 10 & older don't seem to have the issue. + input = document.createElement( "input" ); + input.setAttribute( "name", "" ); + el.appendChild( input ); + if ( !el.querySelectorAll( "[name='']" ).length ) { + rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + + whitespace + "*(?:''|\"\")" ); + } + + // Webkit/Opera - :checked should return selected option elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + // IE8 throws error here and will not see later tests + if ( !el.querySelectorAll( ":checked" ).length ) { + rbuggyQSA.push( ":checked" ); + } + + // Support: Safari 8+, iOS 8+ + // https://bugs.webkit.org/show_bug.cgi?id=136851 + // In-page `selector#id sibling-combinator selector` fails + if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { + rbuggyQSA.push( ".#.+[+~]" ); + } + + // Support: Firefox <=3.6 - 5 only + // Old Firefox doesn't throw on a badly-escaped identifier. + el.querySelectorAll( "\\\f" ); + rbuggyQSA.push( "[\\r\\n\\f]" ); + } ); + + assert( function( el ) { + el.innerHTML = "" + + ""; + + // Support: Windows 8 Native Apps + // The type and name attributes are restricted during .innerHTML assignment + var input = document.createElement( "input" ); + input.setAttribute( "type", "hidden" ); + el.appendChild( input ).setAttribute( "name", "D" ); + + // Support: IE8 + // Enforce case-sensitivity of name attribute + if ( el.querySelectorAll( "[name=d]" ).length ) { + rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); + } + + // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) + // IE8 throws error here and will not see later tests + if ( el.querySelectorAll( ":enabled" ).length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Support: IE9-11+ + // IE's :disabled selector does not pick up the children of disabled fieldsets + docElem.appendChild( el ).disabled = true; + if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Support: Opera 10 - 11 only + // Opera 10-11 does not throw on post-comma invalid pseudos + el.querySelectorAll( "*,:x" ); + rbuggyQSA.push( ",.*:" ); + } ); + } + + if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches || + docElem.webkitMatchesSelector || + docElem.mozMatchesSelector || + docElem.oMatchesSelector || + docElem.msMatchesSelector ) ) ) ) { + + assert( function( el ) { + + // Check to see if it's possible to do matchesSelector + // on a disconnected node (IE 9) + support.disconnectedMatch = matches.call( el, "*" ); + + // This should fail with an exception + // Gecko does not error, returns false instead + matches.call( el, "[s!='']:x" ); + rbuggyMatches.push( "!=", pseudos ); + } ); + } + + rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); + rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) ); + + /* Contains + ---------------------------------------------------------------------- */ + hasCompare = rnative.test( docElem.compareDocumentPosition ); + + // Element contains another + // Purposefully self-exclusive + // As in, an element does not contain itself + contains = hasCompare || rnative.test( docElem.contains ) ? + function( a, b ) { + var adown = a.nodeType === 9 ? a.documentElement : a, + bup = b && b.parentNode; + return a === bup || !!( bup && bup.nodeType === 1 && ( + adown.contains ? + adown.contains( bup ) : + a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 + ) ); + } : + function( a, b ) { + if ( b ) { + while ( ( b = b.parentNode ) ) { + if ( b === a ) { + return true; + } + } + } + return false; + }; + + /* Sorting + ---------------------------------------------------------------------- */ + + // Document order sorting + sortOrder = hasCompare ? + function( a, b ) { + + // Flag for duplicate removal + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + // Sort on method existence if only one input has compareDocumentPosition + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if ( compare ) { + return compare; + } + + // Calculate position if both inputs belong to the same document + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? + a.compareDocumentPosition( b ) : + + // Otherwise we know they are disconnected + 1; + + // Disconnected nodes + if ( compare & 1 || + ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { + + // Choose the first element that is related to our preferred document + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( a == document || a.ownerDocument == preferredDoc && + contains( preferredDoc, a ) ) { + return -1; + } + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( b == document || b.ownerDocument == preferredDoc && + contains( preferredDoc, b ) ) { + return 1; + } + + // Maintain original order + return sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + } + + return compare & 4 ? -1 : 1; + } : + function( a, b ) { + + // Exit early if the nodes are identical + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + var cur, + i = 0, + aup = a.parentNode, + bup = b.parentNode, + ap = [ a ], + bp = [ b ]; + + // Parentless nodes are either documents or disconnected + if ( !aup || !bup ) { + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + /* eslint-disable eqeqeq */ + return a == document ? -1 : + b == document ? 1 : + /* eslint-enable eqeqeq */ + aup ? -1 : + bup ? 1 : + sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + + // If the nodes are siblings, we can do a quick check + } else if ( aup === bup ) { + return siblingCheck( a, b ); + } + + // Otherwise we need full lists of their ancestors for comparison + cur = a; + while ( ( cur = cur.parentNode ) ) { + ap.unshift( cur ); + } + cur = b; + while ( ( cur = cur.parentNode ) ) { + bp.unshift( cur ); + } + + // Walk down the tree looking for a discrepancy + while ( ap[ i ] === bp[ i ] ) { + i++; + } + + return i ? + + // Do a sibling check if the nodes have a common ancestor + siblingCheck( ap[ i ], bp[ i ] ) : + + // Otherwise nodes in our document sort first + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + /* eslint-disable eqeqeq */ + ap[ i ] == preferredDoc ? -1 : + bp[ i ] == preferredDoc ? 1 : + /* eslint-enable eqeqeq */ + 0; + }; + + return document; +}; + +Sizzle.matches = function( expr, elements ) { + return Sizzle( expr, null, null, elements ); +}; + +Sizzle.matchesSelector = function( elem, expr ) { + setDocument( elem ); + + if ( support.matchesSelector && documentIsHTML && + !nonnativeSelectorCache[ expr + " " ] && + ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && + ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { + + try { + var ret = matches.call( elem, expr ); + + // IE 9's matchesSelector returns false on disconnected nodes + if ( ret || support.disconnectedMatch || + + // As well, disconnected nodes are said to be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11 ) { + return ret; + } + } catch ( e ) { + nonnativeSelectorCache( expr, true ); + } + } + + return Sizzle( expr, document, null, [ elem ] ).length > 0; +}; + +Sizzle.contains = function( context, elem ) { + + // Set document vars if needed + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( ( context.ownerDocument || context ) != document ) { + setDocument( context ); + } + return contains( context, elem ); +}; + +Sizzle.attr = function( elem, name ) { + + // Set document vars if needed + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( ( elem.ownerDocument || elem ) != document ) { + setDocument( elem ); + } + + var fn = Expr.attrHandle[ name.toLowerCase() ], + + // Don't get fooled by Object.prototype properties (jQuery #13807) + val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? + fn( elem, name, !documentIsHTML ) : + undefined; + + return val !== undefined ? + val : + support.attributes || !documentIsHTML ? + elem.getAttribute( name ) : + ( val = elem.getAttributeNode( name ) ) && val.specified ? + val.value : + null; +}; + +Sizzle.escape = function( sel ) { + return ( sel + "" ).replace( rcssescape, fcssescape ); +}; + +Sizzle.error = function( msg ) { + throw new Error( "Syntax error, unrecognized expression: " + msg ); +}; + +/** + * Document sorting and removing duplicates + * @param {ArrayLike} results + */ +Sizzle.uniqueSort = function( results ) { + var elem, + duplicates = [], + j = 0, + i = 0; + + // Unless we *know* we can detect duplicates, assume their presence + hasDuplicate = !support.detectDuplicates; + sortInput = !support.sortStable && results.slice( 0 ); + results.sort( sortOrder ); + + if ( hasDuplicate ) { + while ( ( elem = results[ i++ ] ) ) { + if ( elem === results[ i ] ) { + j = duplicates.push( i ); + } + } + while ( j-- ) { + results.splice( duplicates[ j ], 1 ); + } + } + + // Clear input after sorting to release objects + // See https://github.com/jquery/sizzle/pull/225 + sortInput = null; + + return results; +}; + +/** + * Utility function for retrieving the text value of an array of DOM nodes + * @param {Array|Element} elem + */ +getText = Sizzle.getText = function( elem ) { + var node, + ret = "", + i = 0, + nodeType = elem.nodeType; + + if ( !nodeType ) { + + // If no nodeType, this is expected to be an array + while ( ( node = elem[ i++ ] ) ) { + + // Do not traverse comment nodes + ret += getText( node ); + } + } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { + + // Use textContent for elements + // innerText usage removed for consistency of new lines (jQuery #11153) + if ( typeof elem.textContent === "string" ) { + return elem.textContent; + } else { + + // Traverse its children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + ret += getText( elem ); + } + } + } else if ( nodeType === 3 || nodeType === 4 ) { + return elem.nodeValue; + } + + // Do not include comment or processing instruction nodes + + return ret; +}; + +Expr = Sizzle.selectors = { + + // Can be adjusted by the user + cacheLength: 50, + + createPseudo: markFunction, + + match: matchExpr, + + attrHandle: {}, + + find: {}, + + relative: { + ">": { dir: "parentNode", first: true }, + " ": { dir: "parentNode" }, + "+": { dir: "previousSibling", first: true }, + "~": { dir: "previousSibling" } + }, + + preFilter: { + "ATTR": function( match ) { + match[ 1 ] = match[ 1 ].replace( runescape, funescape ); + + // Move the given value to match[3] whether quoted or unquoted + match[ 3 ] = ( match[ 3 ] || match[ 4 ] || + match[ 5 ] || "" ).replace( runescape, funescape ); + + if ( match[ 2 ] === "~=" ) { + match[ 3 ] = " " + match[ 3 ] + " "; + } + + return match.slice( 0, 4 ); + }, + + "CHILD": function( match ) { + + /* matches from matchExpr["CHILD"] + 1 type (only|nth|...) + 2 what (child|of-type) + 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) + 4 xn-component of xn+y argument ([+-]?\d*n|) + 5 sign of xn-component + 6 x of xn-component + 7 sign of y-component + 8 y of y-component + */ + match[ 1 ] = match[ 1 ].toLowerCase(); + + if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { + + // nth-* requires argument + if ( !match[ 3 ] ) { + Sizzle.error( match[ 0 ] ); + } + + // numeric x and y parameters for Expr.filter.CHILD + // remember that false/true cast respectively to 0/1 + match[ 4 ] = +( match[ 4 ] ? + match[ 5 ] + ( match[ 6 ] || 1 ) : + 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) ); + match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); + + // other types prohibit arguments + } else if ( match[ 3 ] ) { + Sizzle.error( match[ 0 ] ); + } + + return match; + }, + + "PSEUDO": function( match ) { + var excess, + unquoted = !match[ 6 ] && match[ 2 ]; + + if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) { + return null; + } + + // Accept quoted arguments as-is + if ( match[ 3 ] ) { + match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; + + // Strip excess characters from unquoted arguments + } else if ( unquoted && rpseudo.test( unquoted ) && + + // Get excess from tokenize (recursively) + ( excess = tokenize( unquoted, true ) ) && + + // advance to the next closing parenthesis + ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { + + // excess is a negative index + match[ 0 ] = match[ 0 ].slice( 0, excess ); + match[ 2 ] = unquoted.slice( 0, excess ); + } + + // Return only captures needed by the pseudo filter method (type and argument) + return match.slice( 0, 3 ); + } + }, + + filter: { + + "TAG": function( nodeNameSelector ) { + var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); + return nodeNameSelector === "*" ? + function() { + return true; + } : + function( elem ) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + + "CLASS": function( className ) { + var pattern = classCache[ className + " " ]; + + return pattern || + ( pattern = new RegExp( "(^|" + whitespace + + ")" + className + "(" + whitespace + "|$)" ) ) && classCache( + className, function( elem ) { + return pattern.test( + typeof elem.className === "string" && elem.className || + typeof elem.getAttribute !== "undefined" && + elem.getAttribute( "class" ) || + "" + ); + } ); + }, + + "ATTR": function( name, operator, check ) { + return function( elem ) { + var result = Sizzle.attr( elem, name ); + + if ( result == null ) { + return operator === "!="; + } + if ( !operator ) { + return true; + } + + result += ""; + + /* eslint-disable max-len */ + + return operator === "=" ? result === check : + operator === "!=" ? result !== check : + operator === "^=" ? check && result.indexOf( check ) === 0 : + operator === "*=" ? check && result.indexOf( check ) > -1 : + operator === "$=" ? check && result.slice( -check.length ) === check : + operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : + operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : + false; + /* eslint-enable max-len */ + + }; + }, + + "CHILD": function( type, what, _argument, first, last ) { + var simple = type.slice( 0, 3 ) !== "nth", + forward = type.slice( -4 ) !== "last", + ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function( elem ) { + return !!elem.parentNode; + } : + + function( elem, _context, xml ) { + var cache, uniqueCache, outerCache, node, nodeIndex, start, + dir = simple !== forward ? "nextSibling" : "previousSibling", + parent = elem.parentNode, + name = ofType && elem.nodeName.toLowerCase(), + useCache = !xml && !ofType, + diff = false; + + if ( parent ) { + + // :(first|last|only)-(child|of-type) + if ( simple ) { + while ( dir ) { + node = elem; + while ( ( node = node[ dir ] ) ) { + if ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) { + + return false; + } + } + + // Reverse direction for :only-* (if we haven't yet done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) stores cache data on `parent` + if ( forward && useCache ) { + + // Seek `elem` from a previously-cached index + + // ...in a gzip-friendly way + node = parent; + outerCache = node[ expando ] || ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex && cache[ 2 ]; + node = nodeIndex && parent.childNodes[ nodeIndex ]; + + while ( ( node = ++nodeIndex && node && node[ dir ] || + + // Fallback to seeking `elem` from the start + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + // When found, cache indexes on `parent` and break + if ( node.nodeType === 1 && ++diff && node === elem ) { + uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + } else { + + // Use previously-cached element index if available + if ( useCache ) { + + // ...in a gzip-friendly way + node = elem; + outerCache = node[ expando ] || ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex; + } + + // xml :nth-child(...) + // or :nth-last-child(...) or :nth(-last)?-of-type(...) + if ( diff === false ) { + + // Use the same loop as above to seek `elem` from the start + while ( ( node = ++nodeIndex && node && node[ dir ] || + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + if ( ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) && + ++diff ) { + + // Cache the index of each encountered element + if ( useCache ) { + outerCache = node[ expando ] || + ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + uniqueCache[ type ] = [ dirruns, diff ]; + } + + if ( node === elem ) { + break; + } + } + } + } + } + + // Incorporate the offset, then check against cycle size + diff -= last; + return diff === first || ( diff % first === 0 && diff / first >= 0 ); + } + }; + }, + + "PSEUDO": function( pseudo, argument ) { + + // pseudo-class names are case-insensitive + // http://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters + // Remember that setFilters inherits from pseudos + var args, + fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || + Sizzle.error( "unsupported pseudo: " + pseudo ); + + // The user may use createPseudo to indicate that + // arguments are needed to create the filter function + // just as Sizzle does + if ( fn[ expando ] ) { + return fn( argument ); + } + + // But maintain support for old signatures + if ( fn.length > 1 ) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? + markFunction( function( seed, matches ) { + var idx, + matched = fn( seed, argument ), + i = matched.length; + while ( i-- ) { + idx = indexOf( seed, matched[ i ] ); + seed[ idx ] = !( matches[ idx ] = matched[ i ] ); + } + } ) : + function( elem ) { + return fn( elem, 0, args ); + }; + } + + return fn; + } + }, + + pseudos: { + + // Potentially complex pseudos + "not": markFunction( function( selector ) { + + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], + results = [], + matcher = compile( selector.replace( rtrim, "$1" ) ); + + return matcher[ expando ] ? + markFunction( function( seed, matches, _context, xml ) { + var elem, + unmatched = matcher( seed, null, xml, [] ), + i = seed.length; + + // Match elements unmatched by `matcher` + while ( i-- ) { + if ( ( elem = unmatched[ i ] ) ) { + seed[ i ] = !( matches[ i ] = elem ); + } + } + } ) : + function( elem, _context, xml ) { + input[ 0 ] = elem; + matcher( input, null, xml, results ); + + // Don't keep the element (issue #299) + input[ 0 ] = null; + return !results.pop(); + }; + } ), + + "has": markFunction( function( selector ) { + return function( elem ) { + return Sizzle( selector, elem ).length > 0; + }; + } ), + + "contains": markFunction( function( text ) { + text = text.replace( runescape, funescape ); + return function( elem ) { + return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1; + }; + } ), + + // "Whether an element is represented by a :lang() selector + // is based solely on the element's language value + // being equal to the identifier C, + // or beginning with the identifier C immediately followed by "-". + // The matching of C against the element's language value is performed case-insensitively. + // The identifier C does not have to be a valid language name." + // http://www.w3.org/TR/selectors/#lang-pseudo + "lang": markFunction( function( lang ) { + + // lang value must be a valid identifier + if ( !ridentifier.test( lang || "" ) ) { + Sizzle.error( "unsupported lang: " + lang ); + } + lang = lang.replace( runescape, funescape ).toLowerCase(); + return function( elem ) { + var elemLang; + do { + if ( ( elemLang = documentIsHTML ? + elem.lang : + elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; + } + } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); + return false; + }; + } ), + + // Miscellaneous + "target": function( elem ) { + var hash = window.location && window.location.hash; + return hash && hash.slice( 1 ) === elem.id; + }, + + "root": function( elem ) { + return elem === docElem; + }, + + "focus": function( elem ) { + return elem === document.activeElement && + ( !document.hasFocus || document.hasFocus() ) && + !!( elem.type || elem.href || ~elem.tabIndex ); + }, + + // Boolean properties + "enabled": createDisabledPseudo( false ), + "disabled": createDisabledPseudo( true ), + + "checked": function( elem ) { + + // In CSS3, :checked should return both checked and selected elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + var nodeName = elem.nodeName.toLowerCase(); + return ( nodeName === "input" && !!elem.checked ) || + ( nodeName === "option" && !!elem.selected ); + }, + + "selected": function( elem ) { + + // Accessing this property makes selected-by-default + // options in Safari work properly + if ( elem.parentNode ) { + // eslint-disable-next-line no-unused-expressions + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + // Contents + "empty": function( elem ) { + + // http://www.w3.org/TR/selectors/#empty-pseudo + // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), + // but not by others (comment: 8; processing instruction: 7; etc.) + // nodeType < 6 works because attributes (2) do not appear as children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + if ( elem.nodeType < 6 ) { + return false; + } + } + return true; + }, + + "parent": function( elem ) { + return !Expr.pseudos[ "empty" ]( elem ); + }, + + // Element/input types + "header": function( elem ) { + return rheader.test( elem.nodeName ); + }, + + "input": function( elem ) { + return rinputs.test( elem.nodeName ); + }, + + "button": function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === "button" || name === "button"; + }, + + "text": function( elem ) { + var attr; + return elem.nodeName.toLowerCase() === "input" && + elem.type === "text" && + + // Support: IE<8 + // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" + ( ( attr = elem.getAttribute( "type" ) ) == null || + attr.toLowerCase() === "text" ); + }, + + // Position-in-collection + "first": createPositionalPseudo( function() { + return [ 0 ]; + } ), + + "last": createPositionalPseudo( function( _matchIndexes, length ) { + return [ length - 1 ]; + } ), + + "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) { + return [ argument < 0 ? argument + length : argument ]; + } ), + + "even": createPositionalPseudo( function( matchIndexes, length ) { + var i = 0; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "odd": createPositionalPseudo( function( matchIndexes, length ) { + var i = 1; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "lt": createPositionalPseudo( function( matchIndexes, length, argument ) { + var i = argument < 0 ? + argument + length : + argument > length ? + length : + argument; + for ( ; --i >= 0; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "gt": createPositionalPseudo( function( matchIndexes, length, argument ) { + var i = argument < 0 ? argument + length : argument; + for ( ; ++i < length; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ) + } +}; + +Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ]; + +// Add button/input type pseudos +for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { + Expr.pseudos[ i ] = createInputPseudo( i ); +} +for ( i in { submit: true, reset: true } ) { + Expr.pseudos[ i ] = createButtonPseudo( i ); +} + +// Easy API for creating new setFilters +function setFilters() {} +setFilters.prototype = Expr.filters = Expr.pseudos; +Expr.setFilters = new setFilters(); + +tokenize = Sizzle.tokenize = function( selector, parseOnly ) { + var matched, match, tokens, type, + soFar, groups, preFilters, + cached = tokenCache[ selector + " " ]; + + if ( cached ) { + return parseOnly ? 0 : cached.slice( 0 ); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while ( soFar ) { + + // Comma and first run + if ( !matched || ( match = rcomma.exec( soFar ) ) ) { + if ( match ) { + + // Don't consume trailing commas as valid + soFar = soFar.slice( match[ 0 ].length ) || soFar; + } + groups.push( ( tokens = [] ) ); + } + + matched = false; + + // Combinators + if ( ( match = rcombinators.exec( soFar ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + + // Cast descendant combinators to space + type: match[ 0 ].replace( rtrim, " " ) + } ); + soFar = soFar.slice( matched.length ); + } + + // Filters + for ( type in Expr.filter ) { + if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || + ( match = preFilters[ type ]( match ) ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + type: type, + matches: match + } ); + soFar = soFar.slice( matched.length ); + } + } + + if ( !matched ) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + return parseOnly ? + soFar.length : + soFar ? + Sizzle.error( selector ) : + + // Cache the tokens + tokenCache( selector, groups ).slice( 0 ); +}; + +function toSelector( tokens ) { + var i = 0, + len = tokens.length, + selector = ""; + for ( ; i < len; i++ ) { + selector += tokens[ i ].value; + } + return selector; +} + +function addCombinator( matcher, combinator, base ) { + var dir = combinator.dir, + skip = combinator.next, + key = skip || dir, + checkNonElements = base && key === "parentNode", + doneName = done++; + + return combinator.first ? + + // Check against closest ancestor/preceding element + function( elem, context, xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + return matcher( elem, context, xml ); + } + } + return false; + } : + + // Check against all ancestor/preceding elements + function( elem, context, xml ) { + var oldCache, uniqueCache, outerCache, + newCache = [ dirruns, doneName ]; + + // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching + if ( xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + if ( matcher( elem, context, xml ) ) { + return true; + } + } + } + } else { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + outerCache = elem[ expando ] || ( elem[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ elem.uniqueID ] || + ( outerCache[ elem.uniqueID ] = {} ); + + if ( skip && skip === elem.nodeName.toLowerCase() ) { + elem = elem[ dir ] || elem; + } else if ( ( oldCache = uniqueCache[ key ] ) && + oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { + + // Assign to newCache so results back-propagate to previous elements + return ( newCache[ 2 ] = oldCache[ 2 ] ); + } else { + + // Reuse newcache so results back-propagate to previous elements + uniqueCache[ key ] = newCache; + + // A match means we're done; a fail means we have to keep checking + if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { + return true; + } + } + } + } + } + return false; + }; +} + +function elementMatcher( matchers ) { + return matchers.length > 1 ? + function( elem, context, xml ) { + var i = matchers.length; + while ( i-- ) { + if ( !matchers[ i ]( elem, context, xml ) ) { + return false; + } + } + return true; + } : + matchers[ 0 ]; +} + +function multipleContexts( selector, contexts, results ) { + var i = 0, + len = contexts.length; + for ( ; i < len; i++ ) { + Sizzle( selector, contexts[ i ], results ); + } + return results; +} + +function condense( unmatched, map, filter, context, xml ) { + var elem, + newUnmatched = [], + i = 0, + len = unmatched.length, + mapped = map != null; + + for ( ; i < len; i++ ) { + if ( ( elem = unmatched[ i ] ) ) { + if ( !filter || filter( elem, context, xml ) ) { + newUnmatched.push( elem ); + if ( mapped ) { + map.push( i ); + } + } + } + } + + return newUnmatched; +} + +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { + if ( postFilter && !postFilter[ expando ] ) { + postFilter = setMatcher( postFilter ); + } + if ( postFinder && !postFinder[ expando ] ) { + postFinder = setMatcher( postFinder, postSelector ); + } + return markFunction( function( seed, results, context, xml ) { + var temp, i, elem, + preMap = [], + postMap = [], + preexisting = results.length, + + // Get initial elements from seed or context + elems = seed || multipleContexts( + selector || "*", + context.nodeType ? [ context ] : context, + [] + ), + + // Prefilter to get matcher input, preserving a map for seed-results synchronization + matcherIn = preFilter && ( seed || !selector ) ? + condense( elems, preMap, preFilter, context, xml ) : + elems, + + matcherOut = matcher ? + + // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, + postFinder || ( seed ? preFilter : preexisting || postFilter ) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results : + matcherIn; + + // Find primary matches + if ( matcher ) { + matcher( matcherIn, matcherOut, context, xml ); + } + + // Apply postFilter + if ( postFilter ) { + temp = condense( matcherOut, postMap ); + postFilter( temp, [], context, xml ); + + // Un-match failing elements by moving them back to matcherIn + i = temp.length; + while ( i-- ) { + if ( ( elem = temp[ i ] ) ) { + matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); + } + } + } + + if ( seed ) { + if ( postFinder || preFilter ) { + if ( postFinder ) { + + // Get the final matcherOut by condensing this intermediate into postFinder contexts + temp = []; + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) ) { + + // Restore matcherIn since elem is not yet a final match + temp.push( ( matcherIn[ i ] = elem ) ); + } + } + postFinder( null, ( matcherOut = [] ), temp, xml ); + } + + // Move matched elements from seed to results to keep them synchronized + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) && + ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) { + + seed[ temp ] = !( results[ temp ] = elem ); + } + } + } + + // Add elements to results, through postFinder if defined + } else { + matcherOut = condense( + matcherOut === results ? + matcherOut.splice( preexisting, matcherOut.length ) : + matcherOut + ); + if ( postFinder ) { + postFinder( null, results, matcherOut, xml ); + } else { + push.apply( results, matcherOut ); + } + } + } ); +} + +function matcherFromTokens( tokens ) { + var checkContext, matcher, j, + len = tokens.length, + leadingRelative = Expr.relative[ tokens[ 0 ].type ], + implicitRelative = leadingRelative || Expr.relative[ " " ], + i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements are reachable from top-level context(s) + matchContext = addCombinator( function( elem ) { + return elem === checkContext; + }, implicitRelative, true ), + matchAnyContext = addCombinator( function( elem ) { + return indexOf( checkContext, elem ) > -1; + }, implicitRelative, true ), + matchers = [ function( elem, context, xml ) { + var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( + ( checkContext = context ).nodeType ? + matchContext( elem, context, xml ) : + matchAnyContext( elem, context, xml ) ); + + // Avoid hanging onto element (issue #299) + checkContext = null; + return ret; + } ]; + + for ( ; i < len; i++ ) { + if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { + matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; + } else { + matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); + + // Return special upon seeing a positional matcher + if ( matcher[ expando ] ) { + + // Find the next relative operator (if any) for proper handling + j = ++i; + for ( ; j < len; j++ ) { + if ( Expr.relative[ tokens[ j ].type ] ) { + break; + } + } + return setMatcher( + i > 1 && elementMatcher( matchers ), + i > 1 && toSelector( + + // If the preceding token was a descendant combinator, insert an implicit any-element `*` + tokens + .slice( 0, i - 1 ) + .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) + ).replace( rtrim, "$1" ), + matcher, + i < j && matcherFromTokens( tokens.slice( i, j ) ), + j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), + j < len && toSelector( tokens ) + ); + } + matchers.push( matcher ); + } + } + + return elementMatcher( matchers ); +} + +function matcherFromGroupMatchers( elementMatchers, setMatchers ) { + var bySet = setMatchers.length > 0, + byElement = elementMatchers.length > 0, + superMatcher = function( seed, context, xml, results, outermost ) { + var elem, j, matcher, + matchedCount = 0, + i = "0", + unmatched = seed && [], + setMatched = [], + contextBackup = outermostContext, + + // We must always have either seed elements or outermost context + elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ), + + // Use integer dirruns iff this is the outermost matcher + dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), + len = elems.length; + + if ( outermost ) { + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + outermostContext = context == document || context || outermost; + } + + // Add elements passing elementMatchers directly to results + // Support: IE<9, Safari + // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id + for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { + if ( byElement && elem ) { + j = 0; + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( !context && elem.ownerDocument != document ) { + setDocument( elem ); + xml = !documentIsHTML; + } + while ( ( matcher = elementMatchers[ j++ ] ) ) { + if ( matcher( elem, context || document, xml ) ) { + results.push( elem ); + break; + } + } + if ( outermost ) { + dirruns = dirrunsUnique; + } + } + + // Track unmatched elements for set filters + if ( bySet ) { + + // They will have gone through all possible matchers + if ( ( elem = !matcher && elem ) ) { + matchedCount--; + } + + // Lengthen the array for every element, matched or not + if ( seed ) { + unmatched.push( elem ); + } + } + } + + // `i` is now the count of elements visited above, and adding it to `matchedCount` + // makes the latter nonnegative. + matchedCount += i; + + // Apply set filters to unmatched elements + // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` + // equals `i`), unless we didn't visit _any_ elements in the above loop because we have + // no element matchers and no seed. + // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that + // case, which will result in a "00" `matchedCount` that differs from `i` but is also + // numerically zero. + if ( bySet && i !== matchedCount ) { + j = 0; + while ( ( matcher = setMatchers[ j++ ] ) ) { + matcher( unmatched, setMatched, context, xml ); + } + + if ( seed ) { + + // Reintegrate element matches to eliminate the need for sorting + if ( matchedCount > 0 ) { + while ( i-- ) { + if ( !( unmatched[ i ] || setMatched[ i ] ) ) { + setMatched[ i ] = pop.call( results ); + } + } + } + + // Discard index placeholder values to get only actual matches + setMatched = condense( setMatched ); + } + + // Add matches to results + push.apply( results, setMatched ); + + // Seedless set matches succeeding multiple successful matchers stipulate sorting + if ( outermost && !seed && setMatched.length > 0 && + ( matchedCount + setMatchers.length ) > 1 ) { + + Sizzle.uniqueSort( results ); + } + } + + // Override manipulation of globals by nested matchers + if ( outermost ) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? + markFunction( superMatcher ) : + superMatcher; +} + +compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { + var i, + setMatchers = [], + elementMatchers = [], + cached = compilerCache[ selector + " " ]; + + if ( !cached ) { + + // Generate a function of recursive functions that can be used to check each element + if ( !match ) { + match = tokenize( selector ); + } + i = match.length; + while ( i-- ) { + cached = matcherFromTokens( match[ i ] ); + if ( cached[ expando ] ) { + setMatchers.push( cached ); + } else { + elementMatchers.push( cached ); + } + } + + // Cache the compiled function + cached = compilerCache( + selector, + matcherFromGroupMatchers( elementMatchers, setMatchers ) + ); + + // Save selector and tokenization + cached.selector = selector; + } + return cached; +}; + +/** + * A low-level selection function that works with Sizzle's compiled + * selector functions + * @param {String|Function} selector A selector or a pre-compiled + * selector function built with Sizzle.compile + * @param {Element} context + * @param {Array} [results] + * @param {Array} [seed] A set of elements to match against + */ +select = Sizzle.select = function( selector, context, results, seed ) { + var i, tokens, token, type, find, + compiled = typeof selector === "function" && selector, + match = !seed && tokenize( ( selector = compiled.selector || selector ) ); + + results = results || []; + + // Try to minimize operations if there is only one selector in the list and no seed + // (the latter of which guarantees us context) + if ( match.length === 1 ) { + + // Reduce context if the leading compound selector is an ID + tokens = match[ 0 ] = match[ 0 ].slice( 0 ); + if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && + context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { + + context = ( Expr.find[ "ID" ]( token.matches[ 0 ] + .replace( runescape, funescape ), context ) || [] )[ 0 ]; + if ( !context ) { + return results; + + // Precompiled matchers will still verify ancestry, so step up a level + } else if ( compiled ) { + context = context.parentNode; + } + + selector = selector.slice( tokens.shift().value.length ); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length; + while ( i-- ) { + token = tokens[ i ]; + + // Abort if we hit a combinator + if ( Expr.relative[ ( type = token.type ) ] ) { + break; + } + if ( ( find = Expr.find[ type ] ) ) { + + // Search, expanding context for leading sibling combinators + if ( ( seed = find( + token.matches[ 0 ].replace( runescape, funescape ), + rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) || + context + ) ) ) { + + // If seed is empty or no tokens remain, we can return early + tokens.splice( i, 1 ); + selector = seed.length && toSelector( tokens ); + if ( !selector ) { + push.apply( results, seed ); + return results; + } + + break; + } + } + } + } + + // Compile and execute a filtering function if one is not provided + // Provide `match` to avoid retokenization if we modified the selector above + ( compiled || compile( selector, match ) )( + seed, + context, + !documentIsHTML, + results, + !context || rsibling.test( selector ) && testContext( context.parentNode ) || context + ); + return results; +}; + +// One-time assignments + +// Sort stability +support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; + +// Support: Chrome 14-35+ +// Always assume duplicates if they aren't passed to the comparison function +support.detectDuplicates = !!hasDuplicate; + +// Initialize against the default document +setDocument(); + +// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) +// Detached nodes confoundingly follow *each other* +support.sortDetached = assert( function( el ) { + + // Should return 1, but returns 4 (following) + return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; +} ); + +// Support: IE<8 +// Prevent attribute/property "interpolation" +// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx +if ( !assert( function( el ) { + el.innerHTML = ""; + return el.firstChild.getAttribute( "href" ) === "#"; +} ) ) { + addHandle( "type|href|height|width", function( elem, name, isXML ) { + if ( !isXML ) { + return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); + } + } ); +} + +// Support: IE<9 +// Use defaultValue in place of getAttribute("value") +if ( !support.attributes || !assert( function( el ) { + el.innerHTML = ""; + el.firstChild.setAttribute( "value", "" ); + return el.firstChild.getAttribute( "value" ) === ""; +} ) ) { + addHandle( "value", function( elem, _name, isXML ) { + if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { + return elem.defaultValue; + } + } ); +} + +// Support: IE<9 +// Use getAttributeNode to fetch booleans when getAttribute lies +if ( !assert( function( el ) { + return el.getAttribute( "disabled" ) == null; +} ) ) { + addHandle( booleans, function( elem, name, isXML ) { + var val; + if ( !isXML ) { + return elem[ name ] === true ? name.toLowerCase() : + ( val = elem.getAttributeNode( name ) ) && val.specified ? + val.value : + null; + } + } ); +} + +return Sizzle; + +} )( window ); + + + +jQuery.find = Sizzle; +jQuery.expr = Sizzle.selectors; + +// Deprecated +jQuery.expr[ ":" ] = jQuery.expr.pseudos; +jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; +jQuery.text = Sizzle.getText; +jQuery.isXMLDoc = Sizzle.isXML; +jQuery.contains = Sizzle.contains; +jQuery.escapeSelector = Sizzle.escape; + + + + +var dir = function( elem, dir, until ) { + var matched = [], + truncate = until !== undefined; + + while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { + if ( elem.nodeType === 1 ) { + if ( truncate && jQuery( elem ).is( until ) ) { + break; + } + matched.push( elem ); + } + } + return matched; +}; + + +var siblings = function( n, elem ) { + var matched = []; + + for ( ; n; n = n.nextSibling ) { + if ( n.nodeType === 1 && n !== elem ) { + matched.push( n ); + } + } + + return matched; +}; + + +var rneedsContext = jQuery.expr.match.needsContext; + + + +function nodeName( elem, name ) { + + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); + +} +var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); + + + +// Implement the identical functionality for filter and not +function winnow( elements, qualifier, not ) { + if ( isFunction( qualifier ) ) { + return jQuery.grep( elements, function( elem, i ) { + return !!qualifier.call( elem, i, elem ) !== not; + } ); + } + + // Single element + if ( qualifier.nodeType ) { + return jQuery.grep( elements, function( elem ) { + return ( elem === qualifier ) !== not; + } ); + } + + // Arraylike of elements (jQuery, arguments, Array) + if ( typeof qualifier !== "string" ) { + return jQuery.grep( elements, function( elem ) { + return ( indexOf.call( qualifier, elem ) > -1 ) !== not; + } ); + } + + // Filtered directly for both simple and complex selectors + return jQuery.filter( qualifier, elements, not ); +} + +jQuery.filter = function( expr, elems, not ) { + var elem = elems[ 0 ]; + + if ( not ) { + expr = ":not(" + expr + ")"; + } + + if ( elems.length === 1 && elem.nodeType === 1 ) { + return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; + } + + return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { + return elem.nodeType === 1; + } ) ); +}; + +jQuery.fn.extend( { + find: function( selector ) { + var i, ret, + len = this.length, + self = this; + + if ( typeof selector !== "string" ) { + return this.pushStack( jQuery( selector ).filter( function() { + for ( i = 0; i < len; i++ ) { + if ( jQuery.contains( self[ i ], this ) ) { + return true; + } + } + } ) ); + } + + ret = this.pushStack( [] ); + + for ( i = 0; i < len; i++ ) { + jQuery.find( selector, self[ i ], ret ); + } + + return len > 1 ? jQuery.uniqueSort( ret ) : ret; + }, + filter: function( selector ) { + return this.pushStack( winnow( this, selector || [], false ) ); + }, + not: function( selector ) { + return this.pushStack( winnow( this, selector || [], true ) ); + }, + is: function( selector ) { + return !!winnow( + this, + + // If this is a positional/relative selector, check membership in the returned set + // so $("p:first").is("p:last") won't return true for a doc with two "p". + typeof selector === "string" && rneedsContext.test( selector ) ? + jQuery( selector ) : + selector || [], + false + ).length; + } +} ); + + +// Initialize a jQuery object + + +// A central reference to the root jQuery(document) +var rootjQuery, + + // A simple way to check for HTML strings + // Prioritize #id over to avoid XSS via location.hash (#9521) + // Strict HTML recognition (#11290: must start with <) + // Shortcut simple #id case for speed + rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, + + init = jQuery.fn.init = function( selector, context, root ) { + var match, elem; + + // HANDLE: $(""), $(null), $(undefined), $(false) + if ( !selector ) { + return this; + } + + // Method init() accepts an alternate rootjQuery + // so migrate can support jQuery.sub (gh-2101) + root = root || rootjQuery; + + // Handle HTML strings + if ( typeof selector === "string" ) { + if ( selector[ 0 ] === "<" && + selector[ selector.length - 1 ] === ">" && + selector.length >= 3 ) { + + // Assume that strings that start and end with <> are HTML and skip the regex check + match = [ null, selector, null ]; + + } else { + match = rquickExpr.exec( selector ); + } + + // Match html or make sure no context is specified for #id + if ( match && ( match[ 1 ] || !context ) ) { + + // HANDLE: $(html) -> $(array) + if ( match[ 1 ] ) { + context = context instanceof jQuery ? context[ 0 ] : context; + + // Option to run scripts is true for back-compat + // Intentionally let the error be thrown if parseHTML is not present + jQuery.merge( this, jQuery.parseHTML( + match[ 1 ], + context && context.nodeType ? context.ownerDocument || context : document, + true + ) ); + + // HANDLE: $(html, props) + if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { + for ( match in context ) { + + // Properties of context are called as methods if possible + if ( isFunction( this[ match ] ) ) { + this[ match ]( context[ match ] ); + + // ...and otherwise set as attributes + } else { + this.attr( match, context[ match ] ); + } + } + } + + return this; + + // HANDLE: $(#id) + } else { + elem = document.getElementById( match[ 2 ] ); + + if ( elem ) { + + // Inject the element directly into the jQuery object + this[ 0 ] = elem; + this.length = 1; + } + return this; + } + + // HANDLE: $(expr, $(...)) + } else if ( !context || context.jquery ) { + return ( context || root ).find( selector ); + + // HANDLE: $(expr, context) + // (which is just equivalent to: $(context).find(expr) + } else { + return this.constructor( context ).find( selector ); + } + + // HANDLE: $(DOMElement) + } else if ( selector.nodeType ) { + this[ 0 ] = selector; + this.length = 1; + return this; + + // HANDLE: $(function) + // Shortcut for document ready + } else if ( isFunction( selector ) ) { + return root.ready !== undefined ? + root.ready( selector ) : + + // Execute immediately if ready is not present + selector( jQuery ); + } + + return jQuery.makeArray( selector, this ); + }; + +// Give the init function the jQuery prototype for later instantiation +init.prototype = jQuery.fn; + +// Initialize central reference +rootjQuery = jQuery( document ); + + +var rparentsprev = /^(?:parents|prev(?:Until|All))/, + + // Methods guaranteed to produce a unique set when starting from a unique set + guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + +jQuery.fn.extend( { + has: function( target ) { + var targets = jQuery( target, this ), + l = targets.length; + + return this.filter( function() { + var i = 0; + for ( ; i < l; i++ ) { + if ( jQuery.contains( this, targets[ i ] ) ) { + return true; + } + } + } ); + }, + + closest: function( selectors, context ) { + var cur, + i = 0, + l = this.length, + matched = [], + targets = typeof selectors !== "string" && jQuery( selectors ); + + // Positional selectors never match, since there's no _selection_ context + if ( !rneedsContext.test( selectors ) ) { + for ( ; i < l; i++ ) { + for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { + + // Always skip document fragments + if ( cur.nodeType < 11 && ( targets ? + targets.index( cur ) > -1 : + + // Don't pass non-elements to Sizzle + cur.nodeType === 1 && + jQuery.find.matchesSelector( cur, selectors ) ) ) { + + matched.push( cur ); + break; + } + } + } + } + + return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); + }, + + // Determine the position of an element within the set + index: function( elem ) { + + // No argument, return index in parent + if ( !elem ) { + return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; + } + + // Index in selector + if ( typeof elem === "string" ) { + return indexOf.call( jQuery( elem ), this[ 0 ] ); + } + + // Locate the position of the desired element + return indexOf.call( this, + + // If it receives a jQuery object, the first element is used + elem.jquery ? elem[ 0 ] : elem + ); + }, + + add: function( selector, context ) { + return this.pushStack( + jQuery.uniqueSort( + jQuery.merge( this.get(), jQuery( selector, context ) ) + ) + ); + }, + + addBack: function( selector ) { + return this.add( selector == null ? + this.prevObject : this.prevObject.filter( selector ) + ); + } +} ); + +function sibling( cur, dir ) { + while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} + return cur; +} + +jQuery.each( { + parent: function( elem ) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents: function( elem ) { + return dir( elem, "parentNode" ); + }, + parentsUntil: function( elem, _i, until ) { + return dir( elem, "parentNode", until ); + }, + next: function( elem ) { + return sibling( elem, "nextSibling" ); + }, + prev: function( elem ) { + return sibling( elem, "previousSibling" ); + }, + nextAll: function( elem ) { + return dir( elem, "nextSibling" ); + }, + prevAll: function( elem ) { + return dir( elem, "previousSibling" ); + }, + nextUntil: function( elem, _i, until ) { + return dir( elem, "nextSibling", until ); + }, + prevUntil: function( elem, _i, until ) { + return dir( elem, "previousSibling", until ); + }, + siblings: function( elem ) { + return siblings( ( elem.parentNode || {} ).firstChild, elem ); + }, + children: function( elem ) { + return siblings( elem.firstChild ); + }, + contents: function( elem ) { + if ( elem.contentDocument != null && + + // Support: IE 11+ + // elements with no `data` attribute has an object + // `contentDocument` with a `null` prototype. + getProto( elem.contentDocument ) ) { + + return elem.contentDocument; + } + + // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only + // Treat the template element as a regular one in browsers that + // don't support it. + if ( nodeName( elem, "template" ) ) { + elem = elem.content || elem; + } + + return jQuery.merge( [], elem.childNodes ); + } +}, function( name, fn ) { + jQuery.fn[ name ] = function( until, selector ) { + var matched = jQuery.map( this, fn, until ); + + if ( name.slice( -5 ) !== "Until" ) { + selector = until; + } + + if ( selector && typeof selector === "string" ) { + matched = jQuery.filter( selector, matched ); + } + + if ( this.length > 1 ) { + + // Remove duplicates + if ( !guaranteedUnique[ name ] ) { + jQuery.uniqueSort( matched ); + } + + // Reverse order for parents* and prev-derivatives + if ( rparentsprev.test( name ) ) { + matched.reverse(); + } + } + + return this.pushStack( matched ); + }; +} ); +var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); + + + +// Convert String-formatted options into Object-formatted ones +function createOptions( options ) { + var object = {}; + jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { + object[ flag ] = true; + } ); + return object; +} + +/* + * Create a callback list using the following parameters: + * + * options: an optional list of space-separated options that will change how + * the callback list behaves or a more traditional option object + * + * By default a callback list will act like an event callback list and can be + * "fired" multiple times. + * + * Possible options: + * + * once: will ensure the callback list can only be fired once (like a Deferred) + * + * memory: will keep track of previous values and will call any callback added + * after the list has been fired right away with the latest "memorized" + * values (like a Deferred) + * + * unique: will ensure a callback can only be added once (no duplicate in the list) + * + * stopOnFalse: interrupt callings when a callback returns false + * + */ +jQuery.Callbacks = function( options ) { + + // Convert options from String-formatted to Object-formatted if needed + // (we check in cache first) + options = typeof options === "string" ? + createOptions( options ) : + jQuery.extend( {}, options ); + + var // Flag to know if list is currently firing + firing, + + // Last fire value for non-forgettable lists + memory, + + // Flag to know if list was already fired + fired, + + // Flag to prevent firing + locked, + + // Actual callback list + list = [], + + // Queue of execution data for repeatable lists + queue = [], + + // Index of currently firing callback (modified by add/remove as needed) + firingIndex = -1, + + // Fire callbacks + fire = function() { + + // Enforce single-firing + locked = locked || options.once; + + // Execute callbacks for all pending executions, + // respecting firingIndex overrides and runtime changes + fired = firing = true; + for ( ; queue.length; firingIndex = -1 ) { + memory = queue.shift(); + while ( ++firingIndex < list.length ) { + + // Run callback and check for early termination + if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && + options.stopOnFalse ) { + + // Jump to end and forget the data so .add doesn't re-fire + firingIndex = list.length; + memory = false; + } + } + } + + // Forget the data if we're done with it + if ( !options.memory ) { + memory = false; + } + + firing = false; + + // Clean up if we're done firing for good + if ( locked ) { + + // Keep an empty list if we have data for future add calls + if ( memory ) { + list = []; + + // Otherwise, this object is spent + } else { + list = ""; + } + } + }, + + // Actual Callbacks object + self = { + + // Add a callback or a collection of callbacks to the list + add: function() { + if ( list ) { + + // If we have memory from a past run, we should fire after adding + if ( memory && !firing ) { + firingIndex = list.length - 1; + queue.push( memory ); + } + + ( function add( args ) { + jQuery.each( args, function( _, arg ) { + if ( isFunction( arg ) ) { + if ( !options.unique || !self.has( arg ) ) { + list.push( arg ); + } + } else if ( arg && arg.length && toType( arg ) !== "string" ) { + + // Inspect recursively + add( arg ); + } + } ); + } )( arguments ); + + if ( memory && !firing ) { + fire(); + } + } + return this; + }, + + // Remove a callback from the list + remove: function() { + jQuery.each( arguments, function( _, arg ) { + var index; + while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { + list.splice( index, 1 ); + + // Handle firing indexes + if ( index <= firingIndex ) { + firingIndex--; + } + } + } ); + return this; + }, + + // Check if a given callback is in the list. + // If no argument is given, return whether or not list has callbacks attached. + has: function( fn ) { + return fn ? + jQuery.inArray( fn, list ) > -1 : + list.length > 0; + }, + + // Remove all callbacks from the list + empty: function() { + if ( list ) { + list = []; + } + return this; + }, + + // Disable .fire and .add + // Abort any current/pending executions + // Clear all callbacks and values + disable: function() { + locked = queue = []; + list = memory = ""; + return this; + }, + disabled: function() { + return !list; + }, + + // Disable .fire + // Also disable .add unless we have memory (since it would have no effect) + // Abort any pending executions + lock: function() { + locked = queue = []; + if ( !memory && !firing ) { + list = memory = ""; + } + return this; + }, + locked: function() { + return !!locked; + }, + + // Call all callbacks with the given context and arguments + fireWith: function( context, args ) { + if ( !locked ) { + args = args || []; + args = [ context, args.slice ? args.slice() : args ]; + queue.push( args ); + if ( !firing ) { + fire(); + } + } + return this; + }, + + // Call all the callbacks with the given arguments + fire: function() { + self.fireWith( this, arguments ); + return this; + }, + + // To know if the callbacks have already been called at least once + fired: function() { + return !!fired; + } + }; + + return self; +}; + + +function Identity( v ) { + return v; +} +function Thrower( ex ) { + throw ex; +} + +function adoptValue( value, resolve, reject, noValue ) { + var method; + + try { + + // Check for promise aspect first to privilege synchronous behavior + if ( value && isFunction( ( method = value.promise ) ) ) { + method.call( value ).done( resolve ).fail( reject ); + + // Other thenables + } else if ( value && isFunction( ( method = value.then ) ) ) { + method.call( value, resolve, reject ); + + // Other non-thenables + } else { + + // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: + // * false: [ value ].slice( 0 ) => resolve( value ) + // * true: [ value ].slice( 1 ) => resolve() + resolve.apply( undefined, [ value ].slice( noValue ) ); + } + + // For Promises/A+, convert exceptions into rejections + // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in + // Deferred#then to conditionally suppress rejection. + } catch ( value ) { + + // Support: Android 4.0 only + // Strict mode functions invoked without .call/.apply get global-object context + reject.apply( undefined, [ value ] ); + } +} + +jQuery.extend( { + + Deferred: function( func ) { + var tuples = [ + + // action, add listener, callbacks, + // ... .then handlers, argument index, [final state] + [ "notify", "progress", jQuery.Callbacks( "memory" ), + jQuery.Callbacks( "memory" ), 2 ], + [ "resolve", "done", jQuery.Callbacks( "once memory" ), + jQuery.Callbacks( "once memory" ), 0, "resolved" ], + [ "reject", "fail", jQuery.Callbacks( "once memory" ), + jQuery.Callbacks( "once memory" ), 1, "rejected" ] + ], + state = "pending", + promise = { + state: function() { + return state; + }, + always: function() { + deferred.done( arguments ).fail( arguments ); + return this; + }, + "catch": function( fn ) { + return promise.then( null, fn ); + }, + + // Keep pipe for back-compat + pipe: function( /* fnDone, fnFail, fnProgress */ ) { + var fns = arguments; + + return jQuery.Deferred( function( newDefer ) { + jQuery.each( tuples, function( _i, tuple ) { + + // Map tuples (progress, done, fail) to arguments (done, fail, progress) + var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; + + // deferred.progress(function() { bind to newDefer or newDefer.notify }) + // deferred.done(function() { bind to newDefer or newDefer.resolve }) + // deferred.fail(function() { bind to newDefer or newDefer.reject }) + deferred[ tuple[ 1 ] ]( function() { + var returned = fn && fn.apply( this, arguments ); + if ( returned && isFunction( returned.promise ) ) { + returned.promise() + .progress( newDefer.notify ) + .done( newDefer.resolve ) + .fail( newDefer.reject ); + } else { + newDefer[ tuple[ 0 ] + "With" ]( + this, + fn ? [ returned ] : arguments + ); + } + } ); + } ); + fns = null; + } ).promise(); + }, + then: function( onFulfilled, onRejected, onProgress ) { + var maxDepth = 0; + function resolve( depth, deferred, handler, special ) { + return function() { + var that = this, + args = arguments, + mightThrow = function() { + var returned, then; + + // Support: Promises/A+ section 2.3.3.3.3 + // https://promisesaplus.com/#point-59 + // Ignore double-resolution attempts + if ( depth < maxDepth ) { + return; + } + + returned = handler.apply( that, args ); + + // Support: Promises/A+ section 2.3.1 + // https://promisesaplus.com/#point-48 + if ( returned === deferred.promise() ) { + throw new TypeError( "Thenable self-resolution" ); + } + + // Support: Promises/A+ sections 2.3.3.1, 3.5 + // https://promisesaplus.com/#point-54 + // https://promisesaplus.com/#point-75 + // Retrieve `then` only once + then = returned && + + // Support: Promises/A+ section 2.3.4 + // https://promisesaplus.com/#point-64 + // Only check objects and functions for thenability + ( typeof returned === "object" || + typeof returned === "function" ) && + returned.then; + + // Handle a returned thenable + if ( isFunction( then ) ) { + + // Special processors (notify) just wait for resolution + if ( special ) { + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ) + ); + + // Normal processors (resolve) also hook into progress + } else { + + // ...and disregard older resolution values + maxDepth++; + + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ), + resolve( maxDepth, deferred, Identity, + deferred.notifyWith ) + ); + } + + // Handle all other returned values + } else { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Identity ) { + that = undefined; + args = [ returned ]; + } + + // Process the value(s) + // Default process is resolve + ( special || deferred.resolveWith )( that, args ); + } + }, + + // Only normal processors (resolve) catch and reject exceptions + process = special ? + mightThrow : + function() { + try { + mightThrow(); + } catch ( e ) { + + if ( jQuery.Deferred.exceptionHook ) { + jQuery.Deferred.exceptionHook( e, + process.stackTrace ); + } + + // Support: Promises/A+ section 2.3.3.3.4.1 + // https://promisesaplus.com/#point-61 + // Ignore post-resolution exceptions + if ( depth + 1 >= maxDepth ) { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Thrower ) { + that = undefined; + args = [ e ]; + } + + deferred.rejectWith( that, args ); + } + } + }; + + // Support: Promises/A+ section 2.3.3.3.1 + // https://promisesaplus.com/#point-57 + // Re-resolve promises immediately to dodge false rejection from + // subsequent errors + if ( depth ) { + process(); + } else { + + // Call an optional hook to record the stack, in case of exception + // since it's otherwise lost when execution goes async + if ( jQuery.Deferred.getStackHook ) { + process.stackTrace = jQuery.Deferred.getStackHook(); + } + window.setTimeout( process ); + } + }; + } + + return jQuery.Deferred( function( newDefer ) { + + // progress_handlers.add( ... ) + tuples[ 0 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onProgress ) ? + onProgress : + Identity, + newDefer.notifyWith + ) + ); + + // fulfilled_handlers.add( ... ) + tuples[ 1 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onFulfilled ) ? + onFulfilled : + Identity + ) + ); + + // rejected_handlers.add( ... ) + tuples[ 2 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onRejected ) ? + onRejected : + Thrower + ) + ); + } ).promise(); + }, + + // Get a promise for this deferred + // If obj is provided, the promise aspect is added to the object + promise: function( obj ) { + return obj != null ? jQuery.extend( obj, promise ) : promise; + } + }, + deferred = {}; + + // Add list-specific methods + jQuery.each( tuples, function( i, tuple ) { + var list = tuple[ 2 ], + stateString = tuple[ 5 ]; + + // promise.progress = list.add + // promise.done = list.add + // promise.fail = list.add + promise[ tuple[ 1 ] ] = list.add; + + // Handle state + if ( stateString ) { + list.add( + function() { + + // state = "resolved" (i.e., fulfilled) + // state = "rejected" + state = stateString; + }, + + // rejected_callbacks.disable + // fulfilled_callbacks.disable + tuples[ 3 - i ][ 2 ].disable, + + // rejected_handlers.disable + // fulfilled_handlers.disable + tuples[ 3 - i ][ 3 ].disable, + + // progress_callbacks.lock + tuples[ 0 ][ 2 ].lock, + + // progress_handlers.lock + tuples[ 0 ][ 3 ].lock + ); + } + + // progress_handlers.fire + // fulfilled_handlers.fire + // rejected_handlers.fire + list.add( tuple[ 3 ].fire ); + + // deferred.notify = function() { deferred.notifyWith(...) } + // deferred.resolve = function() { deferred.resolveWith(...) } + // deferred.reject = function() { deferred.rejectWith(...) } + deferred[ tuple[ 0 ] ] = function() { + deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); + return this; + }; + + // deferred.notifyWith = list.fireWith + // deferred.resolveWith = list.fireWith + // deferred.rejectWith = list.fireWith + deferred[ tuple[ 0 ] + "With" ] = list.fireWith; + } ); + + // Make the deferred a promise + promise.promise( deferred ); + + // Call given func if any + if ( func ) { + func.call( deferred, deferred ); + } + + // All done! + return deferred; + }, + + // Deferred helper + when: function( singleValue ) { + var + + // count of uncompleted subordinates + remaining = arguments.length, + + // count of unprocessed arguments + i = remaining, + + // subordinate fulfillment data + resolveContexts = Array( i ), + resolveValues = slice.call( arguments ), + + // the primary Deferred + primary = jQuery.Deferred(), + + // subordinate callback factory + updateFunc = function( i ) { + return function( value ) { + resolveContexts[ i ] = this; + resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; + if ( !( --remaining ) ) { + primary.resolveWith( resolveContexts, resolveValues ); + } + }; + }; + + // Single- and empty arguments are adopted like Promise.resolve + if ( remaining <= 1 ) { + adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject, + !remaining ); + + // Use .then() to unwrap secondary thenables (cf. gh-3000) + if ( primary.state() === "pending" || + isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { + + return primary.then(); + } + } + + // Multiple arguments are aggregated like Promise.all array elements + while ( i-- ) { + adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject ); + } + + return primary.promise(); + } +} ); + + +// These usually indicate a programmer mistake during development, +// warn about them ASAP rather than swallowing them by default. +var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; + +jQuery.Deferred.exceptionHook = function( error, stack ) { + + // Support: IE 8 - 9 only + // Console exists when dev tools are open, which can happen at any time + if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { + window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); + } +}; + + + + +jQuery.readyException = function( error ) { + window.setTimeout( function() { + throw error; + } ); +}; + + + + +// The deferred used on DOM ready +var readyList = jQuery.Deferred(); + +jQuery.fn.ready = function( fn ) { + + readyList + .then( fn ) + + // Wrap jQuery.readyException in a function so that the lookup + // happens at the time of error handling instead of callback + // registration. + .catch( function( error ) { + jQuery.readyException( error ); + } ); + + return this; +}; + +jQuery.extend( { + + // Is the DOM ready to be used? Set to true once it occurs. + isReady: false, + + // A counter to track how many items to wait for before + // the ready event fires. See #6781 + readyWait: 1, + + // Handle when the DOM is ready + ready: function( wait ) { + + // Abort if there are pending holds or we're already ready + if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { + return; + } + + // Remember that the DOM is ready + jQuery.isReady = true; + + // If a normal DOM Ready event fired, decrement, and wait if need be + if ( wait !== true && --jQuery.readyWait > 0 ) { + return; + } + + // If there are functions bound, to execute + readyList.resolveWith( document, [ jQuery ] ); + } +} ); + +jQuery.ready.then = readyList.then; + +// The ready event handler and self cleanup method +function completed() { + document.removeEventListener( "DOMContentLoaded", completed ); + window.removeEventListener( "load", completed ); + jQuery.ready(); +} + +// Catch cases where $(document).ready() is called +// after the browser event has already occurred. +// Support: IE <=9 - 10 only +// Older IE sometimes signals "interactive" too soon +if ( document.readyState === "complete" || + ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { + + // Handle it asynchronously to allow scripts the opportunity to delay ready + window.setTimeout( jQuery.ready ); + +} else { + + // Use the handy event callback + document.addEventListener( "DOMContentLoaded", completed ); + + // A fallback to window.onload, that will always work + window.addEventListener( "load", completed ); +} + + + + +// Multifunctional method to get and set values of a collection +// The value/s can optionally be executed if it's a function +var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { + var i = 0, + len = elems.length, + bulk = key == null; + + // Sets many values + if ( toType( key ) === "object" ) { + chainable = true; + for ( i in key ) { + access( elems, fn, i, key[ i ], true, emptyGet, raw ); + } + + // Sets one value + } else if ( value !== undefined ) { + chainable = true; + + if ( !isFunction( value ) ) { + raw = true; + } + + if ( bulk ) { + + // Bulk operations run against the entire set + if ( raw ) { + fn.call( elems, value ); + fn = null; + + // ...except when executing function values + } else { + bulk = fn; + fn = function( elem, _key, value ) { + return bulk.call( jQuery( elem ), value ); + }; + } + } + + if ( fn ) { + for ( ; i < len; i++ ) { + fn( + elems[ i ], key, raw ? + value : + value.call( elems[ i ], i, fn( elems[ i ], key ) ) + ); + } + } + } + + if ( chainable ) { + return elems; + } + + // Gets + if ( bulk ) { + return fn.call( elems ); + } + + return len ? fn( elems[ 0 ], key ) : emptyGet; +}; + + +// Matches dashed string for camelizing +var rmsPrefix = /^-ms-/, + rdashAlpha = /-([a-z])/g; + +// Used by camelCase as callback to replace() +function fcamelCase( _all, letter ) { + return letter.toUpperCase(); +} + +// Convert dashed to camelCase; used by the css and data modules +// Support: IE <=9 - 11, Edge 12 - 15 +// Microsoft forgot to hump their vendor prefix (#9572) +function camelCase( string ) { + return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); +} +var acceptData = function( owner ) { + + // Accepts only: + // - Node + // - Node.ELEMENT_NODE + // - Node.DOCUMENT_NODE + // - Object + // - Any + return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); +}; + + + + +function Data() { + this.expando = jQuery.expando + Data.uid++; +} + +Data.uid = 1; + +Data.prototype = { + + cache: function( owner ) { + + // Check if the owner object already has a cache + var value = owner[ this.expando ]; + + // If not, create one + if ( !value ) { + value = {}; + + // We can accept data for non-element nodes in modern browsers, + // but we should not, see #8335. + // Always return an empty object. + if ( acceptData( owner ) ) { + + // If it is a node unlikely to be stringify-ed or looped over + // use plain assignment + if ( owner.nodeType ) { + owner[ this.expando ] = value; + + // Otherwise secure it in a non-enumerable property + // configurable must be true to allow the property to be + // deleted when data is removed + } else { + Object.defineProperty( owner, this.expando, { + value: value, + configurable: true + } ); + } + } + } + + return value; + }, + set: function( owner, data, value ) { + var prop, + cache = this.cache( owner ); + + // Handle: [ owner, key, value ] args + // Always use camelCase key (gh-2257) + if ( typeof data === "string" ) { + cache[ camelCase( data ) ] = value; + + // Handle: [ owner, { properties } ] args + } else { + + // Copy the properties one-by-one to the cache object + for ( prop in data ) { + cache[ camelCase( prop ) ] = data[ prop ]; + } + } + return cache; + }, + get: function( owner, key ) { + return key === undefined ? + this.cache( owner ) : + + // Always use camelCase key (gh-2257) + owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; + }, + access: function( owner, key, value ) { + + // In cases where either: + // + // 1. No key was specified + // 2. A string key was specified, but no value provided + // + // Take the "read" path and allow the get method to determine + // which value to return, respectively either: + // + // 1. The entire cache object + // 2. The data stored at the key + // + if ( key === undefined || + ( ( key && typeof key === "string" ) && value === undefined ) ) { + + return this.get( owner, key ); + } + + // When the key is not a string, or both a key and value + // are specified, set or extend (existing objects) with either: + // + // 1. An object of properties + // 2. A key and value + // + this.set( owner, key, value ); + + // Since the "set" path can have two possible entry points + // return the expected data based on which path was taken[*] + return value !== undefined ? value : key; + }, + remove: function( owner, key ) { + var i, + cache = owner[ this.expando ]; + + if ( cache === undefined ) { + return; + } + + if ( key !== undefined ) { + + // Support array or space separated string of keys + if ( Array.isArray( key ) ) { + + // If key is an array of keys... + // We always set camelCase keys, so remove that. + key = key.map( camelCase ); + } else { + key = camelCase( key ); + + // If a key with the spaces exists, use it. + // Otherwise, create an array by matching non-whitespace + key = key in cache ? + [ key ] : + ( key.match( rnothtmlwhite ) || [] ); + } + + i = key.length; + + while ( i-- ) { + delete cache[ key[ i ] ]; + } + } + + // Remove the expando if there's no more data + if ( key === undefined || jQuery.isEmptyObject( cache ) ) { + + // Support: Chrome <=35 - 45 + // Webkit & Blink performance suffers when deleting properties + // from DOM nodes, so set to undefined instead + // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) + if ( owner.nodeType ) { + owner[ this.expando ] = undefined; + } else { + delete owner[ this.expando ]; + } + } + }, + hasData: function( owner ) { + var cache = owner[ this.expando ]; + return cache !== undefined && !jQuery.isEmptyObject( cache ); + } +}; +var dataPriv = new Data(); + +var dataUser = new Data(); + + + +// Implementation Summary +// +// 1. Enforce API surface and semantic compatibility with 1.9.x branch +// 2. Improve the module's maintainability by reducing the storage +// paths to a single mechanism. +// 3. Use the same single mechanism to support "private" and "user" data. +// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) +// 5. Avoid exposing implementation details on user objects (eg. expando properties) +// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 + +var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, + rmultiDash = /[A-Z]/g; + +function getData( data ) { + if ( data === "true" ) { + return true; + } + + if ( data === "false" ) { + return false; + } + + if ( data === "null" ) { + return null; + } + + // Only convert to a number if it doesn't change the string + if ( data === +data + "" ) { + return +data; + } + + if ( rbrace.test( data ) ) { + return JSON.parse( data ); + } + + return data; +} + +function dataAttr( elem, key, data ) { + var name; + + // If nothing was found internally, try to fetch any + // data from the HTML5 data-* attribute + if ( data === undefined && elem.nodeType === 1 ) { + name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); + data = elem.getAttribute( name ); + + if ( typeof data === "string" ) { + try { + data = getData( data ); + } catch ( e ) {} + + // Make sure we set the data so it isn't changed later + dataUser.set( elem, key, data ); + } else { + data = undefined; + } + } + return data; +} + +jQuery.extend( { + hasData: function( elem ) { + return dataUser.hasData( elem ) || dataPriv.hasData( elem ); + }, + + data: function( elem, name, data ) { + return dataUser.access( elem, name, data ); + }, + + removeData: function( elem, name ) { + dataUser.remove( elem, name ); + }, + + // TODO: Now that all calls to _data and _removeData have been replaced + // with direct calls to dataPriv methods, these can be deprecated. + _data: function( elem, name, data ) { + return dataPriv.access( elem, name, data ); + }, + + _removeData: function( elem, name ) { + dataPriv.remove( elem, name ); + } +} ); + +jQuery.fn.extend( { + data: function( key, value ) { + var i, name, data, + elem = this[ 0 ], + attrs = elem && elem.attributes; + + // Gets all values + if ( key === undefined ) { + if ( this.length ) { + data = dataUser.get( elem ); + + if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { + i = attrs.length; + while ( i-- ) { + + // Support: IE 11 only + // The attrs elements can be null (#14894) + if ( attrs[ i ] ) { + name = attrs[ i ].name; + if ( name.indexOf( "data-" ) === 0 ) { + name = camelCase( name.slice( 5 ) ); + dataAttr( elem, name, data[ name ] ); + } + } + } + dataPriv.set( elem, "hasDataAttrs", true ); + } + } + + return data; + } + + // Sets multiple values + if ( typeof key === "object" ) { + return this.each( function() { + dataUser.set( this, key ); + } ); + } + + return access( this, function( value ) { + var data; + + // The calling jQuery object (element matches) is not empty + // (and therefore has an element appears at this[ 0 ]) and the + // `value` parameter was not undefined. An empty jQuery object + // will result in `undefined` for elem = this[ 0 ] which will + // throw an exception if an attempt to read a data cache is made. + if ( elem && value === undefined ) { + + // Attempt to get data from the cache + // The key will always be camelCased in Data + data = dataUser.get( elem, key ); + if ( data !== undefined ) { + return data; + } + + // Attempt to "discover" the data in + // HTML5 custom data-* attrs + data = dataAttr( elem, key ); + if ( data !== undefined ) { + return data; + } + + // We tried really hard, but the data doesn't exist. + return; + } + + // Set the data... + this.each( function() { + + // We always store the camelCased key + dataUser.set( this, key, value ); + } ); + }, null, value, arguments.length > 1, null, true ); + }, + + removeData: function( key ) { + return this.each( function() { + dataUser.remove( this, key ); + } ); + } +} ); + + +jQuery.extend( { + queue: function( elem, type, data ) { + var queue; + + if ( elem ) { + type = ( type || "fx" ) + "queue"; + queue = dataPriv.get( elem, type ); + + // Speed up dequeue by getting out quickly if this is just a lookup + if ( data ) { + if ( !queue || Array.isArray( data ) ) { + queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); + } else { + queue.push( data ); + } + } + return queue || []; + } + }, + + dequeue: function( elem, type ) { + type = type || "fx"; + + var queue = jQuery.queue( elem, type ), + startLength = queue.length, + fn = queue.shift(), + hooks = jQuery._queueHooks( elem, type ), + next = function() { + jQuery.dequeue( elem, type ); + }; + + // If the fx queue is dequeued, always remove the progress sentinel + if ( fn === "inprogress" ) { + fn = queue.shift(); + startLength--; + } + + if ( fn ) { + + // Add a progress sentinel to prevent the fx queue from being + // automatically dequeued + if ( type === "fx" ) { + queue.unshift( "inprogress" ); + } + + // Clear up the last queue stop function + delete hooks.stop; + fn.call( elem, next, hooks ); + } + + if ( !startLength && hooks ) { + hooks.empty.fire(); + } + }, + + // Not public - generate a queueHooks object, or return the current one + _queueHooks: function( elem, type ) { + var key = type + "queueHooks"; + return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { + empty: jQuery.Callbacks( "once memory" ).add( function() { + dataPriv.remove( elem, [ type + "queue", key ] ); + } ) + } ); + } +} ); + +jQuery.fn.extend( { + queue: function( type, data ) { + var setter = 2; + + if ( typeof type !== "string" ) { + data = type; + type = "fx"; + setter--; + } + + if ( arguments.length < setter ) { + return jQuery.queue( this[ 0 ], type ); + } + + return data === undefined ? + this : + this.each( function() { + var queue = jQuery.queue( this, type, data ); + + // Ensure a hooks for this queue + jQuery._queueHooks( this, type ); + + if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { + jQuery.dequeue( this, type ); + } + } ); + }, + dequeue: function( type ) { + return this.each( function() { + jQuery.dequeue( this, type ); + } ); + }, + clearQueue: function( type ) { + return this.queue( type || "fx", [] ); + }, + + // Get a promise resolved when queues of a certain type + // are emptied (fx is the type by default) + promise: function( type, obj ) { + var tmp, + count = 1, + defer = jQuery.Deferred(), + elements = this, + i = this.length, + resolve = function() { + if ( !( --count ) ) { + defer.resolveWith( elements, [ elements ] ); + } + }; + + if ( typeof type !== "string" ) { + obj = type; + type = undefined; + } + type = type || "fx"; + + while ( i-- ) { + tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); + if ( tmp && tmp.empty ) { + count++; + tmp.empty.add( resolve ); + } + } + resolve(); + return defer.promise( obj ); + } +} ); +var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; + +var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); + + +var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; + +var documentElement = document.documentElement; + + + + var isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ); + }, + composed = { composed: true }; + + // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only + // Check attachment across shadow DOM boundaries when possible (gh-3504) + // Support: iOS 10.0-10.2 only + // Early iOS 10 versions support `attachShadow` but not `getRootNode`, + // leading to errors. We need to check for `getRootNode`. + if ( documentElement.getRootNode ) { + isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ) || + elem.getRootNode( composed ) === elem.ownerDocument; + }; + } +var isHiddenWithinTree = function( elem, el ) { + + // isHiddenWithinTree might be called from jQuery#filter function; + // in that case, element will be second argument + elem = el || elem; + + // Inline style trumps all + return elem.style.display === "none" || + elem.style.display === "" && + + // Otherwise, check computed style + // Support: Firefox <=43 - 45 + // Disconnected elements can have computed display: none, so first confirm that elem is + // in the document. + isAttached( elem ) && + + jQuery.css( elem, "display" ) === "none"; + }; + + + +function adjustCSS( elem, prop, valueParts, tween ) { + var adjusted, scale, + maxIterations = 20, + currentValue = tween ? + function() { + return tween.cur(); + } : + function() { + return jQuery.css( elem, prop, "" ); + }, + initial = currentValue(), + unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), + + // Starting value computation is required for potential unit mismatches + initialInUnit = elem.nodeType && + ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && + rcssNum.exec( jQuery.css( elem, prop ) ); + + if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { + + // Support: Firefox <=54 + // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) + initial = initial / 2; + + // Trust units reported by jQuery.css + unit = unit || initialInUnit[ 3 ]; + + // Iteratively approximate from a nonzero starting point + initialInUnit = +initial || 1; + + while ( maxIterations-- ) { + + // Evaluate and update our best guess (doubling guesses that zero out). + // Finish if the scale equals or crosses 1 (making the old*new product non-positive). + jQuery.style( elem, prop, initialInUnit + unit ); + if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { + maxIterations = 0; + } + initialInUnit = initialInUnit / scale; + + } + + initialInUnit = initialInUnit * 2; + jQuery.style( elem, prop, initialInUnit + unit ); + + // Make sure we update the tween properties later on + valueParts = valueParts || []; + } + + if ( valueParts ) { + initialInUnit = +initialInUnit || +initial || 0; + + // Apply relative offset (+=/-=) if specified + adjusted = valueParts[ 1 ] ? + initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : + +valueParts[ 2 ]; + if ( tween ) { + tween.unit = unit; + tween.start = initialInUnit; + tween.end = adjusted; + } + } + return adjusted; +} + + +var defaultDisplayMap = {}; + +function getDefaultDisplay( elem ) { + var temp, + doc = elem.ownerDocument, + nodeName = elem.nodeName, + display = defaultDisplayMap[ nodeName ]; + + if ( display ) { + return display; + } + + temp = doc.body.appendChild( doc.createElement( nodeName ) ); + display = jQuery.css( temp, "display" ); + + temp.parentNode.removeChild( temp ); + + if ( display === "none" ) { + display = "block"; + } + defaultDisplayMap[ nodeName ] = display; + + return display; +} + +function showHide( elements, show ) { + var display, elem, + values = [], + index = 0, + length = elements.length; + + // Determine new display value for elements that need to change + for ( ; index < length; index++ ) { + elem = elements[ index ]; + if ( !elem.style ) { + continue; + } + + display = elem.style.display; + if ( show ) { + + // Since we force visibility upon cascade-hidden elements, an immediate (and slow) + // check is required in this first loop unless we have a nonempty display value (either + // inline or about-to-be-restored) + if ( display === "none" ) { + values[ index ] = dataPriv.get( elem, "display" ) || null; + if ( !values[ index ] ) { + elem.style.display = ""; + } + } + if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { + values[ index ] = getDefaultDisplay( elem ); + } + } else { + if ( display !== "none" ) { + values[ index ] = "none"; + + // Remember what we're overwriting + dataPriv.set( elem, "display", display ); + } + } + } + + // Set the display of the elements in a second loop to avoid constant reflow + for ( index = 0; index < length; index++ ) { + if ( values[ index ] != null ) { + elements[ index ].style.display = values[ index ]; + } + } + + return elements; +} + +jQuery.fn.extend( { + show: function() { + return showHide( this, true ); + }, + hide: function() { + return showHide( this ); + }, + toggle: function( state ) { + if ( typeof state === "boolean" ) { + return state ? this.show() : this.hide(); + } + + return this.each( function() { + if ( isHiddenWithinTree( this ) ) { + jQuery( this ).show(); + } else { + jQuery( this ).hide(); + } + } ); + } +} ); +var rcheckableType = ( /^(?:checkbox|radio)$/i ); + +var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); + +var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); + + + +( function() { + var fragment = document.createDocumentFragment(), + div = fragment.appendChild( document.createElement( "div" ) ), + input = document.createElement( "input" ); + + // Support: Android 4.0 - 4.3 only + // Check state lost if the name is set (#11217) + // Support: Windows Web Apps (WWA) + // `name` and `type` must use .setAttribute for WWA (#14901) + input.setAttribute( "type", "radio" ); + input.setAttribute( "checked", "checked" ); + input.setAttribute( "name", "t" ); + + div.appendChild( input ); + + // Support: Android <=4.1 only + // Older WebKit doesn't clone checked state correctly in fragments + support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; + + // Support: IE <=11 only + // Make sure textarea (and checkbox) defaultValue is properly cloned + div.innerHTML = ""; + support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; + + // Support: IE <=9 only + // IE <=9 replaces "; + support.option = !!div.lastChild; +} )(); + + +// We have to close these tags to support XHTML (#13200) +var wrapMap = { + + // XHTML parsers do not magically insert elements in the + // same way that tag soup parsers do. So we cannot shorten + // this by omitting or other required elements. + thead: [ 1, "", "
" ], + col: [ 2, "", "
" ], + tr: [ 2, "", "
" ], + td: [ 3, "", "
" ], + + _default: [ 0, "", "" ] +}; + +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; +wrapMap.th = wrapMap.td; + +// Support: IE <=9 only +if ( !support.option ) { + wrapMap.optgroup = wrapMap.option = [ 1, "" ]; +} + + +function getAll( context, tag ) { + + // Support: IE <=9 - 11 only + // Use typeof to avoid zero-argument method invocation on host objects (#15151) + var ret; + + if ( typeof context.getElementsByTagName !== "undefined" ) { + ret = context.getElementsByTagName( tag || "*" ); + + } else if ( typeof context.querySelectorAll !== "undefined" ) { + ret = context.querySelectorAll( tag || "*" ); + + } else { + ret = []; + } + + if ( tag === undefined || tag && nodeName( context, tag ) ) { + return jQuery.merge( [ context ], ret ); + } + + return ret; +} + + +// Mark scripts as having already been evaluated +function setGlobalEval( elems, refElements ) { + var i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + dataPriv.set( + elems[ i ], + "globalEval", + !refElements || dataPriv.get( refElements[ i ], "globalEval" ) + ); + } +} + + +var rhtml = /<|&#?\w+;/; + +function buildFragment( elems, context, scripts, selection, ignored ) { + var elem, tmp, tag, wrap, attached, j, + fragment = context.createDocumentFragment(), + nodes = [], + i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + elem = elems[ i ]; + + if ( elem || elem === 0 ) { + + // Add nodes directly + if ( toType( elem ) === "object" ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); + + // Convert non-html into a text node + } else if ( !rhtml.test( elem ) ) { + nodes.push( context.createTextNode( elem ) ); + + // Convert html into DOM nodes + } else { + tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); + + // Deserialize a standard representation + tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); + wrap = wrapMap[ tag ] || wrapMap._default; + tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; + + // Descend through wrappers to the right content + j = wrap[ 0 ]; + while ( j-- ) { + tmp = tmp.lastChild; + } + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, tmp.childNodes ); + + // Remember the top-level container + tmp = fragment.firstChild; + + // Ensure the created nodes are orphaned (#12392) + tmp.textContent = ""; + } + } + } + + // Remove wrapper from fragment + fragment.textContent = ""; + + i = 0; + while ( ( elem = nodes[ i++ ] ) ) { + + // Skip elements already in the context collection (trac-4087) + if ( selection && jQuery.inArray( elem, selection ) > -1 ) { + if ( ignored ) { + ignored.push( elem ); + } + continue; + } + + attached = isAttached( elem ); + + // Append to fragment + tmp = getAll( fragment.appendChild( elem ), "script" ); + + // Preserve script evaluation history + if ( attached ) { + setGlobalEval( tmp ); + } + + // Capture executables + if ( scripts ) { + j = 0; + while ( ( elem = tmp[ j++ ] ) ) { + if ( rscriptType.test( elem.type || "" ) ) { + scripts.push( elem ); + } + } + } + } + + return fragment; +} + + +var rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + +function returnTrue() { + return true; +} + +function returnFalse() { + return false; +} + +// Support: IE <=9 - 11+ +// focus() and blur() are asynchronous, except when they are no-op. +// So expect focus to be synchronous when the element is already active, +// and blur to be synchronous when the element is not already active. +// (focus and blur are always synchronous in other supported browsers, +// this just defines when we can count on it). +function expectSync( elem, type ) { + return ( elem === safeActiveElement() ) === ( type === "focus" ); +} + +// Support: IE <=9 only +// Accessing document.activeElement can throw unexpectedly +// https://bugs.jquery.com/ticket/13393 +function safeActiveElement() { + try { + return document.activeElement; + } catch ( err ) { } +} + +function on( elem, types, selector, data, fn, one ) { + var origFn, type; + + // Types can be a map of types/handlers + if ( typeof types === "object" ) { + + // ( types-Object, selector, data ) + if ( typeof selector !== "string" ) { + + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for ( type in types ) { + on( elem, type, selector, data, types[ type ], one ); + } + return elem; + } + + if ( data == null && fn == null ) { + + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if ( fn == null ) { + if ( typeof selector === "string" ) { + + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if ( fn === false ) { + fn = returnFalse; + } else if ( !fn ) { + return elem; + } + + if ( one === 1 ) { + origFn = fn; + fn = function( event ) { + + // Can use an empty set, since event contains the info + jQuery().off( event ); + return origFn.apply( this, arguments ); + }; + + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); + } + return elem.each( function() { + jQuery.event.add( this, types, fn, data, selector ); + } ); +} + +/* + * Helper functions for managing events -- not part of the public interface. + * Props to Dean Edwards' addEvent library for many of the ideas. + */ +jQuery.event = { + + global: {}, + + add: function( elem, types, handler, data, selector ) { + + var handleObjIn, eventHandle, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.get( elem ); + + // Only attach events to objects that accept data + if ( !acceptData( elem ) ) { + return; + } + + // Caller can pass in an object of custom data in lieu of the handler + if ( handler.handler ) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + + // Ensure that invalid selectors throw exceptions at attach time + // Evaluate against documentElement in case elem is a non-element node (e.g., document) + if ( selector ) { + jQuery.find.matchesSelector( documentElement, selector ); + } + + // Make sure that the handler has a unique ID, used to find/remove it later + if ( !handler.guid ) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main handler, if this is the first + if ( !( events = elemData.events ) ) { + events = elemData.events = Object.create( null ); + } + if ( !( eventHandle = elemData.handle ) ) { + eventHandle = elemData.handle = function( e ) { + + // Discard the second event of a jQuery.event.trigger() and + // when an event is called after a page has unloaded + return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? + jQuery.event.dispatch.apply( elem, arguments ) : undefined; + }; + } + + // Handle multiple events separated by a space + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // There *must* be a type, no attaching namespace-only handlers + if ( !type ) { + continue; + } + + // If event changes its type, use the special event handlers for the changed type + special = jQuery.event.special[ type ] || {}; + + // If selector defined, determine special event api type, otherwise given type + type = ( selector ? special.delegateType : special.bindType ) || type; + + // Update special based on newly reset type + special = jQuery.event.special[ type ] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend( { + type: type, + origType: origType, + data: data, + handler: handler, + guid: handler.guid, + selector: selector, + needsContext: selector && jQuery.expr.match.needsContext.test( selector ), + namespace: namespaces.join( "." ) + }, handleObjIn ); + + // Init the event handler queue if we're the first + if ( !( handlers = events[ type ] ) ) { + handlers = events[ type ] = []; + handlers.delegateCount = 0; + + // Only use addEventListener if the special events handler returns false + if ( !special.setup || + special.setup.call( elem, data, namespaces, eventHandle ) === false ) { + + if ( elem.addEventListener ) { + elem.addEventListener( type, eventHandle ); + } + } + } + + if ( special.add ) { + special.add.call( elem, handleObj ); + + if ( !handleObj.handler.guid ) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates in front + if ( selector ) { + handlers.splice( handlers.delegateCount++, 0, handleObj ); + } else { + handlers.push( handleObj ); + } + + // Keep track of which events have ever been used, for event optimization + jQuery.event.global[ type ] = true; + } + + }, + + // Detach an event or set of events from an element + remove: function( elem, types, handler, selector, mappedTypes ) { + + var j, origCount, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); + + if ( !elemData || !( events = elemData.events ) ) { + return; + } + + // Once for each type.namespace in types; type may be omitted + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // Unbind all events (on this namespace, if provided) for the element + if ( !type ) { + for ( type in events ) { + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); + } + continue; + } + + special = jQuery.event.special[ type ] || {}; + type = ( selector ? special.delegateType : special.bindType ) || type; + handlers = events[ type ] || []; + tmp = tmp[ 2 ] && + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); + + // Remove matching events + origCount = j = handlers.length; + while ( j-- ) { + handleObj = handlers[ j ]; + + if ( ( mappedTypes || origType === handleObj.origType ) && + ( !handler || handler.guid === handleObj.guid ) && + ( !tmp || tmp.test( handleObj.namespace ) ) && + ( !selector || selector === handleObj.selector || + selector === "**" && handleObj.selector ) ) { + handlers.splice( j, 1 ); + + if ( handleObj.selector ) { + handlers.delegateCount--; + } + if ( special.remove ) { + special.remove.call( elem, handleObj ); + } + } + } + + // Remove generic event handler if we removed something and no more handlers exist + // (avoids potential for endless recursion during removal of special event handlers) + if ( origCount && !handlers.length ) { + if ( !special.teardown || + special.teardown.call( elem, namespaces, elemData.handle ) === false ) { + + jQuery.removeEvent( elem, type, elemData.handle ); + } + + delete events[ type ]; + } + } + + // Remove data and the expando if it's no longer used + if ( jQuery.isEmptyObject( events ) ) { + dataPriv.remove( elem, "handle events" ); + } + }, + + dispatch: function( nativeEvent ) { + + var i, j, ret, matched, handleObj, handlerQueue, + args = new Array( arguments.length ), + + // Make a writable jQuery.Event from the native event object + event = jQuery.event.fix( nativeEvent ), + + handlers = ( + dataPriv.get( this, "events" ) || Object.create( null ) + )[ event.type ] || [], + special = jQuery.event.special[ event.type ] || {}; + + // Use the fix-ed jQuery.Event rather than the (read-only) native event + args[ 0 ] = event; + + for ( i = 1; i < arguments.length; i++ ) { + args[ i ] = arguments[ i ]; + } + + event.delegateTarget = this; + + // Call the preDispatch hook for the mapped type, and let it bail if desired + if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { + return; + } + + // Determine handlers + handlerQueue = jQuery.event.handlers.call( this, event, handlers ); + + // Run delegates first; they may want to stop propagation beneath us + i = 0; + while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { + event.currentTarget = matched.elem; + + j = 0; + while ( ( handleObj = matched.handlers[ j++ ] ) && + !event.isImmediatePropagationStopped() ) { + + // If the event is namespaced, then each handler is only invoked if it is + // specially universal or its namespaces are a superset of the event's. + if ( !event.rnamespace || handleObj.namespace === false || + event.rnamespace.test( handleObj.namespace ) ) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || + handleObj.handler ).apply( matched.elem, args ); + + if ( ret !== undefined ) { + if ( ( event.result = ret ) === false ) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + // Call the postDispatch hook for the mapped type + if ( special.postDispatch ) { + special.postDispatch.call( this, event ); + } + + return event.result; + }, + + handlers: function( event, handlers ) { + var i, handleObj, sel, matchedHandlers, matchedSelectors, + handlerQueue = [], + delegateCount = handlers.delegateCount, + cur = event.target; + + // Find delegate handlers + if ( delegateCount && + + // Support: IE <=9 + // Black-hole SVG instance trees (trac-13180) + cur.nodeType && + + // Support: Firefox <=42 + // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) + // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click + // Support: IE 11 only + // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) + !( event.type === "click" && event.button >= 1 ) ) { + + for ( ; cur !== this; cur = cur.parentNode || this ) { + + // Don't check non-elements (#13208) + // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) + if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { + matchedHandlers = []; + matchedSelectors = {}; + for ( i = 0; i < delegateCount; i++ ) { + handleObj = handlers[ i ]; + + // Don't conflict with Object.prototype properties (#13203) + sel = handleObj.selector + " "; + + if ( matchedSelectors[ sel ] === undefined ) { + matchedSelectors[ sel ] = handleObj.needsContext ? + jQuery( sel, this ).index( cur ) > -1 : + jQuery.find( sel, this, null, [ cur ] ).length; + } + if ( matchedSelectors[ sel ] ) { + matchedHandlers.push( handleObj ); + } + } + if ( matchedHandlers.length ) { + handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); + } + } + } + } + + // Add the remaining (directly-bound) handlers + cur = this; + if ( delegateCount < handlers.length ) { + handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); + } + + return handlerQueue; + }, + + addProp: function( name, hook ) { + Object.defineProperty( jQuery.Event.prototype, name, { + enumerable: true, + configurable: true, + + get: isFunction( hook ) ? + function() { + if ( this.originalEvent ) { + return hook( this.originalEvent ); + } + } : + function() { + if ( this.originalEvent ) { + return this.originalEvent[ name ]; + } + }, + + set: function( value ) { + Object.defineProperty( this, name, { + enumerable: true, + configurable: true, + writable: true, + value: value + } ); + } + } ); + }, + + fix: function( originalEvent ) { + return originalEvent[ jQuery.expando ] ? + originalEvent : + new jQuery.Event( originalEvent ); + }, + + special: { + load: { + + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + click: { + + // Utilize native event to ensure correct state for checkable inputs + setup: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Claim the first handler + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + // dataPriv.set( el, "click", ... ) + leverageNative( el, "click", returnTrue ); + } + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Force setup before triggering a click + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + leverageNative( el, "click" ); + } + + // Return non-false to allow normal event-path propagation + return true; + }, + + // For cross-browser consistency, suppress native .click() on links + // Also prevent it if we're currently inside a leveraged native-event stack + _default: function( event ) { + var target = event.target; + return rcheckableType.test( target.type ) && + target.click && nodeName( target, "input" ) && + dataPriv.get( target, "click" ) || + nodeName( target, "a" ); + } + }, + + beforeunload: { + postDispatch: function( event ) { + + // Support: Firefox 20+ + // Firefox doesn't alert if the returnValue field is not set. + if ( event.result !== undefined && event.originalEvent ) { + event.originalEvent.returnValue = event.result; + } + } + } + } +}; + +// Ensure the presence of an event listener that handles manually-triggered +// synthetic events by interrupting progress until reinvoked in response to +// *native* events that it fires directly, ensuring that state changes have +// already occurred before other listeners are invoked. +function leverageNative( el, type, expectSync ) { + + // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add + if ( !expectSync ) { + if ( dataPriv.get( el, type ) === undefined ) { + jQuery.event.add( el, type, returnTrue ); + } + return; + } + + // Register the controller as a special universal handler for all event namespaces + dataPriv.set( el, type, false ); + jQuery.event.add( el, type, { + namespace: false, + handler: function( event ) { + var notAsync, result, + saved = dataPriv.get( this, type ); + + if ( ( event.isTrigger & 1 ) && this[ type ] ) { + + // Interrupt processing of the outer synthetic .trigger()ed event + // Saved data should be false in such cases, but might be a leftover capture object + // from an async native handler (gh-4350) + if ( !saved.length ) { + + // Store arguments for use when handling the inner native event + // There will always be at least one argument (an event object), so this array + // will not be confused with a leftover capture object. + saved = slice.call( arguments ); + dataPriv.set( this, type, saved ); + + // Trigger the native event and capture its result + // Support: IE <=9 - 11+ + // focus() and blur() are asynchronous + notAsync = expectSync( this, type ); + this[ type ](); + result = dataPriv.get( this, type ); + if ( saved !== result || notAsync ) { + dataPriv.set( this, type, false ); + } else { + result = {}; + } + if ( saved !== result ) { + + // Cancel the outer synthetic event + event.stopImmediatePropagation(); + event.preventDefault(); + + // Support: Chrome 86+ + // In Chrome, if an element having a focusout handler is blurred by + // clicking outside of it, it invokes the handler synchronously. If + // that handler calls `.remove()` on the element, the data is cleared, + // leaving `result` undefined. We need to guard against this. + return result && result.value; + } + + // If this is an inner synthetic event for an event with a bubbling surrogate + // (focus or blur), assume that the surrogate already propagated from triggering the + // native event and prevent that from happening again here. + // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the + // bubbling surrogate propagates *after* the non-bubbling base), but that seems + // less bad than duplication. + } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { + event.stopPropagation(); + } + + // If this is a native event triggered above, everything is now in order + // Fire an inner synthetic event with the original arguments + } else if ( saved.length ) { + + // ...and capture the result + dataPriv.set( this, type, { + value: jQuery.event.trigger( + + // Support: IE <=9 - 11+ + // Extend with the prototype to reset the above stopImmediatePropagation() + jQuery.extend( saved[ 0 ], jQuery.Event.prototype ), + saved.slice( 1 ), + this + ) + } ); + + // Abort handling of the native event + event.stopImmediatePropagation(); + } + } + } ); +} + +jQuery.removeEvent = function( elem, type, handle ) { + + // This "if" is needed for plain objects + if ( elem.removeEventListener ) { + elem.removeEventListener( type, handle ); + } +}; + +jQuery.Event = function( src, props ) { + + // Allow instantiation without the 'new' keyword + if ( !( this instanceof jQuery.Event ) ) { + return new jQuery.Event( src, props ); + } + + // Event object + if ( src && src.type ) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been marked as prevented + // by a handler lower down the tree; reflect the correct value. + this.isDefaultPrevented = src.defaultPrevented || + src.defaultPrevented === undefined && + + // Support: Android <=2.3 only + src.returnValue === false ? + returnTrue : + returnFalse; + + // Create target properties + // Support: Safari <=6 - 7 only + // Target should not be a text node (#504, #13143) + this.target = ( src.target && src.target.nodeType === 3 ) ? + src.target.parentNode : + src.target; + + this.currentTarget = src.currentTarget; + this.relatedTarget = src.relatedTarget; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event object + if ( props ) { + jQuery.extend( this, props ); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || Date.now(); + + // Mark it as fixed + this[ jQuery.expando ] = true; +}; + +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding +// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html +jQuery.Event.prototype = { + constructor: jQuery.Event, + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + isSimulated: false, + + preventDefault: function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + + if ( e && !this.isSimulated ) { + e.preventDefault(); + } + }, + stopPropagation: function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopPropagation(); + } + }, + stopImmediatePropagation: function() { + var e = this.originalEvent; + + this.isImmediatePropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopImmediatePropagation(); + } + + this.stopPropagation(); + } +}; + +// Includes all common event props including KeyEvent and MouseEvent specific props +jQuery.each( { + altKey: true, + bubbles: true, + cancelable: true, + changedTouches: true, + ctrlKey: true, + detail: true, + eventPhase: true, + metaKey: true, + pageX: true, + pageY: true, + shiftKey: true, + view: true, + "char": true, + code: true, + charCode: true, + key: true, + keyCode: true, + button: true, + buttons: true, + clientX: true, + clientY: true, + offsetX: true, + offsetY: true, + pointerId: true, + pointerType: true, + screenX: true, + screenY: true, + targetTouches: true, + toElement: true, + touches: true, + which: true +}, jQuery.event.addProp ); + +jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { + jQuery.event.special[ type ] = { + + // Utilize native event if possible so blur/focus sequence is correct + setup: function() { + + // Claim the first handler + // dataPriv.set( this, "focus", ... ) + // dataPriv.set( this, "blur", ... ) + leverageNative( this, type, expectSync ); + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function() { + + // Force setup before trigger + leverageNative( this, type ); + + // Return non-false to allow normal event-path propagation + return true; + }, + + // Suppress native focus or blur as it's already being fired + // in leverageNative. + _default: function() { + return true; + }, + + delegateType: delegateType + }; +} ); + +// Create mouseenter/leave events using mouseover/out and event-time checks +// so that event delegation works in jQuery. +// Do the same for pointerenter/pointerleave and pointerover/pointerout +// +// Support: Safari 7 only +// Safari sends mouseenter too often; see: +// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 +// for the description of the bug (it existed in older Chrome versions as well). +jQuery.each( { + mouseenter: "mouseover", + mouseleave: "mouseout", + pointerenter: "pointerover", + pointerleave: "pointerout" +}, function( orig, fix ) { + jQuery.event.special[ orig ] = { + delegateType: fix, + bindType: fix, + + handle: function( event ) { + var ret, + target = this, + related = event.relatedTarget, + handleObj = event.handleObj; + + // For mouseenter/leave call the handler if related is outside the target. + // NB: No relatedTarget if the mouse left/entered the browser window + if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { + event.type = handleObj.origType; + ret = handleObj.handler.apply( this, arguments ); + event.type = fix; + } + return ret; + } + }; +} ); + +jQuery.fn.extend( { + + on: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn ); + }, + one: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn, 1 ); + }, + off: function( types, selector, fn ) { + var handleObj, type; + if ( types && types.preventDefault && types.handleObj ) { + + // ( event ) dispatched jQuery.Event + handleObj = types.handleObj; + jQuery( types.delegateTarget ).off( + handleObj.namespace ? + handleObj.origType + "." + handleObj.namespace : + handleObj.origType, + handleObj.selector, + handleObj.handler + ); + return this; + } + if ( typeof types === "object" ) { + + // ( types-object [, selector] ) + for ( type in types ) { + this.off( type, selector, types[ type ] ); + } + return this; + } + if ( selector === false || typeof selector === "function" ) { + + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if ( fn === false ) { + fn = returnFalse; + } + return this.each( function() { + jQuery.event.remove( this, types, fn, selector ); + } ); + } +} ); + + +var + + // Support: IE <=10 - 11, Edge 12 - 13 only + // In IE/Edge using regex groups here causes severe slowdowns. + // See https://connect.microsoft.com/IE/feedback/details/1736512/ + rnoInnerhtml = /\s*$/g; + +// Prefer a tbody over its parent table for containing new rows +function manipulationTarget( elem, content ) { + if ( nodeName( elem, "table" ) && + nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { + + return jQuery( elem ).children( "tbody" )[ 0 ] || elem; + } + + return elem; +} + +// Replace/restore the type attribute of script elements for safe DOM manipulation +function disableScript( elem ) { + elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; + return elem; +} +function restoreScript( elem ) { + if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { + elem.type = elem.type.slice( 5 ); + } else { + elem.removeAttribute( "type" ); + } + + return elem; +} + +function cloneCopyEvent( src, dest ) { + var i, l, type, pdataOld, udataOld, udataCur, events; + + if ( dest.nodeType !== 1 ) { + return; + } + + // 1. Copy private data: events, handlers, etc. + if ( dataPriv.hasData( src ) ) { + pdataOld = dataPriv.get( src ); + events = pdataOld.events; + + if ( events ) { + dataPriv.remove( dest, "handle events" ); + + for ( type in events ) { + for ( i = 0, l = events[ type ].length; i < l; i++ ) { + jQuery.event.add( dest, type, events[ type ][ i ] ); + } + } + } + } + + // 2. Copy user data + if ( dataUser.hasData( src ) ) { + udataOld = dataUser.access( src ); + udataCur = jQuery.extend( {}, udataOld ); + + dataUser.set( dest, udataCur ); + } +} + +// Fix IE bugs, see support tests +function fixInput( src, dest ) { + var nodeName = dest.nodeName.toLowerCase(); + + // Fails to persist the checked state of a cloned checkbox or radio button. + if ( nodeName === "input" && rcheckableType.test( src.type ) ) { + dest.checked = src.checked; + + // Fails to return the selected option to the default selected state when cloning options + } else if ( nodeName === "input" || nodeName === "textarea" ) { + dest.defaultValue = src.defaultValue; + } +} + +function domManip( collection, args, callback, ignored ) { + + // Flatten any nested arrays + args = flat( args ); + + var fragment, first, scripts, hasScripts, node, doc, + i = 0, + l = collection.length, + iNoClone = l - 1, + value = args[ 0 ], + valueIsFunction = isFunction( value ); + + // We can't cloneNode fragments that contain checked, in WebKit + if ( valueIsFunction || + ( l > 1 && typeof value === "string" && + !support.checkClone && rchecked.test( value ) ) ) { + return collection.each( function( index ) { + var self = collection.eq( index ); + if ( valueIsFunction ) { + args[ 0 ] = value.call( this, index, self.html() ); + } + domManip( self, args, callback, ignored ); + } ); + } + + if ( l ) { + fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); + first = fragment.firstChild; + + if ( fragment.childNodes.length === 1 ) { + fragment = first; + } + + // Require either new content or an interest in ignored elements to invoke the callback + if ( first || ignored ) { + scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); + hasScripts = scripts.length; + + // Use the original fragment for the last item + // instead of the first because it can end up + // being emptied incorrectly in certain situations (#8070). + for ( ; i < l; i++ ) { + node = fragment; + + if ( i !== iNoClone ) { + node = jQuery.clone( node, true, true ); + + // Keep references to cloned scripts for later restoration + if ( hasScripts ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( scripts, getAll( node, "script" ) ); + } + } + + callback.call( collection[ i ], node, i ); + } + + if ( hasScripts ) { + doc = scripts[ scripts.length - 1 ].ownerDocument; + + // Reenable scripts + jQuery.map( scripts, restoreScript ); + + // Evaluate executable scripts on first document insertion + for ( i = 0; i < hasScripts; i++ ) { + node = scripts[ i ]; + if ( rscriptType.test( node.type || "" ) && + !dataPriv.access( node, "globalEval" ) && + jQuery.contains( doc, node ) ) { + + if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { + + // Optional AJAX dependency, but won't run scripts if not present + if ( jQuery._evalUrl && !node.noModule ) { + jQuery._evalUrl( node.src, { + nonce: node.nonce || node.getAttribute( "nonce" ) + }, doc ); + } + } else { + DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); + } + } + } + } + } + } + + return collection; +} + +function remove( elem, selector, keepData ) { + var node, + nodes = selector ? jQuery.filter( selector, elem ) : elem, + i = 0; + + for ( ; ( node = nodes[ i ] ) != null; i++ ) { + if ( !keepData && node.nodeType === 1 ) { + jQuery.cleanData( getAll( node ) ); + } + + if ( node.parentNode ) { + if ( keepData && isAttached( node ) ) { + setGlobalEval( getAll( node, "script" ) ); + } + node.parentNode.removeChild( node ); + } + } + + return elem; +} + +jQuery.extend( { + htmlPrefilter: function( html ) { + return html; + }, + + clone: function( elem, dataAndEvents, deepDataAndEvents ) { + var i, l, srcElements, destElements, + clone = elem.cloneNode( true ), + inPage = isAttached( elem ); + + // Fix IE cloning issues + if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && + !jQuery.isXMLDoc( elem ) ) { + + // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 + destElements = getAll( clone ); + srcElements = getAll( elem ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + fixInput( srcElements[ i ], destElements[ i ] ); + } + } + + // Copy the events from the original to the clone + if ( dataAndEvents ) { + if ( deepDataAndEvents ) { + srcElements = srcElements || getAll( elem ); + destElements = destElements || getAll( clone ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + cloneCopyEvent( srcElements[ i ], destElements[ i ] ); + } + } else { + cloneCopyEvent( elem, clone ); + } + } + + // Preserve script evaluation history + destElements = getAll( clone, "script" ); + if ( destElements.length > 0 ) { + setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); + } + + // Return the cloned set + return clone; + }, + + cleanData: function( elems ) { + var data, elem, type, + special = jQuery.event.special, + i = 0; + + for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { + if ( acceptData( elem ) ) { + if ( ( data = elem[ dataPriv.expando ] ) ) { + if ( data.events ) { + for ( type in data.events ) { + if ( special[ type ] ) { + jQuery.event.remove( elem, type ); + + // This is a shortcut to avoid jQuery.event.remove's overhead + } else { + jQuery.removeEvent( elem, type, data.handle ); + } + } + } + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataPriv.expando ] = undefined; + } + if ( elem[ dataUser.expando ] ) { + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataUser.expando ] = undefined; + } + } + } + } +} ); + +jQuery.fn.extend( { + detach: function( selector ) { + return remove( this, selector, true ); + }, + + remove: function( selector ) { + return remove( this, selector ); + }, + + text: function( value ) { + return access( this, function( value ) { + return value === undefined ? + jQuery.text( this ) : + this.empty().each( function() { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + this.textContent = value; + } + } ); + }, null, value, arguments.length ); + }, + + append: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.appendChild( elem ); + } + } ); + }, + + prepend: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.insertBefore( elem, target.firstChild ); + } + } ); + }, + + before: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this ); + } + } ); + }, + + after: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this.nextSibling ); + } + } ); + }, + + empty: function() { + var elem, + i = 0; + + for ( ; ( elem = this[ i ] ) != null; i++ ) { + if ( elem.nodeType === 1 ) { + + // Prevent memory leaks + jQuery.cleanData( getAll( elem, false ) ); + + // Remove any remaining nodes + elem.textContent = ""; + } + } + + return this; + }, + + clone: function( dataAndEvents, deepDataAndEvents ) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + + return this.map( function() { + return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); + } ); + }, + + html: function( value ) { + return access( this, function( value ) { + var elem = this[ 0 ] || {}, + i = 0, + l = this.length; + + if ( value === undefined && elem.nodeType === 1 ) { + return elem.innerHTML; + } + + // See if we can take a shortcut and just use innerHTML + if ( typeof value === "string" && !rnoInnerhtml.test( value ) && + !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { + + value = jQuery.htmlPrefilter( value ); + + try { + for ( ; i < l; i++ ) { + elem = this[ i ] || {}; + + // Remove element nodes and prevent memory leaks + if ( elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem, false ) ); + elem.innerHTML = value; + } + } + + elem = 0; + + // If using innerHTML throws an exception, use the fallback method + } catch ( e ) {} + } + + if ( elem ) { + this.empty().append( value ); + } + }, null, value, arguments.length ); + }, + + replaceWith: function() { + var ignored = []; + + // Make the changes, replacing each non-ignored context element with the new content + return domManip( this, arguments, function( elem ) { + var parent = this.parentNode; + + if ( jQuery.inArray( this, ignored ) < 0 ) { + jQuery.cleanData( getAll( this ) ); + if ( parent ) { + parent.replaceChild( elem, this ); + } + } + + // Force callback invocation + }, ignored ); + } +} ); + +jQuery.each( { + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" +}, function( name, original ) { + jQuery.fn[ name ] = function( selector ) { + var elems, + ret = [], + insert = jQuery( selector ), + last = insert.length - 1, + i = 0; + + for ( ; i <= last; i++ ) { + elems = i === last ? this : this.clone( true ); + jQuery( insert[ i ] )[ original ]( elems ); + + // Support: Android <=4.0 only, PhantomJS 1 only + // .get() because push.apply(_, arraylike) throws on ancient WebKit + push.apply( ret, elems.get() ); + } + + return this.pushStack( ret ); + }; +} ); +var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); + +var getStyles = function( elem ) { + + // Support: IE <=11 only, Firefox <=30 (#15098, #14150) + // IE throws on elements created in popups + // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" + var view = elem.ownerDocument.defaultView; + + if ( !view || !view.opener ) { + view = window; + } + + return view.getComputedStyle( elem ); + }; + +var swap = function( elem, options, callback ) { + var ret, name, + old = {}; + + // Remember the old values, and insert the new ones + for ( name in options ) { + old[ name ] = elem.style[ name ]; + elem.style[ name ] = options[ name ]; + } + + ret = callback.call( elem ); + + // Revert the old values + for ( name in options ) { + elem.style[ name ] = old[ name ]; + } + + return ret; +}; + + +var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); + + + +( function() { + + // Executing both pixelPosition & boxSizingReliable tests require only one layout + // so they're executed at the same time to save the second computation. + function computeStyleTests() { + + // This is a singleton, we need to execute it only once + if ( !div ) { + return; + } + + container.style.cssText = "position:absolute;left:-11111px;width:60px;" + + "margin-top:1px;padding:0;border:0"; + div.style.cssText = + "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + + "margin:auto;border:1px;padding:1px;" + + "width:60%;top:1%"; + documentElement.appendChild( container ).appendChild( div ); + + var divStyle = window.getComputedStyle( div ); + pixelPositionVal = divStyle.top !== "1%"; + + // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 + reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; + + // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 + // Some styles come back with percentage values, even though they shouldn't + div.style.right = "60%"; + pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; + + // Support: IE 9 - 11 only + // Detect misreporting of content dimensions for box-sizing:border-box elements + boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; + + // Support: IE 9 only + // Detect overflow:scroll screwiness (gh-3699) + // Support: Chrome <=64 + // Don't get tricked when zoom affects offsetWidth (gh-4029) + div.style.position = "absolute"; + scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; + + documentElement.removeChild( container ); + + // Nullify the div so it wouldn't be stored in the memory and + // it will also be a sign that checks already performed + div = null; + } + + function roundPixelMeasures( measure ) { + return Math.round( parseFloat( measure ) ); + } + + var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, + reliableTrDimensionsVal, reliableMarginLeftVal, + container = document.createElement( "div" ), + div = document.createElement( "div" ); + + // Finish early in limited (non-browser) environments + if ( !div.style ) { + return; + } + + // Support: IE <=9 - 11 only + // Style of cloned element affects source element cloned (#8908) + div.style.backgroundClip = "content-box"; + div.cloneNode( true ).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + jQuery.extend( support, { + boxSizingReliable: function() { + computeStyleTests(); + return boxSizingReliableVal; + }, + pixelBoxStyles: function() { + computeStyleTests(); + return pixelBoxStylesVal; + }, + pixelPosition: function() { + computeStyleTests(); + return pixelPositionVal; + }, + reliableMarginLeft: function() { + computeStyleTests(); + return reliableMarginLeftVal; + }, + scrollboxSize: function() { + computeStyleTests(); + return scrollboxSizeVal; + }, + + // Support: IE 9 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Behavior in IE 9 is more subtle than in newer versions & it passes + // some versions of this test; make sure not to make it pass there! + // + // Support: Firefox 70+ + // Only Firefox includes border widths + // in computed dimensions. (gh-4529) + reliableTrDimensions: function() { + var table, tr, trChild, trStyle; + if ( reliableTrDimensionsVal == null ) { + table = document.createElement( "table" ); + tr = document.createElement( "tr" ); + trChild = document.createElement( "div" ); + + table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate"; + tr.style.cssText = "border:1px solid"; + + // Support: Chrome 86+ + // Height set through cssText does not get applied. + // Computed height then comes back as 0. + tr.style.height = "1px"; + trChild.style.height = "9px"; + + // Support: Android 8 Chrome 86+ + // In our bodyBackground.html iframe, + // display for all div elements is set to "inline", + // which causes a problem only in Android 8 Chrome 86. + // Ensuring the div is display: block + // gets around this issue. + trChild.style.display = "block"; + + documentElement + .appendChild( table ) + .appendChild( tr ) + .appendChild( trChild ); + + trStyle = window.getComputedStyle( tr ); + reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) + + parseInt( trStyle.borderTopWidth, 10 ) + + parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight; + + documentElement.removeChild( table ); + } + return reliableTrDimensionsVal; + } + } ); +} )(); + + +function curCSS( elem, name, computed ) { + var width, minWidth, maxWidth, ret, + + // Support: Firefox 51+ + // Retrieving style before computed somehow + // fixes an issue with getting wrong values + // on detached elements + style = elem.style; + + computed = computed || getStyles( elem ); + + // getPropertyValue is needed for: + // .css('filter') (IE 9 only, #12537) + // .css('--customProperty) (#3144) + if ( computed ) { + ret = computed.getPropertyValue( name ) || computed[ name ]; + + if ( ret === "" && !isAttached( elem ) ) { + ret = jQuery.style( elem, name ); + } + + // A tribute to the "awesome hack by Dean Edwards" + // Android Browser returns percentage for some values, + // but width seems to be reliably pixels. + // This is against the CSSOM draft spec: + // https://drafts.csswg.org/cssom/#resolved-values + if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + return ret !== undefined ? + + // Support: IE <=9 - 11 only + // IE returns zIndex value as an integer. + ret + "" : + ret; +} + + +function addGetHookIf( conditionFn, hookFn ) { + + // Define the hook, we'll check on the first run if it's really needed. + return { + get: function() { + if ( conditionFn() ) { + + // Hook not needed (or it's not possible to use it due + // to missing dependency), remove it. + delete this.get; + return; + } + + // Hook needed; redefine it so that the support test is not executed again. + return ( this.get = hookFn ).apply( this, arguments ); + } + }; +} + + +var cssPrefixes = [ "Webkit", "Moz", "ms" ], + emptyStyle = document.createElement( "div" ).style, + vendorProps = {}; + +// Return a vendor-prefixed property or undefined +function vendorPropName( name ) { + + // Check for vendor prefixed names + var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), + i = cssPrefixes.length; + + while ( i-- ) { + name = cssPrefixes[ i ] + capName; + if ( name in emptyStyle ) { + return name; + } + } +} + +// Return a potentially-mapped jQuery.cssProps or vendor prefixed property +function finalPropName( name ) { + var final = jQuery.cssProps[ name ] || vendorProps[ name ]; + + if ( final ) { + return final; + } + if ( name in emptyStyle ) { + return name; + } + return vendorProps[ name ] = vendorPropName( name ) || name; +} + + +var + + // Swappable if display is none or starts with table + // except "table", "table-cell", or "table-caption" + // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, + rcustomProp = /^--/, + cssShow = { position: "absolute", visibility: "hidden", display: "block" }, + cssNormalTransform = { + letterSpacing: "0", + fontWeight: "400" + }; + +function setPositiveNumber( _elem, value, subtract ) { + + // Any relative (+/-) values have already been + // normalized at this point + var matches = rcssNum.exec( value ); + return matches ? + + // Guard against undefined "subtract", e.g., when used as in cssHooks + Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : + value; +} + +function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { + var i = dimension === "width" ? 1 : 0, + extra = 0, + delta = 0; + + // Adjustment may not be necessary + if ( box === ( isBorderBox ? "border" : "content" ) ) { + return 0; + } + + for ( ; i < 4; i += 2 ) { + + // Both box models exclude margin + if ( box === "margin" ) { + delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); + } + + // If we get here with a content-box, we're seeking "padding" or "border" or "margin" + if ( !isBorderBox ) { + + // Add padding + delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + + // For "border" or "margin", add border + if ( box !== "padding" ) { + delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + + // But still keep track of it otherwise + } else { + extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + + // If we get here with a border-box (content + padding + border), we're seeking "content" or + // "padding" or "margin" + } else { + + // For "content", subtract padding + if ( box === "content" ) { + delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + } + + // For "content" or "padding", subtract border + if ( box !== "margin" ) { + delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + } + } + + // Account for positive content-box scroll gutter when requested by providing computedVal + if ( !isBorderBox && computedVal >= 0 ) { + + // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border + // Assuming integer scroll gutter, subtract the rest and round down + delta += Math.max( 0, Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + computedVal - + delta - + extra - + 0.5 + + // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter + // Use an explicit zero to avoid NaN (gh-3964) + ) ) || 0; + } + + return delta; +} + +function getWidthOrHeight( elem, dimension, extra ) { + + // Start with computed style + var styles = getStyles( elem ), + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). + // Fake content-box until we know it's needed to know the true value. + boxSizingNeeded = !support.boxSizingReliable() || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + valueIsBorderBox = isBorderBox, + + val = curCSS( elem, dimension, styles ), + offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); + + // Support: Firefox <=54 + // Return a confounding non-pixel value or feign ignorance, as appropriate. + if ( rnumnonpx.test( val ) ) { + if ( !extra ) { + return val; + } + val = "auto"; + } + + + // Support: IE 9 - 11 only + // Use offsetWidth/offsetHeight for when box sizing is unreliable. + // In those cases, the computed value can be trusted to be border-box. + if ( ( !support.boxSizingReliable() && isBorderBox || + + // Support: IE 10 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Interestingly, in some cases IE 9 doesn't suffer from this issue. + !support.reliableTrDimensions() && nodeName( elem, "tr" ) || + + // Fall back to offsetWidth/offsetHeight when value is "auto" + // This happens for inline elements with no explicit setting (gh-3571) + val === "auto" || + + // Support: Android <=4.1 - 4.3 only + // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) + !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && + + // Make sure the element is visible & connected + elem.getClientRects().length ) { + + isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; + + // Where available, offsetWidth/offsetHeight approximate border box dimensions. + // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the + // retrieved value as a content box dimension. + valueIsBorderBox = offsetProp in elem; + if ( valueIsBorderBox ) { + val = elem[ offsetProp ]; + } + } + + // Normalize "" and auto + val = parseFloat( val ) || 0; + + // Adjust for the element's box model + return ( val + + boxModelAdjustment( + elem, + dimension, + extra || ( isBorderBox ? "border" : "content" ), + valueIsBorderBox, + styles, + + // Provide the current computed size to request scroll gutter calculation (gh-3589) + val + ) + ) + "px"; +} + +jQuery.extend( { + + // Add in style property hooks for overriding the default + // behavior of getting and setting a style property + cssHooks: { + opacity: { + get: function( elem, computed ) { + if ( computed ) { + + // We should always get a number back from opacity + var ret = curCSS( elem, "opacity" ); + return ret === "" ? "1" : ret; + } + } + } + }, + + // Don't automatically add "px" to these possibly-unitless properties + cssNumber: { + "animationIterationCount": true, + "columnCount": true, + "fillOpacity": true, + "flexGrow": true, + "flexShrink": true, + "fontWeight": true, + "gridArea": true, + "gridColumn": true, + "gridColumnEnd": true, + "gridColumnStart": true, + "gridRow": true, + "gridRowEnd": true, + "gridRowStart": true, + "lineHeight": true, + "opacity": true, + "order": true, + "orphans": true, + "widows": true, + "zIndex": true, + "zoom": true + }, + + // Add in properties whose names you wish to fix before + // setting or getting the value + cssProps: {}, + + // Get and set the style property on a DOM Node + style: function( elem, name, value, extra ) { + + // Don't set styles on text and comment nodes + if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { + return; + } + + // Make sure that we're working with the right name + var ret, type, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ), + style = elem.style; + + // Make sure that we're working with the right name. We don't + // want to query the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Gets hook for the prefixed version, then unprefixed version + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // Check if we're setting a value + if ( value !== undefined ) { + type = typeof value; + + // Convert "+=" or "-=" to relative numbers (#7345) + if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { + value = adjustCSS( elem, name, ret ); + + // Fixes bug #9237 + type = "number"; + } + + // Make sure that null and NaN values aren't set (#7116) + if ( value == null || value !== value ) { + return; + } + + // If a number was passed in, add the unit (except for certain CSS properties) + // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append + // "px" to a few hardcoded values. + if ( type === "number" && !isCustomProp ) { + value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); + } + + // background-* props affect original clone's values + if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { + style[ name ] = "inherit"; + } + + // If a hook was provided, use that value, otherwise just set the specified value + if ( !hooks || !( "set" in hooks ) || + ( value = hooks.set( elem, value, extra ) ) !== undefined ) { + + if ( isCustomProp ) { + style.setProperty( name, value ); + } else { + style[ name ] = value; + } + } + + } else { + + // If a hook was provided get the non-computed value from there + if ( hooks && "get" in hooks && + ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { + + return ret; + } + + // Otherwise just get the value from the style object + return style[ name ]; + } + }, + + css: function( elem, name, extra, styles ) { + var val, num, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ); + + // Make sure that we're working with the right name. We don't + // want to modify the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Try prefixed name followed by the unprefixed name + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // If a hook was provided get the computed value from there + if ( hooks && "get" in hooks ) { + val = hooks.get( elem, true, extra ); + } + + // Otherwise, if a way to get the computed value exists, use that + if ( val === undefined ) { + val = curCSS( elem, name, styles ); + } + + // Convert "normal" to computed value + if ( val === "normal" && name in cssNormalTransform ) { + val = cssNormalTransform[ name ]; + } + + // Make numeric if forced or a qualifier was provided and val looks numeric + if ( extra === "" || extra ) { + num = parseFloat( val ); + return extra === true || isFinite( num ) ? num || 0 : val; + } + + return val; + } +} ); + +jQuery.each( [ "height", "width" ], function( _i, dimension ) { + jQuery.cssHooks[ dimension ] = { + get: function( elem, computed, extra ) { + if ( computed ) { + + // Certain elements can have dimension info if we invisibly show them + // but it must have a current display style that would benefit + return rdisplayswap.test( jQuery.css( elem, "display" ) ) && + + // Support: Safari 8+ + // Table columns in Safari have non-zero offsetWidth & zero + // getBoundingClientRect().width unless display is changed. + // Support: IE <=11 only + // Running getBoundingClientRect on a disconnected node + // in IE throws an error. + ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? + swap( elem, cssShow, function() { + return getWidthOrHeight( elem, dimension, extra ); + } ) : + getWidthOrHeight( elem, dimension, extra ); + } + }, + + set: function( elem, value, extra ) { + var matches, + styles = getStyles( elem ), + + // Only read styles.position if the test has a chance to fail + // to avoid forcing a reflow. + scrollboxSizeBuggy = !support.scrollboxSize() && + styles.position === "absolute", + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) + boxSizingNeeded = scrollboxSizeBuggy || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + subtract = extra ? + boxModelAdjustment( + elem, + dimension, + extra, + isBorderBox, + styles + ) : + 0; + + // Account for unreliable border-box dimensions by comparing offset* to computed and + // faking a content-box to get border and padding (gh-3699) + if ( isBorderBox && scrollboxSizeBuggy ) { + subtract -= Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + parseFloat( styles[ dimension ] ) - + boxModelAdjustment( elem, dimension, "border", false, styles ) - + 0.5 + ); + } + + // Convert to pixels if value adjustment is needed + if ( subtract && ( matches = rcssNum.exec( value ) ) && + ( matches[ 3 ] || "px" ) !== "px" ) { + + elem.style[ dimension ] = value; + value = jQuery.css( elem, dimension ); + } + + return setPositiveNumber( elem, value, subtract ); + } + }; +} ); + +jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, + function( elem, computed ) { + if ( computed ) { + return ( parseFloat( curCSS( elem, "marginLeft" ) ) || + elem.getBoundingClientRect().left - + swap( elem, { marginLeft: 0 }, function() { + return elem.getBoundingClientRect().left; + } ) + ) + "px"; + } + } +); + +// These hooks are used by animate to expand properties +jQuery.each( { + margin: "", + padding: "", + border: "Width" +}, function( prefix, suffix ) { + jQuery.cssHooks[ prefix + suffix ] = { + expand: function( value ) { + var i = 0, + expanded = {}, + + // Assumes a single number if not a string + parts = typeof value === "string" ? value.split( " " ) : [ value ]; + + for ( ; i < 4; i++ ) { + expanded[ prefix + cssExpand[ i ] + suffix ] = + parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; + } + + return expanded; + } + }; + + if ( prefix !== "margin" ) { + jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; + } +} ); + +jQuery.fn.extend( { + css: function( name, value ) { + return access( this, function( elem, name, value ) { + var styles, len, + map = {}, + i = 0; + + if ( Array.isArray( name ) ) { + styles = getStyles( elem ); + len = name.length; + + for ( ; i < len; i++ ) { + map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); + } + + return map; + } + + return value !== undefined ? + jQuery.style( elem, name, value ) : + jQuery.css( elem, name ); + }, name, value, arguments.length > 1 ); + } +} ); + + +function Tween( elem, options, prop, end, easing ) { + return new Tween.prototype.init( elem, options, prop, end, easing ); +} +jQuery.Tween = Tween; + +Tween.prototype = { + constructor: Tween, + init: function( elem, options, prop, end, easing, unit ) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); + }, + cur: function() { + var hooks = Tween.propHooks[ this.prop ]; + + return hooks && hooks.get ? + hooks.get( this ) : + Tween.propHooks._default.get( this ); + }, + run: function( percent ) { + var eased, + hooks = Tween.propHooks[ this.prop ]; + + if ( this.options.duration ) { + this.pos = eased = jQuery.easing[ this.easing ]( + percent, this.options.duration * percent, 0, 1, this.options.duration + ); + } else { + this.pos = eased = percent; + } + this.now = ( this.end - this.start ) * eased + this.start; + + if ( this.options.step ) { + this.options.step.call( this.elem, this.now, this ); + } + + if ( hooks && hooks.set ) { + hooks.set( this ); + } else { + Tween.propHooks._default.set( this ); + } + return this; + } +}; + +Tween.prototype.init.prototype = Tween.prototype; + +Tween.propHooks = { + _default: { + get: function( tween ) { + var result; + + // Use a property on the element directly when it is not a DOM element, + // or when there is no matching style property that exists. + if ( tween.elem.nodeType !== 1 || + tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { + return tween.elem[ tween.prop ]; + } + + // Passing an empty string as a 3rd parameter to .css will automatically + // attempt a parseFloat and fallback to a string if the parse fails. + // Simple values such as "10px" are parsed to Float; + // complex values such as "rotate(1rad)" are returned as-is. + result = jQuery.css( tween.elem, tween.prop, "" ); + + // Empty strings, null, undefined and "auto" are converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set: function( tween ) { + + // Use step hook for back compat. + // Use cssHook if its there. + // Use .style if available and use plain properties where available. + if ( jQuery.fx.step[ tween.prop ] ) { + jQuery.fx.step[ tween.prop ]( tween ); + } else if ( tween.elem.nodeType === 1 && ( + jQuery.cssHooks[ tween.prop ] || + tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { + jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); + } else { + tween.elem[ tween.prop ] = tween.now; + } + } + } +}; + +// Support: IE <=9 only +// Panic based approach to setting things on disconnected nodes +Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set: function( tween ) { + if ( tween.elem.nodeType && tween.elem.parentNode ) { + tween.elem[ tween.prop ] = tween.now; + } + } +}; + +jQuery.easing = { + linear: function( p ) { + return p; + }, + swing: function( p ) { + return 0.5 - Math.cos( p * Math.PI ) / 2; + }, + _default: "swing" +}; + +jQuery.fx = Tween.prototype.init; + +// Back compat <1.8 extension point +jQuery.fx.step = {}; + + + + +var + fxNow, inProgress, + rfxtypes = /^(?:toggle|show|hide)$/, + rrun = /queueHooks$/; + +function schedule() { + if ( inProgress ) { + if ( document.hidden === false && window.requestAnimationFrame ) { + window.requestAnimationFrame( schedule ); + } else { + window.setTimeout( schedule, jQuery.fx.interval ); + } + + jQuery.fx.tick(); + } +} + +// Animations created synchronously will run synchronously +function createFxNow() { + window.setTimeout( function() { + fxNow = undefined; + } ); + return ( fxNow = Date.now() ); +} + +// Generate parameters to create a standard animation +function genFx( type, includeWidth ) { + var which, + i = 0, + attrs = { height: type }; + + // If we include width, step value is 1 to do all cssExpand values, + // otherwise step value is 2 to skip over Left and Right + includeWidth = includeWidth ? 1 : 0; + for ( ; i < 4; i += 2 - includeWidth ) { + which = cssExpand[ i ]; + attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; + } + + if ( includeWidth ) { + attrs.opacity = attrs.width = type; + } + + return attrs; +} + +function createTween( value, prop, animation ) { + var tween, + collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), + index = 0, + length = collection.length; + for ( ; index < length; index++ ) { + if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { + + // We're done with this property + return tween; + } + } +} + +function defaultPrefilter( elem, props, opts ) { + var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, + isBox = "width" in props || "height" in props, + anim = this, + orig = {}, + style = elem.style, + hidden = elem.nodeType && isHiddenWithinTree( elem ), + dataShow = dataPriv.get( elem, "fxshow" ); + + // Queue-skipping animations hijack the fx hooks + if ( !opts.queue ) { + hooks = jQuery._queueHooks( elem, "fx" ); + if ( hooks.unqueued == null ) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if ( !hooks.unqueued ) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always( function() { + + // Ensure the complete handler is called before this completes + anim.always( function() { + hooks.unqueued--; + if ( !jQuery.queue( elem, "fx" ).length ) { + hooks.empty.fire(); + } + } ); + } ); + } + + // Detect show/hide animations + for ( prop in props ) { + value = props[ prop ]; + if ( rfxtypes.test( value ) ) { + delete props[ prop ]; + toggle = toggle || value === "toggle"; + if ( value === ( hidden ? "hide" : "show" ) ) { + + // Pretend to be hidden if this is a "show" and + // there is still data from a stopped show/hide + if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { + hidden = true; + + // Ignore all other no-op show/hide data + } else { + continue; + } + } + orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); + } + } + + // Bail out if this is a no-op like .hide().hide() + propTween = !jQuery.isEmptyObject( props ); + if ( !propTween && jQuery.isEmptyObject( orig ) ) { + return; + } + + // Restrict "overflow" and "display" styles during box animations + if ( isBox && elem.nodeType === 1 ) { + + // Support: IE <=9 - 11, Edge 12 - 15 + // Record all 3 overflow attributes because IE does not infer the shorthand + // from identically-valued overflowX and overflowY and Edge just mirrors + // the overflowX value there. + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Identify a display type, preferring old show/hide data over the CSS cascade + restoreDisplay = dataShow && dataShow.display; + if ( restoreDisplay == null ) { + restoreDisplay = dataPriv.get( elem, "display" ); + } + display = jQuery.css( elem, "display" ); + if ( display === "none" ) { + if ( restoreDisplay ) { + display = restoreDisplay; + } else { + + // Get nonempty value(s) by temporarily forcing visibility + showHide( [ elem ], true ); + restoreDisplay = elem.style.display || restoreDisplay; + display = jQuery.css( elem, "display" ); + showHide( [ elem ] ); + } + } + + // Animate inline elements as inline-block + if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { + if ( jQuery.css( elem, "float" ) === "none" ) { + + // Restore the original display value at the end of pure show/hide animations + if ( !propTween ) { + anim.done( function() { + style.display = restoreDisplay; + } ); + if ( restoreDisplay == null ) { + display = style.display; + restoreDisplay = display === "none" ? "" : display; + } + } + style.display = "inline-block"; + } + } + } + + if ( opts.overflow ) { + style.overflow = "hidden"; + anim.always( function() { + style.overflow = opts.overflow[ 0 ]; + style.overflowX = opts.overflow[ 1 ]; + style.overflowY = opts.overflow[ 2 ]; + } ); + } + + // Implement show/hide animations + propTween = false; + for ( prop in orig ) { + + // General show/hide setup for this element animation + if ( !propTween ) { + if ( dataShow ) { + if ( "hidden" in dataShow ) { + hidden = dataShow.hidden; + } + } else { + dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); + } + + // Store hidden/visible for toggle so `.stop().toggle()` "reverses" + if ( toggle ) { + dataShow.hidden = !hidden; + } + + // Show elements before animating them + if ( hidden ) { + showHide( [ elem ], true ); + } + + /* eslint-disable no-loop-func */ + + anim.done( function() { + + /* eslint-enable no-loop-func */ + + // The final step of a "hide" animation is actually hiding the element + if ( !hidden ) { + showHide( [ elem ] ); + } + dataPriv.remove( elem, "fxshow" ); + for ( prop in orig ) { + jQuery.style( elem, prop, orig[ prop ] ); + } + } ); + } + + // Per-property setup + propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); + if ( !( prop in dataShow ) ) { + dataShow[ prop ] = propTween.start; + if ( hidden ) { + propTween.end = propTween.start; + propTween.start = 0; + } + } + } +} + +function propFilter( props, specialEasing ) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for ( index in props ) { + name = camelCase( index ); + easing = specialEasing[ name ]; + value = props[ index ]; + if ( Array.isArray( value ) ) { + easing = value[ 1 ]; + value = props[ index ] = value[ 0 ]; + } + + if ( index !== name ) { + props[ name ] = value; + delete props[ index ]; + } + + hooks = jQuery.cssHooks[ name ]; + if ( hooks && "expand" in hooks ) { + value = hooks.expand( value ); + delete props[ name ]; + + // Not quite $.extend, this won't overwrite existing keys. + // Reusing 'index' because we have the correct "name" + for ( index in value ) { + if ( !( index in props ) ) { + props[ index ] = value[ index ]; + specialEasing[ index ] = easing; + } + } + } else { + specialEasing[ name ] = easing; + } + } +} + +function Animation( elem, properties, options ) { + var result, + stopped, + index = 0, + length = Animation.prefilters.length, + deferred = jQuery.Deferred().always( function() { + + // Don't match elem in the :animated selector + delete tick.elem; + } ), + tick = function() { + if ( stopped ) { + return false; + } + var currentTime = fxNow || createFxNow(), + remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), + + // Support: Android 2.3 only + // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) + temp = remaining / animation.duration || 0, + percent = 1 - temp, + index = 0, + length = animation.tweens.length; + + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( percent ); + } + + deferred.notifyWith( elem, [ animation, percent, remaining ] ); + + // If there's more to do, yield + if ( percent < 1 && length ) { + return remaining; + } + + // If this was an empty animation, synthesize a final progress notification + if ( !length ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + } + + // Resolve the animation and report its conclusion + deferred.resolveWith( elem, [ animation ] ); + return false; + }, + animation = deferred.promise( { + elem: elem, + props: jQuery.extend( {}, properties ), + opts: jQuery.extend( true, { + specialEasing: {}, + easing: jQuery.easing._default + }, options ), + originalProperties: properties, + originalOptions: options, + startTime: fxNow || createFxNow(), + duration: options.duration, + tweens: [], + createTween: function( prop, end ) { + var tween = jQuery.Tween( elem, animation.opts, prop, end, + animation.opts.specialEasing[ prop ] || animation.opts.easing ); + animation.tweens.push( tween ); + return tween; + }, + stop: function( gotoEnd ) { + var index = 0, + + // If we are going to the end, we want to run all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + if ( stopped ) { + return this; + } + stopped = true; + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( 1 ); + } + + // Resolve when we played the last frame; otherwise, reject + if ( gotoEnd ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + deferred.resolveWith( elem, [ animation, gotoEnd ] ); + } else { + deferred.rejectWith( elem, [ animation, gotoEnd ] ); + } + return this; + } + } ), + props = animation.props; + + propFilter( props, animation.opts.specialEasing ); + + for ( ; index < length; index++ ) { + result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); + if ( result ) { + if ( isFunction( result.stop ) ) { + jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = + result.stop.bind( result ); + } + return result; + } + } + + jQuery.map( props, createTween, animation ); + + if ( isFunction( animation.opts.start ) ) { + animation.opts.start.call( elem, animation ); + } + + // Attach callbacks from options + animation + .progress( animation.opts.progress ) + .done( animation.opts.done, animation.opts.complete ) + .fail( animation.opts.fail ) + .always( animation.opts.always ); + + jQuery.fx.timer( + jQuery.extend( tick, { + elem: elem, + anim: animation, + queue: animation.opts.queue + } ) + ); + + return animation; +} + +jQuery.Animation = jQuery.extend( Animation, { + + tweeners: { + "*": [ function( prop, value ) { + var tween = this.createTween( prop, value ); + adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); + return tween; + } ] + }, + + tweener: function( props, callback ) { + if ( isFunction( props ) ) { + callback = props; + props = [ "*" ]; + } else { + props = props.match( rnothtmlwhite ); + } + + var prop, + index = 0, + length = props.length; + + for ( ; index < length; index++ ) { + prop = props[ index ]; + Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; + Animation.tweeners[ prop ].unshift( callback ); + } + }, + + prefilters: [ defaultPrefilter ], + + prefilter: function( callback, prepend ) { + if ( prepend ) { + Animation.prefilters.unshift( callback ); + } else { + Animation.prefilters.push( callback ); + } + } +} ); + +jQuery.speed = function( speed, easing, fn ) { + var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { + complete: fn || !fn && easing || + isFunction( speed ) && speed, + duration: speed, + easing: fn && easing || easing && !isFunction( easing ) && easing + }; + + // Go to the end state if fx are off + if ( jQuery.fx.off ) { + opt.duration = 0; + + } else { + if ( typeof opt.duration !== "number" ) { + if ( opt.duration in jQuery.fx.speeds ) { + opt.duration = jQuery.fx.speeds[ opt.duration ]; + + } else { + opt.duration = jQuery.fx.speeds._default; + } + } + } + + // Normalize opt.queue - true/undefined/null -> "fx" + if ( opt.queue == null || opt.queue === true ) { + opt.queue = "fx"; + } + + // Queueing + opt.old = opt.complete; + + opt.complete = function() { + if ( isFunction( opt.old ) ) { + opt.old.call( this ); + } + + if ( opt.queue ) { + jQuery.dequeue( this, opt.queue ); + } + }; + + return opt; +}; + +jQuery.fn.extend( { + fadeTo: function( speed, to, easing, callback ) { + + // Show any hidden elements after setting opacity to 0 + return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() + + // Animate to the value specified + .end().animate( { opacity: to }, speed, easing, callback ); + }, + animate: function( prop, speed, easing, callback ) { + var empty = jQuery.isEmptyObject( prop ), + optall = jQuery.speed( speed, easing, callback ), + doAnimation = function() { + + // Operate on a copy of prop so per-property easing won't be lost + var anim = Animation( this, jQuery.extend( {}, prop ), optall ); + + // Empty animations, or finishing resolves immediately + if ( empty || dataPriv.get( this, "finish" ) ) { + anim.stop( true ); + } + }; + + doAnimation.finish = doAnimation; + + return empty || optall.queue === false ? + this.each( doAnimation ) : + this.queue( optall.queue, doAnimation ); + }, + stop: function( type, clearQueue, gotoEnd ) { + var stopQueue = function( hooks ) { + var stop = hooks.stop; + delete hooks.stop; + stop( gotoEnd ); + }; + + if ( typeof type !== "string" ) { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if ( clearQueue ) { + this.queue( type || "fx", [] ); + } + + return this.each( function() { + var dequeue = true, + index = type != null && type + "queueHooks", + timers = jQuery.timers, + data = dataPriv.get( this ); + + if ( index ) { + if ( data[ index ] && data[ index ].stop ) { + stopQueue( data[ index ] ); + } + } else { + for ( index in data ) { + if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { + stopQueue( data[ index ] ); + } + } + } + + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && + ( type == null || timers[ index ].queue === type ) ) { + + timers[ index ].anim.stop( gotoEnd ); + dequeue = false; + timers.splice( index, 1 ); + } + } + + // Start the next in the queue if the last step wasn't forced. + // Timers currently will call their complete callbacks, which + // will dequeue but only if they were gotoEnd. + if ( dequeue || !gotoEnd ) { + jQuery.dequeue( this, type ); + } + } ); + }, + finish: function( type ) { + if ( type !== false ) { + type = type || "fx"; + } + return this.each( function() { + var index, + data = dataPriv.get( this ), + queue = data[ type + "queue" ], + hooks = data[ type + "queueHooks" ], + timers = jQuery.timers, + length = queue ? queue.length : 0; + + // Enable finishing flag on private data + data.finish = true; + + // Empty the queue first + jQuery.queue( this, type, [] ); + + if ( hooks && hooks.stop ) { + hooks.stop.call( this, true ); + } + + // Look for any active animations, and finish them + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && timers[ index ].queue === type ) { + timers[ index ].anim.stop( true ); + timers.splice( index, 1 ); + } + } + + // Look for any animations in the old queue and finish them + for ( index = 0; index < length; index++ ) { + if ( queue[ index ] && queue[ index ].finish ) { + queue[ index ].finish.call( this ); + } + } + + // Turn off finishing flag + delete data.finish; + } ); + } +} ); + +jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { + var cssFn = jQuery.fn[ name ]; + jQuery.fn[ name ] = function( speed, easing, callback ) { + return speed == null || typeof speed === "boolean" ? + cssFn.apply( this, arguments ) : + this.animate( genFx( name, true ), speed, easing, callback ); + }; +} ); + +// Generate shortcuts for custom animations +jQuery.each( { + slideDown: genFx( "show" ), + slideUp: genFx( "hide" ), + slideToggle: genFx( "toggle" ), + fadeIn: { opacity: "show" }, + fadeOut: { opacity: "hide" }, + fadeToggle: { opacity: "toggle" } +}, function( name, props ) { + jQuery.fn[ name ] = function( speed, easing, callback ) { + return this.animate( props, speed, easing, callback ); + }; +} ); + +jQuery.timers = []; +jQuery.fx.tick = function() { + var timer, + i = 0, + timers = jQuery.timers; + + fxNow = Date.now(); + + for ( ; i < timers.length; i++ ) { + timer = timers[ i ]; + + // Run the timer and safely remove it when done (allowing for external removal) + if ( !timer() && timers[ i ] === timer ) { + timers.splice( i--, 1 ); + } + } + + if ( !timers.length ) { + jQuery.fx.stop(); + } + fxNow = undefined; +}; + +jQuery.fx.timer = function( timer ) { + jQuery.timers.push( timer ); + jQuery.fx.start(); +}; + +jQuery.fx.interval = 13; +jQuery.fx.start = function() { + if ( inProgress ) { + return; + } + + inProgress = true; + schedule(); +}; + +jQuery.fx.stop = function() { + inProgress = null; +}; + +jQuery.fx.speeds = { + slow: 600, + fast: 200, + + // Default speed + _default: 400 +}; + + +// Based off of the plugin by Clint Helfers, with permission. +// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ +jQuery.fn.delay = function( time, type ) { + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; + type = type || "fx"; + + return this.queue( type, function( next, hooks ) { + var timeout = window.setTimeout( next, time ); + hooks.stop = function() { + window.clearTimeout( timeout ); + }; + } ); +}; + + +( function() { + var input = document.createElement( "input" ), + select = document.createElement( "select" ), + opt = select.appendChild( document.createElement( "option" ) ); + + input.type = "checkbox"; + + // Support: Android <=4.3 only + // Default value for a checkbox should be "on" + support.checkOn = input.value !== ""; + + // Support: IE <=11 only + // Must access selectedIndex to make default options select + support.optSelected = opt.selected; + + // Support: IE <=11 only + // An input loses its value after becoming a radio + input = document.createElement( "input" ); + input.value = "t"; + input.type = "radio"; + support.radioValue = input.value === "t"; +} )(); + + +var boolHook, + attrHandle = jQuery.expr.attrHandle; + +jQuery.fn.extend( { + attr: function( name, value ) { + return access( this, jQuery.attr, name, value, arguments.length > 1 ); + }, + + removeAttr: function( name ) { + return this.each( function() { + jQuery.removeAttr( this, name ); + } ); + } +} ); + +jQuery.extend( { + attr: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set attributes on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + // Fallback to prop when attributes are not supported + if ( typeof elem.getAttribute === "undefined" ) { + return jQuery.prop( elem, name, value ); + } + + // Attribute hooks are determined by the lowercase version + // Grab necessary hook if one is defined + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + hooks = jQuery.attrHooks[ name.toLowerCase() ] || + ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); + } + + if ( value !== undefined ) { + if ( value === null ) { + jQuery.removeAttr( elem, name ); + return; + } + + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + elem.setAttribute( name, value + "" ); + return value; + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + ret = jQuery.find.attr( elem, name ); + + // Non-existent attributes return null, we normalize to undefined + return ret == null ? undefined : ret; + }, + + attrHooks: { + type: { + set: function( elem, value ) { + if ( !support.radioValue && value === "radio" && + nodeName( elem, "input" ) ) { + var val = elem.value; + elem.setAttribute( "type", value ); + if ( val ) { + elem.value = val; + } + return value; + } + } + } + }, + + removeAttr: function( elem, value ) { + var name, + i = 0, + + // Attribute names can contain non-HTML whitespace characters + // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 + attrNames = value && value.match( rnothtmlwhite ); + + if ( attrNames && elem.nodeType === 1 ) { + while ( ( name = attrNames[ i++ ] ) ) { + elem.removeAttribute( name ); + } + } + } +} ); + +// Hooks for boolean attributes +boolHook = { + set: function( elem, value, name ) { + if ( value === false ) { + + // Remove boolean attributes when set to false + jQuery.removeAttr( elem, name ); + } else { + elem.setAttribute( name, name ); + } + return name; + } +}; + +jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { + var getter = attrHandle[ name ] || jQuery.find.attr; + + attrHandle[ name ] = function( elem, name, isXML ) { + var ret, handle, + lowercaseName = name.toLowerCase(); + + if ( !isXML ) { + + // Avoid an infinite loop by temporarily removing this function from the getter + handle = attrHandle[ lowercaseName ]; + attrHandle[ lowercaseName ] = ret; + ret = getter( elem, name, isXML ) != null ? + lowercaseName : + null; + attrHandle[ lowercaseName ] = handle; + } + return ret; + }; +} ); + + + + +var rfocusable = /^(?:input|select|textarea|button)$/i, + rclickable = /^(?:a|area)$/i; + +jQuery.fn.extend( { + prop: function( name, value ) { + return access( this, jQuery.prop, name, value, arguments.length > 1 ); + }, + + removeProp: function( name ) { + return this.each( function() { + delete this[ jQuery.propFix[ name ] || name ]; + } ); + } +} ); + +jQuery.extend( { + prop: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set properties on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + + // Fix name and attach hooks + name = jQuery.propFix[ name ] || name; + hooks = jQuery.propHooks[ name ]; + } + + if ( value !== undefined ) { + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + return ( elem[ name ] = value ); + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + return elem[ name ]; + }, + + propHooks: { + tabIndex: { + get: function( elem ) { + + // Support: IE <=9 - 11 only + // elem.tabIndex doesn't always return the + // correct value when it hasn't been explicitly set + // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ + // Use proper attribute retrieval(#12072) + var tabindex = jQuery.find.attr( elem, "tabindex" ); + + if ( tabindex ) { + return parseInt( tabindex, 10 ); + } + + if ( + rfocusable.test( elem.nodeName ) || + rclickable.test( elem.nodeName ) && + elem.href + ) { + return 0; + } + + return -1; + } + } + }, + + propFix: { + "for": "htmlFor", + "class": "className" + } +} ); + +// Support: IE <=11 only +// Accessing the selectedIndex property +// forces the browser to respect setting selected +// on the option +// The getter ensures a default option is selected +// when in an optgroup +// eslint rule "no-unused-expressions" is disabled for this code +// since it considers such accessions noop +if ( !support.optSelected ) { + jQuery.propHooks.selected = { + get: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent && parent.parentNode ) { + parent.parentNode.selectedIndex; + } + return null; + }, + set: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent ) { + parent.selectedIndex; + + if ( parent.parentNode ) { + parent.parentNode.selectedIndex; + } + } + } + }; +} + +jQuery.each( [ + "tabIndex", + "readOnly", + "maxLength", + "cellSpacing", + "cellPadding", + "rowSpan", + "colSpan", + "useMap", + "frameBorder", + "contentEditable" +], function() { + jQuery.propFix[ this.toLowerCase() ] = this; +} ); + + + + + // Strip and collapse whitespace according to HTML spec + // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace + function stripAndCollapse( value ) { + var tokens = value.match( rnothtmlwhite ) || []; + return tokens.join( " " ); + } + + +function getClass( elem ) { + return elem.getAttribute && elem.getAttribute( "class" ) || ""; +} + +function classesToArray( value ) { + if ( Array.isArray( value ) ) { + return value; + } + if ( typeof value === "string" ) { + return value.match( rnothtmlwhite ) || []; + } + return []; +} + +jQuery.fn.extend( { + addClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + if ( cur.indexOf( " " + clazz + " " ) < 0 ) { + cur += clazz + " "; + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + removeClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + if ( !arguments.length ) { + return this.attr( "class", "" ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + + // This expression is here for better compressibility (see addClass) + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + + // Remove *all* instances + while ( cur.indexOf( " " + clazz + " " ) > -1 ) { + cur = cur.replace( " " + clazz + " ", " " ); + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + toggleClass: function( value, stateVal ) { + var type = typeof value, + isValidValue = type === "string" || Array.isArray( value ); + + if ( typeof stateVal === "boolean" && isValidValue ) { + return stateVal ? this.addClass( value ) : this.removeClass( value ); + } + + if ( isFunction( value ) ) { + return this.each( function( i ) { + jQuery( this ).toggleClass( + value.call( this, i, getClass( this ), stateVal ), + stateVal + ); + } ); + } + + return this.each( function() { + var className, i, self, classNames; + + if ( isValidValue ) { + + // Toggle individual class names + i = 0; + self = jQuery( this ); + classNames = classesToArray( value ); + + while ( ( className = classNames[ i++ ] ) ) { + + // Check each className given, space separated list + if ( self.hasClass( className ) ) { + self.removeClass( className ); + } else { + self.addClass( className ); + } + } + + // Toggle whole class name + } else if ( value === undefined || type === "boolean" ) { + className = getClass( this ); + if ( className ) { + + // Store className if set + dataPriv.set( this, "__className__", className ); + } + + // If the element has a class name or if we're passed `false`, + // then remove the whole classname (if there was one, the above saved it). + // Otherwise bring back whatever was previously saved (if anything), + // falling back to the empty string if nothing was stored. + if ( this.setAttribute ) { + this.setAttribute( "class", + className || value === false ? + "" : + dataPriv.get( this, "__className__" ) || "" + ); + } + } + } ); + }, + + hasClass: function( selector ) { + var className, elem, + i = 0; + + className = " " + selector + " "; + while ( ( elem = this[ i++ ] ) ) { + if ( elem.nodeType === 1 && + ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { + return true; + } + } + + return false; + } +} ); + + + + +var rreturn = /\r/g; + +jQuery.fn.extend( { + val: function( value ) { + var hooks, ret, valueIsFunction, + elem = this[ 0 ]; + + if ( !arguments.length ) { + if ( elem ) { + hooks = jQuery.valHooks[ elem.type ] || + jQuery.valHooks[ elem.nodeName.toLowerCase() ]; + + if ( hooks && + "get" in hooks && + ( ret = hooks.get( elem, "value" ) ) !== undefined + ) { + return ret; + } + + ret = elem.value; + + // Handle most common string cases + if ( typeof ret === "string" ) { + return ret.replace( rreturn, "" ); + } + + // Handle cases where value is null/undef or number + return ret == null ? "" : ret; + } + + return; + } + + valueIsFunction = isFunction( value ); + + return this.each( function( i ) { + var val; + + if ( this.nodeType !== 1 ) { + return; + } + + if ( valueIsFunction ) { + val = value.call( this, i, jQuery( this ).val() ); + } else { + val = value; + } + + // Treat null/undefined as ""; convert numbers to string + if ( val == null ) { + val = ""; + + } else if ( typeof val === "number" ) { + val += ""; + + } else if ( Array.isArray( val ) ) { + val = jQuery.map( val, function( value ) { + return value == null ? "" : value + ""; + } ); + } + + hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; + + // If set returns undefined, fall back to normal setting + if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { + this.value = val; + } + } ); + } +} ); + +jQuery.extend( { + valHooks: { + option: { + get: function( elem ) { + + var val = jQuery.find.attr( elem, "value" ); + return val != null ? + val : + + // Support: IE <=10 - 11 only + // option.text throws exceptions (#14686, #14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + stripAndCollapse( jQuery.text( elem ) ); + } + }, + select: { + get: function( elem ) { + var value, option, i, + options = elem.options, + index = elem.selectedIndex, + one = elem.type === "select-one", + values = one ? null : [], + max = one ? index + 1 : options.length; + + if ( index < 0 ) { + i = max; + + } else { + i = one ? index : 0; + } + + // Loop through all the selected options + for ( ; i < max; i++ ) { + option = options[ i ]; + + // Support: IE <=9 only + // IE8-9 doesn't update selected after form reset (#2551) + if ( ( option.selected || i === index ) && + + // Don't return options that are disabled or in a disabled optgroup + !option.disabled && + ( !option.parentNode.disabled || + !nodeName( option.parentNode, "optgroup" ) ) ) { + + // Get the specific value for the option + value = jQuery( option ).val(); + + // We don't need an array for one selects + if ( one ) { + return value; + } + + // Multi-Selects return an array + values.push( value ); + } + } + + return values; + }, + + set: function( elem, value ) { + var optionSet, option, + options = elem.options, + values = jQuery.makeArray( value ), + i = options.length; + + while ( i-- ) { + option = options[ i ]; + + /* eslint-disable no-cond-assign */ + + if ( option.selected = + jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 + ) { + optionSet = true; + } + + /* eslint-enable no-cond-assign */ + } + + // Force browsers to behave consistently when non-matching value is set + if ( !optionSet ) { + elem.selectedIndex = -1; + } + return values; + } + } + } +} ); + +// Radios and checkboxes getter/setter +jQuery.each( [ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = { + set: function( elem, value ) { + if ( Array.isArray( value ) ) { + return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); + } + } + }; + if ( !support.checkOn ) { + jQuery.valHooks[ this ].get = function( elem ) { + return elem.getAttribute( "value" ) === null ? "on" : elem.value; + }; + } +} ); + + + + +// Return jQuery for attributes-only inclusion + + +support.focusin = "onfocusin" in window; + + +var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, + stopPropagationCallback = function( e ) { + e.stopPropagation(); + }; + +jQuery.extend( jQuery.event, { + + trigger: function( event, data, elem, onlyHandlers ) { + + var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, + eventPath = [ elem || document ], + type = hasOwn.call( event, "type" ) ? event.type : event, + namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; + + cur = lastElement = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if ( elem.nodeType === 3 || elem.nodeType === 8 ) { + return; + } + + // focus/blur morphs to focusin/out; ensure we're not firing them right now + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { + return; + } + + if ( type.indexOf( "." ) > -1 ) { + + // Namespaced trigger; create a regexp to match event type in handle() + namespaces = type.split( "." ); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf( ":" ) < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, or just an event type string + event = event[ jQuery.expando ] ? + event : + new jQuery.Event( type, typeof event === "object" && event ); + + // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join( "." ); + event.rnamespace = event.namespace ? + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : + null; + + // Clean up the event in case it is being reused + event.result = undefined; + if ( !event.target ) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, creating the handler arg list + data = data == null ? + [ event ] : + jQuery.makeArray( data, [ event ] ); + + // Allow special events to draw outside the lines + special = jQuery.event.special[ type ] || {}; + if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { + return; + } + + // Determine event propagation path in advance, per W3C events spec (#9951) + // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) + if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { + + bubbleType = special.delegateType || type; + if ( !rfocusMorph.test( bubbleType + type ) ) { + cur = cur.parentNode; + } + for ( ; cur; cur = cur.parentNode ) { + eventPath.push( cur ); + tmp = cur; + } + + // Only add window if we got to document (e.g., not plain obj or detached DOM) + if ( tmp === ( elem.ownerDocument || document ) ) { + eventPath.push( tmp.defaultView || tmp.parentWindow || window ); + } + } + + // Fire handlers on the event path + i = 0; + while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { + lastElement = cur; + event.type = i > 1 ? + bubbleType : + special.bindType || type; + + // jQuery handler + handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] && + dataPriv.get( cur, "handle" ); + if ( handle ) { + handle.apply( cur, data ); + } + + // Native handler + handle = ontype && cur[ ontype ]; + if ( handle && handle.apply && acceptData( cur ) ) { + event.result = handle.apply( cur, data ); + if ( event.result === false ) { + event.preventDefault(); + } + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if ( !onlyHandlers && !event.isDefaultPrevented() ) { + + if ( ( !special._default || + special._default.apply( eventPath.pop(), data ) === false ) && + acceptData( elem ) ) { + + // Call a native DOM method on the target with the same name as the event. + // Don't do default actions on window, that's where global variables be (#6170) + if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { + + // Don't re-trigger an onFOO event when we call its FOO() method + tmp = elem[ ontype ]; + + if ( tmp ) { + elem[ ontype ] = null; + } + + // Prevent re-triggering of the same event, since we already bubbled it above + jQuery.event.triggered = type; + + if ( event.isPropagationStopped() ) { + lastElement.addEventListener( type, stopPropagationCallback ); + } + + elem[ type ](); + + if ( event.isPropagationStopped() ) { + lastElement.removeEventListener( type, stopPropagationCallback ); + } + + jQuery.event.triggered = undefined; + + if ( tmp ) { + elem[ ontype ] = tmp; + } + } + } + } + + return event.result; + }, + + // Piggyback on a donor event to simulate a different one + // Used only for `focus(in | out)` events + simulate: function( type, elem, event ) { + var e = jQuery.extend( + new jQuery.Event(), + event, + { + type: type, + isSimulated: true + } + ); + + jQuery.event.trigger( e, null, elem ); + } + +} ); + +jQuery.fn.extend( { + + trigger: function( type, data ) { + return this.each( function() { + jQuery.event.trigger( type, data, this ); + } ); + }, + triggerHandler: function( type, data ) { + var elem = this[ 0 ]; + if ( elem ) { + return jQuery.event.trigger( type, data, elem, true ); + } + } +} ); + + +// Support: Firefox <=44 +// Firefox doesn't have focus(in | out) events +// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 +// +// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 +// focus(in | out) events fire after focus & blur events, +// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order +// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 +if ( !support.focusin ) { + jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { + + // Attach a single capturing handler on the document while someone wants focusin/focusout + var handler = function( event ) { + jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); + }; + + jQuery.event.special[ fix ] = { + setup: function() { + + // Handle: regular nodes (via `this.ownerDocument`), window + // (via `this.document`) & document (via `this`). + var doc = this.ownerDocument || this.document || this, + attaches = dataPriv.access( doc, fix ); + + if ( !attaches ) { + doc.addEventListener( orig, handler, true ); + } + dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); + }, + teardown: function() { + var doc = this.ownerDocument || this.document || this, + attaches = dataPriv.access( doc, fix ) - 1; + + if ( !attaches ) { + doc.removeEventListener( orig, handler, true ); + dataPriv.remove( doc, fix ); + + } else { + dataPriv.access( doc, fix, attaches ); + } + } + }; + } ); +} +var location = window.location; + +var nonce = { guid: Date.now() }; + +var rquery = ( /\?/ ); + + + +// Cross-browser xml parsing +jQuery.parseXML = function( data ) { + var xml, parserErrorElem; + if ( !data || typeof data !== "string" ) { + return null; + } + + // Support: IE 9 - 11 only + // IE throws on parseFromString with invalid input. + try { + xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); + } catch ( e ) {} + + parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ]; + if ( !xml || parserErrorElem ) { + jQuery.error( "Invalid XML: " + ( + parserErrorElem ? + jQuery.map( parserErrorElem.childNodes, function( el ) { + return el.textContent; + } ).join( "\n" ) : + data + ) ); + } + return xml; +}; + + +var + rbracket = /\[\]$/, + rCRLF = /\r?\n/g, + rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, + rsubmittable = /^(?:input|select|textarea|keygen)/i; + +function buildParams( prefix, obj, traditional, add ) { + var name; + + if ( Array.isArray( obj ) ) { + + // Serialize array item. + jQuery.each( obj, function( i, v ) { + if ( traditional || rbracket.test( prefix ) ) { + + // Treat each array item as a scalar. + add( prefix, v ); + + } else { + + // Item is non-scalar (array or object), encode its numeric index. + buildParams( + prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", + v, + traditional, + add + ); + } + } ); + + } else if ( !traditional && toType( obj ) === "object" ) { + + // Serialize object item. + for ( name in obj ) { + buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); + } + + } else { + + // Serialize scalar item. + add( prefix, obj ); + } +} + +// Serialize an array of form elements or a set of +// key/values into a query string +jQuery.param = function( a, traditional ) { + var prefix, + s = [], + add = function( key, valueOrFunction ) { + + // If value is a function, invoke it and use its return value + var value = isFunction( valueOrFunction ) ? + valueOrFunction() : + valueOrFunction; + + s[ s.length ] = encodeURIComponent( key ) + "=" + + encodeURIComponent( value == null ? "" : value ); + }; + + if ( a == null ) { + return ""; + } + + // If an array was passed in, assume that it is an array of form elements. + if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { + + // Serialize the form elements + jQuery.each( a, function() { + add( this.name, this.value ); + } ); + + } else { + + // If traditional, encode the "old" way (the way 1.3.2 or older + // did it), otherwise encode params recursively. + for ( prefix in a ) { + buildParams( prefix, a[ prefix ], traditional, add ); + } + } + + // Return the resulting serialization + return s.join( "&" ); +}; + +jQuery.fn.extend( { + serialize: function() { + return jQuery.param( this.serializeArray() ); + }, + serializeArray: function() { + return this.map( function() { + + // Can add propHook for "elements" to filter or add form elements + var elements = jQuery.prop( this, "elements" ); + return elements ? jQuery.makeArray( elements ) : this; + } ).filter( function() { + var type = this.type; + + // Use .is( ":disabled" ) so that fieldset[disabled] works + return this.name && !jQuery( this ).is( ":disabled" ) && + rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && + ( this.checked || !rcheckableType.test( type ) ); + } ).map( function( _i, elem ) { + var val = jQuery( this ).val(); + + if ( val == null ) { + return null; + } + + if ( Array.isArray( val ) ) { + return jQuery.map( val, function( val ) { + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ); + } + + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ).get(); + } +} ); + + +var + r20 = /%20/g, + rhash = /#.*$/, + rantiCache = /([?&])_=[^&]*/, + rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, + + // #7653, #8125, #8152: local protocol detection + rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, + rnoContent = /^(?:GET|HEAD)$/, + rprotocol = /^\/\//, + + /* Prefilters + * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) + * 2) These are called: + * - BEFORE asking for a transport + * - AFTER param serialization (s.data is a string if s.processData is true) + * 3) key is the dataType + * 4) the catchall symbol "*" can be used + * 5) execution will start with transport dataType and THEN continue down to "*" if needed + */ + prefilters = {}, + + /* Transports bindings + * 1) key is the dataType + * 2) the catchall symbol "*" can be used + * 3) selection will start with transport dataType and THEN go to "*" if needed + */ + transports = {}, + + // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression + allTypes = "*/".concat( "*" ), + + // Anchor tag for parsing the document origin + originAnchor = document.createElement( "a" ); + +originAnchor.href = location.href; + +// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport +function addToPrefiltersOrTransports( structure ) { + + // dataTypeExpression is optional and defaults to "*" + return function( dataTypeExpression, func ) { + + if ( typeof dataTypeExpression !== "string" ) { + func = dataTypeExpression; + dataTypeExpression = "*"; + } + + var dataType, + i = 0, + dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; + + if ( isFunction( func ) ) { + + // For each dataType in the dataTypeExpression + while ( ( dataType = dataTypes[ i++ ] ) ) { + + // Prepend if requested + if ( dataType[ 0 ] === "+" ) { + dataType = dataType.slice( 1 ) || "*"; + ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); + + // Otherwise append + } else { + ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); + } + } + } + }; +} + +// Base inspection function for prefilters and transports +function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { + + var inspected = {}, + seekingTransport = ( structure === transports ); + + function inspect( dataType ) { + var selected; + inspected[ dataType ] = true; + jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { + var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); + if ( typeof dataTypeOrTransport === "string" && + !seekingTransport && !inspected[ dataTypeOrTransport ] ) { + + options.dataTypes.unshift( dataTypeOrTransport ); + inspect( dataTypeOrTransport ); + return false; + } else if ( seekingTransport ) { + return !( selected = dataTypeOrTransport ); + } + } ); + return selected; + } + + return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); +} + +// A special extend for ajax options +// that takes "flat" options (not to be deep extended) +// Fixes #9887 +function ajaxExtend( target, src ) { + var key, deep, + flatOptions = jQuery.ajaxSettings.flatOptions || {}; + + for ( key in src ) { + if ( src[ key ] !== undefined ) { + ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; + } + } + if ( deep ) { + jQuery.extend( true, target, deep ); + } + + return target; +} + +/* Handles responses to an ajax request: + * - finds the right dataType (mediates between content-type and expected dataType) + * - returns the corresponding response + */ +function ajaxHandleResponses( s, jqXHR, responses ) { + + var ct, type, finalDataType, firstDataType, + contents = s.contents, + dataTypes = s.dataTypes; + + // Remove auto dataType and get content-type in the process + while ( dataTypes[ 0 ] === "*" ) { + dataTypes.shift(); + if ( ct === undefined ) { + ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); + } + } + + // Check if we're dealing with a known content-type + if ( ct ) { + for ( type in contents ) { + if ( contents[ type ] && contents[ type ].test( ct ) ) { + dataTypes.unshift( type ); + break; + } + } + } + + // Check to see if we have a response for the expected dataType + if ( dataTypes[ 0 ] in responses ) { + finalDataType = dataTypes[ 0 ]; + } else { + + // Try convertible dataTypes + for ( type in responses ) { + if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { + finalDataType = type; + break; + } + if ( !firstDataType ) { + firstDataType = type; + } + } + + // Or just use first one + finalDataType = finalDataType || firstDataType; + } + + // If we found a dataType + // We add the dataType to the list if needed + // and return the corresponding response + if ( finalDataType ) { + if ( finalDataType !== dataTypes[ 0 ] ) { + dataTypes.unshift( finalDataType ); + } + return responses[ finalDataType ]; + } +} + +/* Chain conversions given the request and the original response + * Also sets the responseXXX fields on the jqXHR instance + */ +function ajaxConvert( s, response, jqXHR, isSuccess ) { + var conv2, current, conv, tmp, prev, + converters = {}, + + // Work with a copy of dataTypes in case we need to modify it for conversion + dataTypes = s.dataTypes.slice(); + + // Create converters map with lowercased keys + if ( dataTypes[ 1 ] ) { + for ( conv in s.converters ) { + converters[ conv.toLowerCase() ] = s.converters[ conv ]; + } + } + + current = dataTypes.shift(); + + // Convert to each sequential dataType + while ( current ) { + + if ( s.responseFields[ current ] ) { + jqXHR[ s.responseFields[ current ] ] = response; + } + + // Apply the dataFilter if provided + if ( !prev && isSuccess && s.dataFilter ) { + response = s.dataFilter( response, s.dataType ); + } + + prev = current; + current = dataTypes.shift(); + + if ( current ) { + + // There's only work to do if current dataType is non-auto + if ( current === "*" ) { + + current = prev; + + // Convert response if prev dataType is non-auto and differs from current + } else if ( prev !== "*" && prev !== current ) { + + // Seek a direct converter + conv = converters[ prev + " " + current ] || converters[ "* " + current ]; + + // If none found, seek a pair + if ( !conv ) { + for ( conv2 in converters ) { + + // If conv2 outputs current + tmp = conv2.split( " " ); + if ( tmp[ 1 ] === current ) { + + // If prev can be converted to accepted input + conv = converters[ prev + " " + tmp[ 0 ] ] || + converters[ "* " + tmp[ 0 ] ]; + if ( conv ) { + + // Condense equivalence converters + if ( conv === true ) { + conv = converters[ conv2 ]; + + // Otherwise, insert the intermediate dataType + } else if ( converters[ conv2 ] !== true ) { + current = tmp[ 0 ]; + dataTypes.unshift( tmp[ 1 ] ); + } + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if ( conv !== true ) { + + // Unless errors are allowed to bubble, catch and return them + if ( conv && s.throws ) { + response = conv( response ); + } else { + try { + response = conv( response ); + } catch ( e ) { + return { + state: "parsererror", + error: conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + + return { state: "success", data: response }; +} + +jQuery.extend( { + + // Counter for holding the number of active queries + active: 0, + + // Last-Modified header cache for next request + lastModified: {}, + etag: {}, + + ajaxSettings: { + url: location.href, + type: "GET", + isLocal: rlocalProtocol.test( location.protocol ), + global: true, + processData: true, + async: true, + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + + /* + timeout: 0, + data: null, + dataType: null, + username: null, + password: null, + cache: null, + throws: false, + traditional: false, + headers: {}, + */ + + accepts: { + "*": allTypes, + text: "text/plain", + html: "text/html", + xml: "application/xml, text/xml", + json: "application/json, text/javascript" + }, + + contents: { + xml: /\bxml\b/, + html: /\bhtml/, + json: /\bjson\b/ + }, + + responseFields: { + xml: "responseXML", + text: "responseText", + json: "responseJSON" + }, + + // Data converters + // Keys separate source (or catchall "*") and destination types with a single space + converters: { + + // Convert anything to text + "* text": String, + + // Text to html (true = no transformation) + "text html": true, + + // Evaluate text as a json expression + "text json": JSON.parse, + + // Parse text as xml + "text xml": jQuery.parseXML + }, + + // For options that shouldn't be deep extended: + // you can add your own custom options here if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions: { + url: true, + context: true + } + }, + + // Creates a full fledged settings object into target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into ajaxSettings. + ajaxSetup: function( target, settings ) { + return settings ? + + // Building a settings object + ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : + + // Extending ajaxSettings + ajaxExtend( jQuery.ajaxSettings, target ); + }, + + ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), + ajaxTransport: addToPrefiltersOrTransports( transports ), + + // Main method + ajax: function( url, options ) { + + // If url is an object, simulate pre-1.5 signature + if ( typeof url === "object" ) { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var transport, + + // URL without anti-cache param + cacheURL, + + // Response headers + responseHeadersString, + responseHeaders, + + // timeout handle + timeoutTimer, + + // Url cleanup var + urlAnchor, + + // Request state (becomes false upon send and true upon completion) + completed, + + // To know if global events are to be dispatched + fireGlobals, + + // Loop variable + i, + + // uncached part of the url + uncached, + + // Create the final options object + s = jQuery.ajaxSetup( {}, options ), + + // Callbacks context + callbackContext = s.context || s, + + // Context for global events is callbackContext if it is a DOM node or jQuery collection + globalEventContext = s.context && + ( callbackContext.nodeType || callbackContext.jquery ) ? + jQuery( callbackContext ) : + jQuery.event, + + // Deferreds + deferred = jQuery.Deferred(), + completeDeferred = jQuery.Callbacks( "once memory" ), + + // Status-dependent callbacks + statusCode = s.statusCode || {}, + + // Headers (they are sent all at once) + requestHeaders = {}, + requestHeadersNames = {}, + + // Default abort message + strAbort = "canceled", + + // Fake xhr + jqXHR = { + readyState: 0, + + // Builds headers hashtable if needed + getResponseHeader: function( key ) { + var match; + if ( completed ) { + if ( !responseHeaders ) { + responseHeaders = {}; + while ( ( match = rheaders.exec( responseHeadersString ) ) ) { + responseHeaders[ match[ 1 ].toLowerCase() + " " ] = + ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) + .concat( match[ 2 ] ); + } + } + match = responseHeaders[ key.toLowerCase() + " " ]; + } + return match == null ? null : match.join( ", " ); + }, + + // Raw string + getAllResponseHeaders: function() { + return completed ? responseHeadersString : null; + }, + + // Caches the header + setRequestHeader: function( name, value ) { + if ( completed == null ) { + name = requestHeadersNames[ name.toLowerCase() ] = + requestHeadersNames[ name.toLowerCase() ] || name; + requestHeaders[ name ] = value; + } + return this; + }, + + // Overrides response content-type header + overrideMimeType: function( type ) { + if ( completed == null ) { + s.mimeType = type; + } + return this; + }, + + // Status-dependent callbacks + statusCode: function( map ) { + var code; + if ( map ) { + if ( completed ) { + + // Execute the appropriate callbacks + jqXHR.always( map[ jqXHR.status ] ); + } else { + + // Lazy-add the new callbacks in a way that preserves old ones + for ( code in map ) { + statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; + } + } + } + return this; + }, + + // Cancel the request + abort: function( statusText ) { + var finalText = statusText || strAbort; + if ( transport ) { + transport.abort( finalText ); + } + done( 0, finalText ); + return this; + } + }; + + // Attach deferreds + deferred.promise( jqXHR ); + + // Add protocol if not provided (prefilters might expect it) + // Handle falsy url in the settings object (#10093: consistency with old signature) + // We also use the url parameter if available + s.url = ( ( url || s.url || location.href ) + "" ) + .replace( rprotocol, location.protocol + "//" ); + + // Alias method option to type as per ticket #12004 + s.type = options.method || options.type || s.method || s.type; + + // Extract dataTypes list + s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; + + // A cross-domain request is in order when the origin doesn't match the current origin. + if ( s.crossDomain == null ) { + urlAnchor = document.createElement( "a" ); + + // Support: IE <=8 - 11, Edge 12 - 15 + // IE throws exception on accessing the href property if url is malformed, + // e.g. http://example.com:80x/ + try { + urlAnchor.href = s.url; + + // Support: IE <=8 - 11 only + // Anchor's host property isn't correctly set when s.url is relative + urlAnchor.href = urlAnchor.href; + s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== + urlAnchor.protocol + "//" + urlAnchor.host; + } catch ( e ) { + + // If there is an error parsing the URL, assume it is crossDomain, + // it can be rejected by the transport if it is invalid + s.crossDomain = true; + } + } + + // Convert data if not already a string + if ( s.data && s.processData && typeof s.data !== "string" ) { + s.data = jQuery.param( s.data, s.traditional ); + } + + // Apply prefilters + inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); + + // If request was aborted inside a prefilter, stop there + if ( completed ) { + return jqXHR; + } + + // We can fire global events as of now if asked to + // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) + fireGlobals = jQuery.event && s.global; + + // Watch for a new set of requests + if ( fireGlobals && jQuery.active++ === 0 ) { + jQuery.event.trigger( "ajaxStart" ); + } + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test( s.type ); + + // Save the URL in case we're toying with the If-Modified-Since + // and/or If-None-Match header later on + // Remove hash to simplify url manipulation + cacheURL = s.url.replace( rhash, "" ); + + // More options handling for requests with no content + if ( !s.hasContent ) { + + // Remember the hash so we can put it back + uncached = s.url.slice( cacheURL.length ); + + // If data is available and should be processed, append data to url + if ( s.data && ( s.processData || typeof s.data === "string" ) ) { + cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; + + // #9682: remove data so that it's not used in an eventual retry + delete s.data; + } + + // Add or update anti-cache param if needed + if ( s.cache === false ) { + cacheURL = cacheURL.replace( rantiCache, "$1" ); + uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + + uncached; + } + + // Put hash and anti-cache on the URL that will be requested (gh-1732) + s.url = cacheURL + uncached; + + // Change '%20' to '+' if this is encoded form body content (gh-2658) + } else if ( s.data && s.processData && + ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { + s.data = s.data.replace( r20, "+" ); + } + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + if ( jQuery.lastModified[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); + } + if ( jQuery.etag[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); + } + } + + // Set the correct header, if data is being sent + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { + jqXHR.setRequestHeader( "Content-Type", s.contentType ); + } + + // Set the Accepts header for the server, depending on the dataType + jqXHR.setRequestHeader( + "Accept", + s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? + s.accepts[ s.dataTypes[ 0 ] ] + + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : + s.accepts[ "*" ] + ); + + // Check for headers option + for ( i in s.headers ) { + jqXHR.setRequestHeader( i, s.headers[ i ] ); + } + + // Allow custom headers/mimetypes and early abort + if ( s.beforeSend && + ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { + + // Abort if not done already and return + return jqXHR.abort(); + } + + // Aborting is no longer a cancellation + strAbort = "abort"; + + // Install callbacks on deferreds + completeDeferred.add( s.complete ); + jqXHR.done( s.success ); + jqXHR.fail( s.error ); + + // Get transport + transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); + + // If no transport, we auto-abort + if ( !transport ) { + done( -1, "No Transport" ); + } else { + jqXHR.readyState = 1; + + // Send global event + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); + } + + // If request was aborted inside ajaxSend, stop there + if ( completed ) { + return jqXHR; + } + + // Timeout + if ( s.async && s.timeout > 0 ) { + timeoutTimer = window.setTimeout( function() { + jqXHR.abort( "timeout" ); + }, s.timeout ); + } + + try { + completed = false; + transport.send( requestHeaders, done ); + } catch ( e ) { + + // Rethrow post-completion exceptions + if ( completed ) { + throw e; + } + + // Propagate others as results + done( -1, e ); + } + } + + // Callback for when everything is done + function done( status, nativeStatusText, responses, headers ) { + var isSuccess, success, error, response, modified, + statusText = nativeStatusText; + + // Ignore repeat invocations + if ( completed ) { + return; + } + + completed = true; + + // Clear timeout if it exists + if ( timeoutTimer ) { + window.clearTimeout( timeoutTimer ); + } + + // Dereference transport for early garbage collection + // (no matter how long the jqXHR object will be used) + transport = undefined; + + // Cache response headers + responseHeadersString = headers || ""; + + // Set readyState + jqXHR.readyState = status > 0 ? 4 : 0; + + // Determine if successful + isSuccess = status >= 200 && status < 300 || status === 304; + + // Get response data + if ( responses ) { + response = ajaxHandleResponses( s, jqXHR, responses ); + } + + // Use a noop converter for missing script but not if jsonp + if ( !isSuccess && + jQuery.inArray( "script", s.dataTypes ) > -1 && + jQuery.inArray( "json", s.dataTypes ) < 0 ) { + s.converters[ "text script" ] = function() {}; + } + + // Convert no matter what (that way responseXXX fields are always set) + response = ajaxConvert( s, response, jqXHR, isSuccess ); + + // If successful, handle type chaining + if ( isSuccess ) { + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + modified = jqXHR.getResponseHeader( "Last-Modified" ); + if ( modified ) { + jQuery.lastModified[ cacheURL ] = modified; + } + modified = jqXHR.getResponseHeader( "etag" ); + if ( modified ) { + jQuery.etag[ cacheURL ] = modified; + } + } + + // if no content + if ( status === 204 || s.type === "HEAD" ) { + statusText = "nocontent"; + + // if not modified + } else if ( status === 304 ) { + statusText = "notmodified"; + + // If we have data, let's convert it + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + + // Extract error from statusText and normalize for non-aborts + error = statusText; + if ( status || !statusText ) { + statusText = "error"; + if ( status < 0 ) { + status = 0; + } + } + } + + // Set data for the fake xhr object + jqXHR.status = status; + jqXHR.statusText = ( nativeStatusText || statusText ) + ""; + + // Success/Error + if ( isSuccess ) { + deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); + } else { + deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); + } + + // Status-dependent callbacks + jqXHR.statusCode( statusCode ); + statusCode = undefined; + + if ( fireGlobals ) { + globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", + [ jqXHR, s, isSuccess ? success : error ] ); + } + + // Complete + completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); + + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); + + // Handle the global AJAX counter + if ( !( --jQuery.active ) ) { + jQuery.event.trigger( "ajaxStop" ); + } + } + } + + return jqXHR; + }, + + getJSON: function( url, data, callback ) { + return jQuery.get( url, data, callback, "json" ); + }, + + getScript: function( url, callback ) { + return jQuery.get( url, undefined, callback, "script" ); + } +} ); + +jQuery.each( [ "get", "post" ], function( _i, method ) { + jQuery[ method ] = function( url, data, callback, type ) { + + // Shift arguments if data argument was omitted + if ( isFunction( data ) ) { + type = type || callback; + callback = data; + data = undefined; + } + + // The url can be an options object (which then must have .url) + return jQuery.ajax( jQuery.extend( { + url: url, + type: method, + dataType: type, + data: data, + success: callback + }, jQuery.isPlainObject( url ) && url ) ); + }; +} ); + +jQuery.ajaxPrefilter( function( s ) { + var i; + for ( i in s.headers ) { + if ( i.toLowerCase() === "content-type" ) { + s.contentType = s.headers[ i ] || ""; + } + } +} ); + + +jQuery._evalUrl = function( url, options, doc ) { + return jQuery.ajax( { + url: url, + + // Make this explicit, since user can override this through ajaxSetup (#11264) + type: "GET", + dataType: "script", + cache: true, + async: false, + global: false, + + // Only evaluate the response if it is successful (gh-4126) + // dataFilter is not invoked for failure responses, so using it instead + // of the default converter is kludgy but it works. + converters: { + "text script": function() {} + }, + dataFilter: function( response ) { + jQuery.globalEval( response, options, doc ); + } + } ); +}; + + +jQuery.fn.extend( { + wrapAll: function( html ) { + var wrap; + + if ( this[ 0 ] ) { + if ( isFunction( html ) ) { + html = html.call( this[ 0 ] ); + } + + // The elements to wrap the target around + wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); + + if ( this[ 0 ].parentNode ) { + wrap.insertBefore( this[ 0 ] ); + } + + wrap.map( function() { + var elem = this; + + while ( elem.firstElementChild ) { + elem = elem.firstElementChild; + } + + return elem; + } ).append( this ); + } + + return this; + }, + + wrapInner: function( html ) { + if ( isFunction( html ) ) { + return this.each( function( i ) { + jQuery( this ).wrapInner( html.call( this, i ) ); + } ); + } + + return this.each( function() { + var self = jQuery( this ), + contents = self.contents(); + + if ( contents.length ) { + contents.wrapAll( html ); + + } else { + self.append( html ); + } + } ); + }, + + wrap: function( html ) { + var htmlIsFunction = isFunction( html ); + + return this.each( function( i ) { + jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); + } ); + }, + + unwrap: function( selector ) { + this.parent( selector ).not( "body" ).each( function() { + jQuery( this ).replaceWith( this.childNodes ); + } ); + return this; + } +} ); + + +jQuery.expr.pseudos.hidden = function( elem ) { + return !jQuery.expr.pseudos.visible( elem ); +}; +jQuery.expr.pseudos.visible = function( elem ) { + return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); +}; + + + + +jQuery.ajaxSettings.xhr = function() { + try { + return new window.XMLHttpRequest(); + } catch ( e ) {} +}; + +var xhrSuccessStatus = { + + // File protocol always yields status code 0, assume 200 + 0: 200, + + // Support: IE <=9 only + // #1450: sometimes IE returns 1223 when it should be 204 + 1223: 204 + }, + xhrSupported = jQuery.ajaxSettings.xhr(); + +support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); +support.ajax = xhrSupported = !!xhrSupported; + +jQuery.ajaxTransport( function( options ) { + var callback, errorCallback; + + // Cross domain only allowed if supported through XMLHttpRequest + if ( support.cors || xhrSupported && !options.crossDomain ) { + return { + send: function( headers, complete ) { + var i, + xhr = options.xhr(); + + xhr.open( + options.type, + options.url, + options.async, + options.username, + options.password + ); + + // Apply custom fields if provided + if ( options.xhrFields ) { + for ( i in options.xhrFields ) { + xhr[ i ] = options.xhrFields[ i ]; + } + } + + // Override mime type if needed + if ( options.mimeType && xhr.overrideMimeType ) { + xhr.overrideMimeType( options.mimeType ); + } + + // X-Requested-With header + // For cross-domain requests, seeing as conditions for a preflight are + // akin to a jigsaw puzzle, we simply never set it to be sure. + // (it can always be set on a per-request basis or even using ajaxSetup) + // For same-domain requests, won't change header if already provided. + if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { + headers[ "X-Requested-With" ] = "XMLHttpRequest"; + } + + // Set headers + for ( i in headers ) { + xhr.setRequestHeader( i, headers[ i ] ); + } + + // Callback + callback = function( type ) { + return function() { + if ( callback ) { + callback = errorCallback = xhr.onload = + xhr.onerror = xhr.onabort = xhr.ontimeout = + xhr.onreadystatechange = null; + + if ( type === "abort" ) { + xhr.abort(); + } else if ( type === "error" ) { + + // Support: IE <=9 only + // On a manual native abort, IE9 throws + // errors on any property access that is not readyState + if ( typeof xhr.status !== "number" ) { + complete( 0, "error" ); + } else { + complete( + + // File: protocol always yields status 0; see #8605, #14207 + xhr.status, + xhr.statusText + ); + } + } else { + complete( + xhrSuccessStatus[ xhr.status ] || xhr.status, + xhr.statusText, + + // Support: IE <=9 only + // IE9 has no XHR2 but throws on binary (trac-11426) + // For XHR2 non-text, let the caller handle it (gh-2498) + ( xhr.responseType || "text" ) !== "text" || + typeof xhr.responseText !== "string" ? + { binary: xhr.response } : + { text: xhr.responseText }, + xhr.getAllResponseHeaders() + ); + } + } + }; + }; + + // Listen to events + xhr.onload = callback(); + errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); + + // Support: IE 9 only + // Use onreadystatechange to replace onabort + // to handle uncaught aborts + if ( xhr.onabort !== undefined ) { + xhr.onabort = errorCallback; + } else { + xhr.onreadystatechange = function() { + + // Check readyState before timeout as it changes + if ( xhr.readyState === 4 ) { + + // Allow onerror to be called first, + // but that will not handle a native abort + // Also, save errorCallback to a variable + // as xhr.onerror cannot be accessed + window.setTimeout( function() { + if ( callback ) { + errorCallback(); + } + } ); + } + }; + } + + // Create the abort callback + callback = callback( "abort" ); + + try { + + // Do send the request (this may raise an exception) + xhr.send( options.hasContent && options.data || null ); + } catch ( e ) { + + // #14683: Only rethrow if this hasn't been notified as an error yet + if ( callback ) { + throw e; + } + } + }, + + abort: function() { + if ( callback ) { + callback(); + } + } + }; + } +} ); + + + + +// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) +jQuery.ajaxPrefilter( function( s ) { + if ( s.crossDomain ) { + s.contents.script = false; + } +} ); + +// Install script dataType +jQuery.ajaxSetup( { + accepts: { + script: "text/javascript, application/javascript, " + + "application/ecmascript, application/x-ecmascript" + }, + contents: { + script: /\b(?:java|ecma)script\b/ + }, + converters: { + "text script": function( text ) { + jQuery.globalEval( text ); + return text; + } + } +} ); + +// Handle cache's special case and crossDomain +jQuery.ajaxPrefilter( "script", function( s ) { + if ( s.cache === undefined ) { + s.cache = false; + } + if ( s.crossDomain ) { + s.type = "GET"; + } +} ); + +// Bind script tag hack transport +jQuery.ajaxTransport( "script", function( s ) { + + // This transport only deals with cross domain or forced-by-attrs requests + if ( s.crossDomain || s.scriptAttrs ) { + var script, callback; + return { + send: function( _, complete ) { + script = jQuery( " +{% endmacro %} diff --git a/_static/scripts/bootstrap.js b/_static/scripts/bootstrap.js new file mode 100644 index 000000000..bda8a6027 --- /dev/null +++ b/_static/scripts/bootstrap.js @@ -0,0 +1,3 @@ +/*! For license information please see bootstrap.js.LICENSE.txt */ +(()=>{"use strict";var t={d:(e,i)=>{for(var n in i)t.o(i,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:i[n]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{afterMain:()=>w,afterRead:()=>b,afterWrite:()=>T,applyStyles:()=>D,arrow:()=>G,auto:()=>r,basePlacements:()=>a,beforeMain:()=>v,beforeRead:()=>g,beforeWrite:()=>E,bottom:()=>n,clippingParents:()=>h,computeStyles:()=>et,createPopper:()=>St,createPopperBase:()=>Lt,createPopperLite:()=>Dt,detectOverflow:()=>gt,end:()=>c,eventListeners:()=>nt,flip:()=>_t,hide:()=>yt,left:()=>o,main:()=>y,modifierPhases:()=>C,offset:()=>wt,placements:()=>m,popper:()=>u,popperGenerator:()=>kt,popperOffsets:()=>Et,preventOverflow:()=>At,read:()=>_,reference:()=>f,right:()=>s,start:()=>l,top:()=>i,variationPlacements:()=>p,viewport:()=>d,write:()=>A});var i="top",n="bottom",s="right",o="left",r="auto",a=[i,n,s,o],l="start",c="end",h="clippingParents",d="viewport",u="popper",f="reference",p=a.reduce((function(t,e){return t.concat([e+"-"+l,e+"-"+c])}),[]),m=[].concat(a,[r]).reduce((function(t,e){return t.concat([e,e+"-"+l,e+"-"+c])}),[]),g="beforeRead",_="read",b="afterRead",v="beforeMain",y="main",w="afterMain",E="beforeWrite",A="write",T="afterWrite",C=[g,_,b,v,y,w,E,A,T];function O(t){return t?(t.nodeName||"").toLowerCase():null}function x(t){if(null==t)return window;if("[object Window]"!==t.toString()){var e=t.ownerDocument;return e&&e.defaultView||window}return t}function k(t){return t instanceof x(t).Element||t instanceof Element}function L(t){return t instanceof x(t).HTMLElement||t instanceof HTMLElement}function S(t){return"undefined"!=typeof ShadowRoot&&(t instanceof x(t).ShadowRoot||t instanceof ShadowRoot)}const D={name:"applyStyles",enabled:!0,phase:"write",fn:function(t){var e=t.state;Object.keys(e.elements).forEach((function(t){var i=e.styles[t]||{},n=e.attributes[t]||{},s=e.elements[t];L(s)&&O(s)&&(Object.assign(s.style,i),Object.keys(n).forEach((function(t){var e=n[t];!1===e?s.removeAttribute(t):s.setAttribute(t,!0===e?"":e)})))}))},effect:function(t){var e=t.state,i={popper:{position:e.options.strategy,left:"0",top:"0",margin:"0"},arrow:{position:"absolute"},reference:{}};return Object.assign(e.elements.popper.style,i.popper),e.styles=i,e.elements.arrow&&Object.assign(e.elements.arrow.style,i.arrow),function(){Object.keys(e.elements).forEach((function(t){var n=e.elements[t],s=e.attributes[t]||{},o=Object.keys(e.styles.hasOwnProperty(t)?e.styles[t]:i[t]).reduce((function(t,e){return t[e]="",t}),{});L(n)&&O(n)&&(Object.assign(n.style,o),Object.keys(s).forEach((function(t){n.removeAttribute(t)})))}))}},requires:["computeStyles"]};function $(t){return t.split("-")[0]}var I=Math.max,N=Math.min,P=Math.round;function M(){var t=navigator.userAgentData;return null!=t&&t.brands&&Array.isArray(t.brands)?t.brands.map((function(t){return t.brand+"/"+t.version})).join(" "):navigator.userAgent}function j(){return!/^((?!chrome|android).)*safari/i.test(M())}function F(t,e,i){void 0===e&&(e=!1),void 0===i&&(i=!1);var n=t.getBoundingClientRect(),s=1,o=1;e&&L(t)&&(s=t.offsetWidth>0&&P(n.width)/t.offsetWidth||1,o=t.offsetHeight>0&&P(n.height)/t.offsetHeight||1);var r=(k(t)?x(t):window).visualViewport,a=!j()&&i,l=(n.left+(a&&r?r.offsetLeft:0))/s,c=(n.top+(a&&r?r.offsetTop:0))/o,h=n.width/s,d=n.height/o;return{width:h,height:d,top:c,right:l+h,bottom:c+d,left:l,x:l,y:c}}function H(t){var e=F(t),i=t.offsetWidth,n=t.offsetHeight;return Math.abs(e.width-i)<=1&&(i=e.width),Math.abs(e.height-n)<=1&&(n=e.height),{x:t.offsetLeft,y:t.offsetTop,width:i,height:n}}function B(t,e){var i=e.getRootNode&&e.getRootNode();if(t.contains(e))return!0;if(i&&S(i)){var n=e;do{if(n&&t.isSameNode(n))return!0;n=n.parentNode||n.host}while(n)}return!1}function W(t){return x(t).getComputedStyle(t)}function z(t){return["table","td","th"].indexOf(O(t))>=0}function R(t){return((k(t)?t.ownerDocument:t.document)||window.document).documentElement}function q(t){return"html"===O(t)?t:t.assignedSlot||t.parentNode||(S(t)?t.host:null)||R(t)}function V(t){return L(t)&&"fixed"!==W(t).position?t.offsetParent:null}function Y(t){for(var e=x(t),i=V(t);i&&z(i)&&"static"===W(i).position;)i=V(i);return i&&("html"===O(i)||"body"===O(i)&&"static"===W(i).position)?e:i||function(t){var e=/firefox/i.test(M());if(/Trident/i.test(M())&&L(t)&&"fixed"===W(t).position)return null;var i=q(t);for(S(i)&&(i=i.host);L(i)&&["html","body"].indexOf(O(i))<0;){var n=W(i);if("none"!==n.transform||"none"!==n.perspective||"paint"===n.contain||-1!==["transform","perspective"].indexOf(n.willChange)||e&&"filter"===n.willChange||e&&n.filter&&"none"!==n.filter)return i;i=i.parentNode}return null}(t)||e}function K(t){return["top","bottom"].indexOf(t)>=0?"x":"y"}function Q(t,e,i){return I(t,N(e,i))}function X(t){return Object.assign({},{top:0,right:0,bottom:0,left:0},t)}function U(t,e){return e.reduce((function(e,i){return e[i]=t,e}),{})}const G={name:"arrow",enabled:!0,phase:"main",fn:function(t){var e,r=t.state,l=t.name,c=t.options,h=r.elements.arrow,d=r.modifiersData.popperOffsets,u=$(r.placement),f=K(u),p=[o,s].indexOf(u)>=0?"height":"width";if(h&&d){var m=function(t,e){return X("number"!=typeof(t="function"==typeof t?t(Object.assign({},e.rects,{placement:e.placement})):t)?t:U(t,a))}(c.padding,r),g=H(h),_="y"===f?i:o,b="y"===f?n:s,v=r.rects.reference[p]+r.rects.reference[f]-d[f]-r.rects.popper[p],y=d[f]-r.rects.reference[f],w=Y(h),E=w?"y"===f?w.clientHeight||0:w.clientWidth||0:0,A=v/2-y/2,T=m[_],C=E-g[p]-m[b],O=E/2-g[p]/2+A,x=Q(T,O,C),k=f;r.modifiersData[l]=((e={})[k]=x,e.centerOffset=x-O,e)}},effect:function(t){var e=t.state,i=t.options.element,n=void 0===i?"[data-popper-arrow]":i;null!=n&&("string"!=typeof n||(n=e.elements.popper.querySelector(n)))&&B(e.elements.popper,n)&&(e.elements.arrow=n)},requires:["popperOffsets"],requiresIfExists:["preventOverflow"]};function J(t){return t.split("-")[1]}var Z={top:"auto",right:"auto",bottom:"auto",left:"auto"};function tt(t){var e,r=t.popper,a=t.popperRect,l=t.placement,h=t.variation,d=t.offsets,u=t.position,f=t.gpuAcceleration,p=t.adaptive,m=t.roundOffsets,g=t.isFixed,_=d.x,b=void 0===_?0:_,v=d.y,y=void 0===v?0:v,w="function"==typeof m?m({x:b,y}):{x:b,y};b=w.x,y=w.y;var E=d.hasOwnProperty("x"),A=d.hasOwnProperty("y"),T=o,C=i,O=window;if(p){var k=Y(r),L="clientHeight",S="clientWidth";k===x(r)&&"static"!==W(k=R(r)).position&&"absolute"===u&&(L="scrollHeight",S="scrollWidth"),(l===i||(l===o||l===s)&&h===c)&&(C=n,y-=(g&&k===O&&O.visualViewport?O.visualViewport.height:k[L])-a.height,y*=f?1:-1),l!==o&&(l!==i&&l!==n||h!==c)||(T=s,b-=(g&&k===O&&O.visualViewport?O.visualViewport.width:k[S])-a.width,b*=f?1:-1)}var D,$=Object.assign({position:u},p&&Z),I=!0===m?function(t,e){var i=t.x,n=t.y,s=e.devicePixelRatio||1;return{x:P(i*s)/s||0,y:P(n*s)/s||0}}({x:b,y},x(r)):{x:b,y};return b=I.x,y=I.y,f?Object.assign({},$,((D={})[C]=A?"0":"",D[T]=E?"0":"",D.transform=(O.devicePixelRatio||1)<=1?"translate("+b+"px, "+y+"px)":"translate3d("+b+"px, "+y+"px, 0)",D)):Object.assign({},$,((e={})[C]=A?y+"px":"",e[T]=E?b+"px":"",e.transform="",e))}const et={name:"computeStyles",enabled:!0,phase:"beforeWrite",fn:function(t){var e=t.state,i=t.options,n=i.gpuAcceleration,s=void 0===n||n,o=i.adaptive,r=void 0===o||o,a=i.roundOffsets,l=void 0===a||a,c={placement:$(e.placement),variation:J(e.placement),popper:e.elements.popper,popperRect:e.rects.popper,gpuAcceleration:s,isFixed:"fixed"===e.options.strategy};null!=e.modifiersData.popperOffsets&&(e.styles.popper=Object.assign({},e.styles.popper,tt(Object.assign({},c,{offsets:e.modifiersData.popperOffsets,position:e.options.strategy,adaptive:r,roundOffsets:l})))),null!=e.modifiersData.arrow&&(e.styles.arrow=Object.assign({},e.styles.arrow,tt(Object.assign({},c,{offsets:e.modifiersData.arrow,position:"absolute",adaptive:!1,roundOffsets:l})))),e.attributes.popper=Object.assign({},e.attributes.popper,{"data-popper-placement":e.placement})},data:{}};var it={passive:!0};const nt={name:"eventListeners",enabled:!0,phase:"write",fn:function(){},effect:function(t){var e=t.state,i=t.instance,n=t.options,s=n.scroll,o=void 0===s||s,r=n.resize,a=void 0===r||r,l=x(e.elements.popper),c=[].concat(e.scrollParents.reference,e.scrollParents.popper);return o&&c.forEach((function(t){t.addEventListener("scroll",i.update,it)})),a&&l.addEventListener("resize",i.update,it),function(){o&&c.forEach((function(t){t.removeEventListener("scroll",i.update,it)})),a&&l.removeEventListener("resize",i.update,it)}},data:{}};var st={left:"right",right:"left",bottom:"top",top:"bottom"};function ot(t){return t.replace(/left|right|bottom|top/g,(function(t){return st[t]}))}var rt={start:"end",end:"start"};function at(t){return t.replace(/start|end/g,(function(t){return rt[t]}))}function lt(t){var e=x(t);return{scrollLeft:e.pageXOffset,scrollTop:e.pageYOffset}}function ct(t){return F(R(t)).left+lt(t).scrollLeft}function ht(t){var e=W(t),i=e.overflow,n=e.overflowX,s=e.overflowY;return/auto|scroll|overlay|hidden/.test(i+s+n)}function dt(t){return["html","body","#document"].indexOf(O(t))>=0?t.ownerDocument.body:L(t)&&ht(t)?t:dt(q(t))}function ut(t,e){var i;void 0===e&&(e=[]);var n=dt(t),s=n===(null==(i=t.ownerDocument)?void 0:i.body),o=x(n),r=s?[o].concat(o.visualViewport||[],ht(n)?n:[]):n,a=e.concat(r);return s?a:a.concat(ut(q(r)))}function ft(t){return Object.assign({},t,{left:t.x,top:t.y,right:t.x+t.width,bottom:t.y+t.height})}function pt(t,e,i){return e===d?ft(function(t,e){var i=x(t),n=R(t),s=i.visualViewport,o=n.clientWidth,r=n.clientHeight,a=0,l=0;if(s){o=s.width,r=s.height;var c=j();(c||!c&&"fixed"===e)&&(a=s.offsetLeft,l=s.offsetTop)}return{width:o,height:r,x:a+ct(t),y:l}}(t,i)):k(e)?function(t,e){var i=F(t,!1,"fixed"===e);return i.top=i.top+t.clientTop,i.left=i.left+t.clientLeft,i.bottom=i.top+t.clientHeight,i.right=i.left+t.clientWidth,i.width=t.clientWidth,i.height=t.clientHeight,i.x=i.left,i.y=i.top,i}(e,i):ft(function(t){var e,i=R(t),n=lt(t),s=null==(e=t.ownerDocument)?void 0:e.body,o=I(i.scrollWidth,i.clientWidth,s?s.scrollWidth:0,s?s.clientWidth:0),r=I(i.scrollHeight,i.clientHeight,s?s.scrollHeight:0,s?s.clientHeight:0),a=-n.scrollLeft+ct(t),l=-n.scrollTop;return"rtl"===W(s||i).direction&&(a+=I(i.clientWidth,s?s.clientWidth:0)-o),{width:o,height:r,x:a,y:l}}(R(t)))}function mt(t){var e,r=t.reference,a=t.element,h=t.placement,d=h?$(h):null,u=h?J(h):null,f=r.x+r.width/2-a.width/2,p=r.y+r.height/2-a.height/2;switch(d){case i:e={x:f,y:r.y-a.height};break;case n:e={x:f,y:r.y+r.height};break;case s:e={x:r.x+r.width,y:p};break;case o:e={x:r.x-a.width,y:p};break;default:e={x:r.x,y:r.y}}var m=d?K(d):null;if(null!=m){var g="y"===m?"height":"width";switch(u){case l:e[m]=e[m]-(r[g]/2-a[g]/2);break;case c:e[m]=e[m]+(r[g]/2-a[g]/2)}}return e}function gt(t,e){void 0===e&&(e={});var o=e,r=o.placement,l=void 0===r?t.placement:r,c=o.strategy,p=void 0===c?t.strategy:c,m=o.boundary,g=void 0===m?h:m,_=o.rootBoundary,b=void 0===_?d:_,v=o.elementContext,y=void 0===v?u:v,w=o.altBoundary,E=void 0!==w&&w,A=o.padding,T=void 0===A?0:A,C=X("number"!=typeof T?T:U(T,a)),x=y===u?f:u,S=t.rects.popper,D=t.elements[E?x:y],$=function(t,e,i,n){var s="clippingParents"===e?function(t){var e=ut(q(t)),i=["absolute","fixed"].indexOf(W(t).position)>=0&&L(t)?Y(t):t;return k(i)?e.filter((function(t){return k(t)&&B(t,i)&&"body"!==O(t)})):[]}(t):[].concat(e),o=[].concat(s,[i]),r=o[0],a=o.reduce((function(e,i){var s=pt(t,i,n);return e.top=I(s.top,e.top),e.right=N(s.right,e.right),e.bottom=N(s.bottom,e.bottom),e.left=I(s.left,e.left),e}),pt(t,r,n));return a.width=a.right-a.left,a.height=a.bottom-a.top,a.x=a.left,a.y=a.top,a}(k(D)?D:D.contextElement||R(t.elements.popper),g,b,p),P=F(t.elements.reference),M=mt({reference:P,element:S,strategy:"absolute",placement:l}),j=ft(Object.assign({},S,M)),H=y===u?j:P,z={top:$.top-H.top+C.top,bottom:H.bottom-$.bottom+C.bottom,left:$.left-H.left+C.left,right:H.right-$.right+C.right},V=t.modifiersData.offset;if(y===u&&V){var K=V[l];Object.keys(z).forEach((function(t){var e=[s,n].indexOf(t)>=0?1:-1,o=[i,n].indexOf(t)>=0?"y":"x";z[t]+=K[o]*e}))}return z}const _t={name:"flip",enabled:!0,phase:"main",fn:function(t){var e=t.state,c=t.options,h=t.name;if(!e.modifiersData[h]._skip){for(var d=c.mainAxis,u=void 0===d||d,f=c.altAxis,g=void 0===f||f,_=c.fallbackPlacements,b=c.padding,v=c.boundary,y=c.rootBoundary,w=c.altBoundary,E=c.flipVariations,A=void 0===E||E,T=c.allowedAutoPlacements,C=e.options.placement,O=$(C),x=_||(O!==C&&A?function(t){if($(t)===r)return[];var e=ot(t);return[at(t),e,at(e)]}(C):[ot(C)]),k=[C].concat(x).reduce((function(t,i){return t.concat($(i)===r?function(t,e){void 0===e&&(e={});var i=e,n=i.placement,s=i.boundary,o=i.rootBoundary,r=i.padding,l=i.flipVariations,c=i.allowedAutoPlacements,h=void 0===c?m:c,d=J(n),u=d?l?p:p.filter((function(t){return J(t)===d})):a,f=u.filter((function(t){return h.indexOf(t)>=0}));0===f.length&&(f=u);var g=f.reduce((function(e,i){return e[i]=gt(t,{placement:i,boundary:s,rootBoundary:o,padding:r})[$(i)],e}),{});return Object.keys(g).sort((function(t,e){return g[t]-g[e]}))}(e,{placement:i,boundary:v,rootBoundary:y,padding:b,flipVariations:A,allowedAutoPlacements:T}):i)}),[]),L=e.rects.reference,S=e.rects.popper,D=new Map,I=!0,N=k[0],P=0;P=0,B=H?"width":"height",W=gt(e,{placement:M,boundary:v,rootBoundary:y,altBoundary:w,padding:b}),z=H?F?s:o:F?n:i;L[B]>S[B]&&(z=ot(z));var R=ot(z),q=[];if(u&&q.push(W[j]<=0),g&&q.push(W[z]<=0,W[R]<=0),q.every((function(t){return t}))){N=M,I=!1;break}D.set(M,q)}if(I)for(var V=function(t){var e=k.find((function(e){var i=D.get(e);if(i)return i.slice(0,t).every((function(t){return t}))}));if(e)return N=e,"break"},Y=A?3:1;Y>0&&"break"!==V(Y);Y--);e.placement!==N&&(e.modifiersData[h]._skip=!0,e.placement=N,e.reset=!0)}},requiresIfExists:["offset"],data:{_skip:!1}};function bt(t,e,i){return void 0===i&&(i={x:0,y:0}),{top:t.top-e.height-i.y,right:t.right-e.width+i.x,bottom:t.bottom-e.height+i.y,left:t.left-e.width-i.x}}function vt(t){return[i,s,n,o].some((function(e){return t[e]>=0}))}const yt={name:"hide",enabled:!0,phase:"main",requiresIfExists:["preventOverflow"],fn:function(t){var e=t.state,i=t.name,n=e.rects.reference,s=e.rects.popper,o=e.modifiersData.preventOverflow,r=gt(e,{elementContext:"reference"}),a=gt(e,{altBoundary:!0}),l=bt(r,n),c=bt(a,s,o),h=vt(l),d=vt(c);e.modifiersData[i]={referenceClippingOffsets:l,popperEscapeOffsets:c,isReferenceHidden:h,hasPopperEscaped:d},e.attributes.popper=Object.assign({},e.attributes.popper,{"data-popper-reference-hidden":h,"data-popper-escaped":d})}},wt={name:"offset",enabled:!0,phase:"main",requires:["popperOffsets"],fn:function(t){var e=t.state,n=t.options,r=t.name,a=n.offset,l=void 0===a?[0,0]:a,c=m.reduce((function(t,n){return t[n]=function(t,e,n){var r=$(t),a=[o,i].indexOf(r)>=0?-1:1,l="function"==typeof n?n(Object.assign({},e,{placement:t})):n,c=l[0],h=l[1];return c=c||0,h=(h||0)*a,[o,s].indexOf(r)>=0?{x:h,y:c}:{x:c,y:h}}(n,e.rects,l),t}),{}),h=c[e.placement],d=h.x,u=h.y;null!=e.modifiersData.popperOffsets&&(e.modifiersData.popperOffsets.x+=d,e.modifiersData.popperOffsets.y+=u),e.modifiersData[r]=c}},Et={name:"popperOffsets",enabled:!0,phase:"read",fn:function(t){var e=t.state,i=t.name;e.modifiersData[i]=mt({reference:e.rects.reference,element:e.rects.popper,strategy:"absolute",placement:e.placement})},data:{}},At={name:"preventOverflow",enabled:!0,phase:"main",fn:function(t){var e=t.state,r=t.options,a=t.name,c=r.mainAxis,h=void 0===c||c,d=r.altAxis,u=void 0!==d&&d,f=r.boundary,p=r.rootBoundary,m=r.altBoundary,g=r.padding,_=r.tether,b=void 0===_||_,v=r.tetherOffset,y=void 0===v?0:v,w=gt(e,{boundary:f,rootBoundary:p,padding:g,altBoundary:m}),E=$(e.placement),A=J(e.placement),T=!A,C=K(E),O="x"===C?"y":"x",x=e.modifiersData.popperOffsets,k=e.rects.reference,L=e.rects.popper,S="function"==typeof y?y(Object.assign({},e.rects,{placement:e.placement})):y,D="number"==typeof S?{mainAxis:S,altAxis:S}:Object.assign({mainAxis:0,altAxis:0},S),P=e.modifiersData.offset?e.modifiersData.offset[e.placement]:null,M={x:0,y:0};if(x){if(h){var j,F="y"===C?i:o,B="y"===C?n:s,W="y"===C?"height":"width",z=x[C],R=z+w[F],q=z-w[B],V=b?-L[W]/2:0,X=A===l?k[W]:L[W],U=A===l?-L[W]:-k[W],G=e.elements.arrow,Z=b&&G?H(G):{width:0,height:0},tt=e.modifiersData["arrow#persistent"]?e.modifiersData["arrow#persistent"].padding:{top:0,right:0,bottom:0,left:0},et=tt[F],it=tt[B],nt=Q(0,k[W],Z[W]),st=T?k[W]/2-V-nt-et-D.mainAxis:X-nt-et-D.mainAxis,ot=T?-k[W]/2+V+nt+it+D.mainAxis:U+nt+it+D.mainAxis,rt=e.elements.arrow&&Y(e.elements.arrow),at=rt?"y"===C?rt.clientTop||0:rt.clientLeft||0:0,lt=null!=(j=null==P?void 0:P[C])?j:0,ct=z+ot-lt,ht=Q(b?N(R,z+st-lt-at):R,z,b?I(q,ct):q);x[C]=ht,M[C]=ht-z}if(u){var dt,ut="x"===C?i:o,ft="x"===C?n:s,pt=x[O],mt="y"===O?"height":"width",_t=pt+w[ut],bt=pt-w[ft],vt=-1!==[i,o].indexOf(E),yt=null!=(dt=null==P?void 0:P[O])?dt:0,wt=vt?_t:pt-k[mt]-L[mt]-yt+D.altAxis,Et=vt?pt+k[mt]+L[mt]-yt-D.altAxis:bt,At=b&&vt?function(t,e,i){var n=Q(t,e,i);return n>i?i:n}(wt,pt,Et):Q(b?wt:_t,pt,b?Et:bt);x[O]=At,M[O]=At-pt}e.modifiersData[a]=M}},requiresIfExists:["offset"]};function Tt(t,e,i){void 0===i&&(i=!1);var n,s,o=L(e),r=L(e)&&function(t){var e=t.getBoundingClientRect(),i=P(e.width)/t.offsetWidth||1,n=P(e.height)/t.offsetHeight||1;return 1!==i||1!==n}(e),a=R(e),l=F(t,r,i),c={scrollLeft:0,scrollTop:0},h={x:0,y:0};return(o||!o&&!i)&&(("body"!==O(e)||ht(a))&&(c=(n=e)!==x(n)&&L(n)?{scrollLeft:(s=n).scrollLeft,scrollTop:s.scrollTop}:lt(n)),L(e)?((h=F(e,!0)).x+=e.clientLeft,h.y+=e.clientTop):a&&(h.x=ct(a))),{x:l.left+c.scrollLeft-h.x,y:l.top+c.scrollTop-h.y,width:l.width,height:l.height}}function Ct(t){var e=new Map,i=new Set,n=[];function s(t){i.add(t.name),[].concat(t.requires||[],t.requiresIfExists||[]).forEach((function(t){if(!i.has(t)){var n=e.get(t);n&&s(n)}})),n.push(t)}return t.forEach((function(t){e.set(t.name,t)})),t.forEach((function(t){i.has(t.name)||s(t)})),n}var Ot={placement:"bottom",modifiers:[],strategy:"absolute"};function xt(){for(var t=arguments.length,e=new Array(t),i=0;i$t.has(t)&&$t.get(t).get(e)||null,remove(t,e){if(!$t.has(t))return;const i=$t.get(t);i.delete(e),0===i.size&&$t.delete(t)}},Nt="transitionend",Pt=t=>(t&&window.CSS&&window.CSS.escape&&(t=t.replace(/#([^\s"#']+)/g,((t,e)=>`#${CSS.escape(e)}`))),t),Mt=t=>{t.dispatchEvent(new Event(Nt))},jt=t=>!(!t||"object"!=typeof t)&&(void 0!==t.jquery&&(t=t[0]),void 0!==t.nodeType),Ft=t=>jt(t)?t.jquery?t[0]:t:"string"==typeof t&&t.length>0?document.querySelector(Pt(t)):null,Ht=t=>{if(!jt(t)||0===t.getClientRects().length)return!1;const e="visible"===getComputedStyle(t).getPropertyValue("visibility"),i=t.closest("details:not([open])");if(!i)return e;if(i!==t){const e=t.closest("summary");if(e&&e.parentNode!==i)return!1;if(null===e)return!1}return e},Bt=t=>!t||t.nodeType!==Node.ELEMENT_NODE||!!t.classList.contains("disabled")||(void 0!==t.disabled?t.disabled:t.hasAttribute("disabled")&&"false"!==t.getAttribute("disabled")),Wt=t=>{if(!document.documentElement.attachShadow)return null;if("function"==typeof t.getRootNode){const e=t.getRootNode();return e instanceof ShadowRoot?e:null}return t instanceof ShadowRoot?t:t.parentNode?Wt(t.parentNode):null},zt=()=>{},Rt=t=>{t.offsetHeight},qt=()=>window.jQuery&&!document.body.hasAttribute("data-bs-no-jquery")?window.jQuery:null,Vt=[],Yt=()=>"rtl"===document.documentElement.dir,Kt=t=>{var e;e=()=>{const e=qt();if(e){const i=t.NAME,n=e.fn[i];e.fn[i]=t.jQueryInterface,e.fn[i].Constructor=t,e.fn[i].noConflict=()=>(e.fn[i]=n,t.jQueryInterface)}},"loading"===document.readyState?(Vt.length||document.addEventListener("DOMContentLoaded",(()=>{for(const t of Vt)t()})),Vt.push(e)):e()},Qt=(t,e=[],i=t)=>"function"==typeof t?t(...e):i,Xt=(t,e,i=!0)=>{if(!i)return void Qt(t);const n=(t=>{if(!t)return 0;let{transitionDuration:e,transitionDelay:i}=window.getComputedStyle(t);const n=Number.parseFloat(e),s=Number.parseFloat(i);return n||s?(e=e.split(",")[0],i=i.split(",")[0],1e3*(Number.parseFloat(e)+Number.parseFloat(i))):0})(e)+5;let s=!1;const o=({target:i})=>{i===e&&(s=!0,e.removeEventListener(Nt,o),Qt(t))};e.addEventListener(Nt,o),setTimeout((()=>{s||Mt(e)}),n)},Ut=(t,e,i,n)=>{const s=t.length;let o=t.indexOf(e);return-1===o?!i&&n?t[s-1]:t[0]:(o+=i?1:-1,n&&(o=(o+s)%s),t[Math.max(0,Math.min(o,s-1))])},Gt=/[^.]*(?=\..*)\.|.*/,Jt=/\..*/,Zt=/::\d+$/,te={};let ee=1;const ie={mouseenter:"mouseover",mouseleave:"mouseout"},ne=new Set(["click","dblclick","mouseup","mousedown","contextmenu","mousewheel","DOMMouseScroll","mouseover","mouseout","mousemove","selectstart","selectend","keydown","keypress","keyup","orientationchange","touchstart","touchmove","touchend","touchcancel","pointerdown","pointermove","pointerup","pointerleave","pointercancel","gesturestart","gesturechange","gestureend","focus","blur","change","reset","select","submit","focusin","focusout","load","unload","beforeunload","resize","move","DOMContentLoaded","readystatechange","error","abort","scroll"]);function se(t,e){return e&&`${e}::${ee++}`||t.uidEvent||ee++}function oe(t){const e=se(t);return t.uidEvent=e,te[e]=te[e]||{},te[e]}function re(t,e,i=null){return Object.values(t).find((t=>t.callable===e&&t.delegationSelector===i))}function ae(t,e,i){const n="string"==typeof e,s=n?i:e||i;let o=de(t);return ne.has(o)||(o=t),[n,s,o]}function le(t,e,i,n,s){if("string"!=typeof e||!t)return;let[o,r,a]=ae(e,i,n);if(e in ie){const t=t=>function(e){if(!e.relatedTarget||e.relatedTarget!==e.delegateTarget&&!e.delegateTarget.contains(e.relatedTarget))return t.call(this,e)};r=t(r)}const l=oe(t),c=l[a]||(l[a]={}),h=re(c,r,o?i:null);if(h)return void(h.oneOff=h.oneOff&&s);const d=se(r,e.replace(Gt,"")),u=o?function(t,e,i){return function n(s){const o=t.querySelectorAll(e);for(let{target:r}=s;r&&r!==this;r=r.parentNode)for(const a of o)if(a===r)return fe(s,{delegateTarget:r}),n.oneOff&&ue.off(t,s.type,e,i),i.apply(r,[s])}}(t,i,r):function(t,e){return function i(n){return fe(n,{delegateTarget:t}),i.oneOff&&ue.off(t,n.type,e),e.apply(t,[n])}}(t,r);u.delegationSelector=o?i:null,u.callable=r,u.oneOff=s,u.uidEvent=d,c[d]=u,t.addEventListener(a,u,o)}function ce(t,e,i,n,s){const o=re(e[i],n,s);o&&(t.removeEventListener(i,o,Boolean(s)),delete e[i][o.uidEvent])}function he(t,e,i,n){const s=e[i]||{};for(const[o,r]of Object.entries(s))o.includes(n)&&ce(t,e,i,r.callable,r.delegationSelector)}function de(t){return t=t.replace(Jt,""),ie[t]||t}const ue={on(t,e,i,n){le(t,e,i,n,!1)},one(t,e,i,n){le(t,e,i,n,!0)},off(t,e,i,n){if("string"!=typeof e||!t)return;const[s,o,r]=ae(e,i,n),a=r!==e,l=oe(t),c=l[r]||{},h=e.startsWith(".");if(void 0===o){if(h)for(const i of Object.keys(l))he(t,l,i,e.slice(1));for(const[i,n]of Object.entries(c)){const s=i.replace(Zt,"");a&&!e.includes(s)||ce(t,l,r,n.callable,n.delegationSelector)}}else{if(!Object.keys(c).length)return;ce(t,l,r,o,s?i:null)}},trigger(t,e,i){if("string"!=typeof e||!t)return null;const n=qt();let s=null,o=!0,r=!0,a=!1;e!==de(e)&&n&&(s=n.Event(e,i),n(t).trigger(s),o=!s.isPropagationStopped(),r=!s.isImmediatePropagationStopped(),a=s.isDefaultPrevented());const l=fe(new Event(e,{bubbles:o,cancelable:!0}),i);return a&&l.preventDefault(),r&&t.dispatchEvent(l),l.defaultPrevented&&s&&s.preventDefault(),l}};function fe(t,e={}){for(const[i,n]of Object.entries(e))try{t[i]=n}catch(e){Object.defineProperty(t,i,{configurable:!0,get:()=>n})}return t}function pe(t){if("true"===t)return!0;if("false"===t)return!1;if(t===Number(t).toString())return Number(t);if(""===t||"null"===t)return null;if("string"!=typeof t)return t;try{return JSON.parse(decodeURIComponent(t))}catch(e){return t}}function me(t){return t.replace(/[A-Z]/g,(t=>`-${t.toLowerCase()}`))}const ge={setDataAttribute(t,e,i){t.setAttribute(`data-bs-${me(e)}`,i)},removeDataAttribute(t,e){t.removeAttribute(`data-bs-${me(e)}`)},getDataAttributes(t){if(!t)return{};const e={},i=Object.keys(t.dataset).filter((t=>t.startsWith("bs")&&!t.startsWith("bsConfig")));for(const n of i){let i=n.replace(/^bs/,"");i=i.charAt(0).toLowerCase()+i.slice(1,i.length),e[i]=pe(t.dataset[n])}return e},getDataAttribute:(t,e)=>pe(t.getAttribute(`data-bs-${me(e)}`))};class _e{static get Default(){return{}}static get DefaultType(){return{}}static get NAME(){throw new Error('You have to implement the static method "NAME", for each component!')}_getConfig(t){return t=this._mergeConfigObj(t),t=this._configAfterMerge(t),this._typeCheckConfig(t),t}_configAfterMerge(t){return t}_mergeConfigObj(t,e){const i=jt(e)?ge.getDataAttribute(e,"config"):{};return{...this.constructor.Default,..."object"==typeof i?i:{},...jt(e)?ge.getDataAttributes(e):{},..."object"==typeof t?t:{}}}_typeCheckConfig(t,e=this.constructor.DefaultType){for(const[n,s]of Object.entries(e)){const e=t[n],o=jt(e)?"element":null==(i=e)?`${i}`:Object.prototype.toString.call(i).match(/\s([a-z]+)/i)[1].toLowerCase();if(!new RegExp(s).test(o))throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${n}" provided type "${o}" but expected type "${s}".`)}var i}}class be extends _e{constructor(t,e){super(),(t=Ft(t))&&(this._element=t,this._config=this._getConfig(e),It.set(this._element,this.constructor.DATA_KEY,this))}dispose(){It.remove(this._element,this.constructor.DATA_KEY),ue.off(this._element,this.constructor.EVENT_KEY);for(const t of Object.getOwnPropertyNames(this))this[t]=null}_queueCallback(t,e,i=!0){Xt(t,e,i)}_getConfig(t){return t=this._mergeConfigObj(t,this._element),t=this._configAfterMerge(t),this._typeCheckConfig(t),t}static getInstance(t){return It.get(Ft(t),this.DATA_KEY)}static getOrCreateInstance(t,e={}){return this.getInstance(t)||new this(t,"object"==typeof e?e:null)}static get VERSION(){return"5.3.2"}static get DATA_KEY(){return`bs.${this.NAME}`}static get EVENT_KEY(){return`.${this.DATA_KEY}`}static eventName(t){return`${t}${this.EVENT_KEY}`}}const ve=t=>{let e=t.getAttribute("data-bs-target");if(!e||"#"===e){let i=t.getAttribute("href");if(!i||!i.includes("#")&&!i.startsWith("."))return null;i.includes("#")&&!i.startsWith("#")&&(i=`#${i.split("#")[1]}`),e=i&&"#"!==i?Pt(i.trim()):null}return e},ye={find:(t,e=document.documentElement)=>[].concat(...Element.prototype.querySelectorAll.call(e,t)),findOne:(t,e=document.documentElement)=>Element.prototype.querySelector.call(e,t),children:(t,e)=>[].concat(...t.children).filter((t=>t.matches(e))),parents(t,e){const i=[];let n=t.parentNode.closest(e);for(;n;)i.push(n),n=n.parentNode.closest(e);return i},prev(t,e){let i=t.previousElementSibling;for(;i;){if(i.matches(e))return[i];i=i.previousElementSibling}return[]},next(t,e){let i=t.nextElementSibling;for(;i;){if(i.matches(e))return[i];i=i.nextElementSibling}return[]},focusableChildren(t){const e=["a","button","input","textarea","select","details","[tabindex]",'[contenteditable="true"]'].map((t=>`${t}:not([tabindex^="-"])`)).join(",");return this.find(e,t).filter((t=>!Bt(t)&&Ht(t)))},getSelectorFromElement(t){const e=ve(t);return e&&ye.findOne(e)?e:null},getElementFromSelector(t){const e=ve(t);return e?ye.findOne(e):null},getMultipleElementsFromSelector(t){const e=ve(t);return e?ye.find(e):[]}},we=(t,e="hide")=>{const i=`click.dismiss${t.EVENT_KEY}`,n=t.NAME;ue.on(document,i,`[data-bs-dismiss="${n}"]`,(function(i){if(["A","AREA"].includes(this.tagName)&&i.preventDefault(),Bt(this))return;const s=ye.getElementFromSelector(this)||this.closest(`.${n}`);t.getOrCreateInstance(s)[e]()}))},Ee=".bs.alert",Ae=`close${Ee}`,Te=`closed${Ee}`;class Ce extends be{static get NAME(){return"alert"}close(){if(ue.trigger(this._element,Ae).defaultPrevented)return;this._element.classList.remove("show");const t=this._element.classList.contains("fade");this._queueCallback((()=>this._destroyElement()),this._element,t)}_destroyElement(){this._element.remove(),ue.trigger(this._element,Te),this.dispose()}static jQueryInterface(t){return this.each((function(){const e=Ce.getOrCreateInstance(this);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}we(Ce,"close"),Kt(Ce);const Oe='[data-bs-toggle="button"]';class xe extends be{static get NAME(){return"button"}toggle(){this._element.setAttribute("aria-pressed",this._element.classList.toggle("active"))}static jQueryInterface(t){return this.each((function(){const e=xe.getOrCreateInstance(this);"toggle"===t&&e[t]()}))}}ue.on(document,"click.bs.button.data-api",Oe,(t=>{t.preventDefault();const e=t.target.closest(Oe);xe.getOrCreateInstance(e).toggle()})),Kt(xe);const ke=".bs.swipe",Le=`touchstart${ke}`,Se=`touchmove${ke}`,De=`touchend${ke}`,$e=`pointerdown${ke}`,Ie=`pointerup${ke}`,Ne={endCallback:null,leftCallback:null,rightCallback:null},Pe={endCallback:"(function|null)",leftCallback:"(function|null)",rightCallback:"(function|null)"};class Me extends _e{constructor(t,e){super(),this._element=t,t&&Me.isSupported()&&(this._config=this._getConfig(e),this._deltaX=0,this._supportPointerEvents=Boolean(window.PointerEvent),this._initEvents())}static get Default(){return Ne}static get DefaultType(){return Pe}static get NAME(){return"swipe"}dispose(){ue.off(this._element,ke)}_start(t){this._supportPointerEvents?this._eventIsPointerPenTouch(t)&&(this._deltaX=t.clientX):this._deltaX=t.touches[0].clientX}_end(t){this._eventIsPointerPenTouch(t)&&(this._deltaX=t.clientX-this._deltaX),this._handleSwipe(),Qt(this._config.endCallback)}_move(t){this._deltaX=t.touches&&t.touches.length>1?0:t.touches[0].clientX-this._deltaX}_handleSwipe(){const t=Math.abs(this._deltaX);if(t<=40)return;const e=t/this._deltaX;this._deltaX=0,e&&Qt(e>0?this._config.rightCallback:this._config.leftCallback)}_initEvents(){this._supportPointerEvents?(ue.on(this._element,$e,(t=>this._start(t))),ue.on(this._element,Ie,(t=>this._end(t))),this._element.classList.add("pointer-event")):(ue.on(this._element,Le,(t=>this._start(t))),ue.on(this._element,Se,(t=>this._move(t))),ue.on(this._element,De,(t=>this._end(t))))}_eventIsPointerPenTouch(t){return this._supportPointerEvents&&("pen"===t.pointerType||"touch"===t.pointerType)}static isSupported(){return"ontouchstart"in document.documentElement||navigator.maxTouchPoints>0}}const je=".bs.carousel",Fe=".data-api",He="next",Be="prev",We="left",ze="right",Re=`slide${je}`,qe=`slid${je}`,Ve=`keydown${je}`,Ye=`mouseenter${je}`,Ke=`mouseleave${je}`,Qe=`dragstart${je}`,Xe=`load${je}${Fe}`,Ue=`click${je}${Fe}`,Ge="carousel",Je="active",Ze=".active",ti=".carousel-item",ei=Ze+ti,ii={ArrowLeft:ze,ArrowRight:We},ni={interval:5e3,keyboard:!0,pause:"hover",ride:!1,touch:!0,wrap:!0},si={interval:"(number|boolean)",keyboard:"boolean",pause:"(string|boolean)",ride:"(boolean|string)",touch:"boolean",wrap:"boolean"};class oi extends be{constructor(t,e){super(t,e),this._interval=null,this._activeElement=null,this._isSliding=!1,this.touchTimeout=null,this._swipeHelper=null,this._indicatorsElement=ye.findOne(".carousel-indicators",this._element),this._addEventListeners(),this._config.ride===Ge&&this.cycle()}static get Default(){return ni}static get DefaultType(){return si}static get NAME(){return"carousel"}next(){this._slide(He)}nextWhenVisible(){!document.hidden&&Ht(this._element)&&this.next()}prev(){this._slide(Be)}pause(){this._isSliding&&Mt(this._element),this._clearInterval()}cycle(){this._clearInterval(),this._updateInterval(),this._interval=setInterval((()=>this.nextWhenVisible()),this._config.interval)}_maybeEnableCycle(){this._config.ride&&(this._isSliding?ue.one(this._element,qe,(()=>this.cycle())):this.cycle())}to(t){const e=this._getItems();if(t>e.length-1||t<0)return;if(this._isSliding)return void ue.one(this._element,qe,(()=>this.to(t)));const i=this._getItemIndex(this._getActive());if(i===t)return;const n=t>i?He:Be;this._slide(n,e[t])}dispose(){this._swipeHelper&&this._swipeHelper.dispose(),super.dispose()}_configAfterMerge(t){return t.defaultInterval=t.interval,t}_addEventListeners(){this._config.keyboard&&ue.on(this._element,Ve,(t=>this._keydown(t))),"hover"===this._config.pause&&(ue.on(this._element,Ye,(()=>this.pause())),ue.on(this._element,Ke,(()=>this._maybeEnableCycle()))),this._config.touch&&Me.isSupported()&&this._addTouchEventListeners()}_addTouchEventListeners(){for(const t of ye.find(".carousel-item img",this._element))ue.on(t,Qe,(t=>t.preventDefault()));const t={leftCallback:()=>this._slide(this._directionToOrder(We)),rightCallback:()=>this._slide(this._directionToOrder(ze)),endCallback:()=>{"hover"===this._config.pause&&(this.pause(),this.touchTimeout&&clearTimeout(this.touchTimeout),this.touchTimeout=setTimeout((()=>this._maybeEnableCycle()),500+this._config.interval))}};this._swipeHelper=new Me(this._element,t)}_keydown(t){if(/input|textarea/i.test(t.target.tagName))return;const e=ii[t.key];e&&(t.preventDefault(),this._slide(this._directionToOrder(e)))}_getItemIndex(t){return this._getItems().indexOf(t)}_setActiveIndicatorElement(t){if(!this._indicatorsElement)return;const e=ye.findOne(Ze,this._indicatorsElement);e.classList.remove(Je),e.removeAttribute("aria-current");const i=ye.findOne(`[data-bs-slide-to="${t}"]`,this._indicatorsElement);i&&(i.classList.add(Je),i.setAttribute("aria-current","true"))}_updateInterval(){const t=this._activeElement||this._getActive();if(!t)return;const e=Number.parseInt(t.getAttribute("data-bs-interval"),10);this._config.interval=e||this._config.defaultInterval}_slide(t,e=null){if(this._isSliding)return;const i=this._getActive(),n=t===He,s=e||Ut(this._getItems(),i,n,this._config.wrap);if(s===i)return;const o=this._getItemIndex(s),r=e=>ue.trigger(this._element,e,{relatedTarget:s,direction:this._orderToDirection(t),from:this._getItemIndex(i),to:o});if(r(Re).defaultPrevented)return;if(!i||!s)return;const a=Boolean(this._interval);this.pause(),this._isSliding=!0,this._setActiveIndicatorElement(o),this._activeElement=s;const l=n?"carousel-item-start":"carousel-item-end",c=n?"carousel-item-next":"carousel-item-prev";s.classList.add(c),Rt(s),i.classList.add(l),s.classList.add(l),this._queueCallback((()=>{s.classList.remove(l,c),s.classList.add(Je),i.classList.remove(Je,c,l),this._isSliding=!1,r(qe)}),i,this._isAnimated()),a&&this.cycle()}_isAnimated(){return this._element.classList.contains("slide")}_getActive(){return ye.findOne(ei,this._element)}_getItems(){return ye.find(ti,this._element)}_clearInterval(){this._interval&&(clearInterval(this._interval),this._interval=null)}_directionToOrder(t){return Yt()?t===We?Be:He:t===We?He:Be}_orderToDirection(t){return Yt()?t===Be?We:ze:t===Be?ze:We}static jQueryInterface(t){return this.each((function(){const e=oi.getOrCreateInstance(this,t);if("number"!=typeof t){if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t]()}}else e.to(t)}))}}ue.on(document,Ue,"[data-bs-slide], [data-bs-slide-to]",(function(t){const e=ye.getElementFromSelector(this);if(!e||!e.classList.contains(Ge))return;t.preventDefault();const i=oi.getOrCreateInstance(e),n=this.getAttribute("data-bs-slide-to");return n?(i.to(n),void i._maybeEnableCycle()):"next"===ge.getDataAttribute(this,"slide")?(i.next(),void i._maybeEnableCycle()):(i.prev(),void i._maybeEnableCycle())})),ue.on(window,Xe,(()=>{const t=ye.find('[data-bs-ride="carousel"]');for(const e of t)oi.getOrCreateInstance(e)})),Kt(oi);const ri=".bs.collapse",ai=`show${ri}`,li=`shown${ri}`,ci=`hide${ri}`,hi=`hidden${ri}`,di=`click${ri}.data-api`,ui="show",fi="collapse",pi="collapsing",mi=`:scope .${fi} .${fi}`,gi='[data-bs-toggle="collapse"]',_i={parent:null,toggle:!0},bi={parent:"(null|element)",toggle:"boolean"};class vi extends be{constructor(t,e){super(t,e),this._isTransitioning=!1,this._triggerArray=[];const i=ye.find(gi);for(const t of i){const e=ye.getSelectorFromElement(t),i=ye.find(e).filter((t=>t===this._element));null!==e&&i.length&&this._triggerArray.push(t)}this._initializeChildren(),this._config.parent||this._addAriaAndCollapsedClass(this._triggerArray,this._isShown()),this._config.toggle&&this.toggle()}static get Default(){return _i}static get DefaultType(){return bi}static get NAME(){return"collapse"}toggle(){this._isShown()?this.hide():this.show()}show(){if(this._isTransitioning||this._isShown())return;let t=[];if(this._config.parent&&(t=this._getFirstLevelChildren(".collapse.show, .collapse.collapsing").filter((t=>t!==this._element)).map((t=>vi.getOrCreateInstance(t,{toggle:!1})))),t.length&&t[0]._isTransitioning)return;if(ue.trigger(this._element,ai).defaultPrevented)return;for(const e of t)e.hide();const e=this._getDimension();this._element.classList.remove(fi),this._element.classList.add(pi),this._element.style[e]=0,this._addAriaAndCollapsedClass(this._triggerArray,!0),this._isTransitioning=!0;const i=`scroll${e[0].toUpperCase()+e.slice(1)}`;this._queueCallback((()=>{this._isTransitioning=!1,this._element.classList.remove(pi),this._element.classList.add(fi,ui),this._element.style[e]="",ue.trigger(this._element,li)}),this._element,!0),this._element.style[e]=`${this._element[i]}px`}hide(){if(this._isTransitioning||!this._isShown())return;if(ue.trigger(this._element,ci).defaultPrevented)return;const t=this._getDimension();this._element.style[t]=`${this._element.getBoundingClientRect()[t]}px`,Rt(this._element),this._element.classList.add(pi),this._element.classList.remove(fi,ui);for(const t of this._triggerArray){const e=ye.getElementFromSelector(t);e&&!this._isShown(e)&&this._addAriaAndCollapsedClass([t],!1)}this._isTransitioning=!0,this._element.style[t]="",this._queueCallback((()=>{this._isTransitioning=!1,this._element.classList.remove(pi),this._element.classList.add(fi),ue.trigger(this._element,hi)}),this._element,!0)}_isShown(t=this._element){return t.classList.contains(ui)}_configAfterMerge(t){return t.toggle=Boolean(t.toggle),t.parent=Ft(t.parent),t}_getDimension(){return this._element.classList.contains("collapse-horizontal")?"width":"height"}_initializeChildren(){if(!this._config.parent)return;const t=this._getFirstLevelChildren(gi);for(const e of t){const t=ye.getElementFromSelector(e);t&&this._addAriaAndCollapsedClass([e],this._isShown(t))}}_getFirstLevelChildren(t){const e=ye.find(mi,this._config.parent);return ye.find(t,this._config.parent).filter((t=>!e.includes(t)))}_addAriaAndCollapsedClass(t,e){if(t.length)for(const i of t)i.classList.toggle("collapsed",!e),i.setAttribute("aria-expanded",e)}static jQueryInterface(t){const e={};return"string"==typeof t&&/show|hide/.test(t)&&(e.toggle=!1),this.each((function(){const i=vi.getOrCreateInstance(this,e);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t]()}}))}}ue.on(document,di,gi,(function(t){("A"===t.target.tagName||t.delegateTarget&&"A"===t.delegateTarget.tagName)&&t.preventDefault();for(const t of ye.getMultipleElementsFromSelector(this))vi.getOrCreateInstance(t,{toggle:!1}).toggle()})),Kt(vi);const yi="dropdown",wi=".bs.dropdown",Ei=".data-api",Ai="ArrowUp",Ti="ArrowDown",Ci=`hide${wi}`,Oi=`hidden${wi}`,xi=`show${wi}`,ki=`shown${wi}`,Li=`click${wi}${Ei}`,Si=`keydown${wi}${Ei}`,Di=`keyup${wi}${Ei}`,$i="show",Ii='[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)',Ni=`${Ii}.${$i}`,Pi=".dropdown-menu",Mi=Yt()?"top-end":"top-start",ji=Yt()?"top-start":"top-end",Fi=Yt()?"bottom-end":"bottom-start",Hi=Yt()?"bottom-start":"bottom-end",Bi=Yt()?"left-start":"right-start",Wi=Yt()?"right-start":"left-start",zi={autoClose:!0,boundary:"clippingParents",display:"dynamic",offset:[0,2],popperConfig:null,reference:"toggle"},Ri={autoClose:"(boolean|string)",boundary:"(string|element)",display:"string",offset:"(array|string|function)",popperConfig:"(null|object|function)",reference:"(string|element|object)"};class qi extends be{constructor(t,e){super(t,e),this._popper=null,this._parent=this._element.parentNode,this._menu=ye.next(this._element,Pi)[0]||ye.prev(this._element,Pi)[0]||ye.findOne(Pi,this._parent),this._inNavbar=this._detectNavbar()}static get Default(){return zi}static get DefaultType(){return Ri}static get NAME(){return yi}toggle(){return this._isShown()?this.hide():this.show()}show(){if(Bt(this._element)||this._isShown())return;const t={relatedTarget:this._element};if(!ue.trigger(this._element,xi,t).defaultPrevented){if(this._createPopper(),"ontouchstart"in document.documentElement&&!this._parent.closest(".navbar-nav"))for(const t of[].concat(...document.body.children))ue.on(t,"mouseover",zt);this._element.focus(),this._element.setAttribute("aria-expanded",!0),this._menu.classList.add($i),this._element.classList.add($i),ue.trigger(this._element,ki,t)}}hide(){if(Bt(this._element)||!this._isShown())return;const t={relatedTarget:this._element};this._completeHide(t)}dispose(){this._popper&&this._popper.destroy(),super.dispose()}update(){this._inNavbar=this._detectNavbar(),this._popper&&this._popper.update()}_completeHide(t){if(!ue.trigger(this._element,Ci,t).defaultPrevented){if("ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))ue.off(t,"mouseover",zt);this._popper&&this._popper.destroy(),this._menu.classList.remove($i),this._element.classList.remove($i),this._element.setAttribute("aria-expanded","false"),ge.removeDataAttribute(this._menu,"popper"),ue.trigger(this._element,Oi,t)}}_getConfig(t){if("object"==typeof(t=super._getConfig(t)).reference&&!jt(t.reference)&&"function"!=typeof t.reference.getBoundingClientRect)throw new TypeError(`${yi.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);return t}_createPopper(){if(void 0===e)throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");let t=this._element;"parent"===this._config.reference?t=this._parent:jt(this._config.reference)?t=Ft(this._config.reference):"object"==typeof this._config.reference&&(t=this._config.reference);const i=this._getPopperConfig();this._popper=St(t,this._menu,i)}_isShown(){return this._menu.classList.contains($i)}_getPlacement(){const t=this._parent;if(t.classList.contains("dropend"))return Bi;if(t.classList.contains("dropstart"))return Wi;if(t.classList.contains("dropup-center"))return"top";if(t.classList.contains("dropdown-center"))return"bottom";const e="end"===getComputedStyle(this._menu).getPropertyValue("--bs-position").trim();return t.classList.contains("dropup")?e?ji:Mi:e?Hi:Fi}_detectNavbar(){return null!==this._element.closest(".navbar")}_getOffset(){const{offset:t}=this._config;return"string"==typeof t?t.split(",").map((t=>Number.parseInt(t,10))):"function"==typeof t?e=>t(e,this._element):t}_getPopperConfig(){const t={placement:this._getPlacement(),modifiers:[{name:"preventOverflow",options:{boundary:this._config.boundary}},{name:"offset",options:{offset:this._getOffset()}}]};return(this._inNavbar||"static"===this._config.display)&&(ge.setDataAttribute(this._menu,"popper","static"),t.modifiers=[{name:"applyStyles",enabled:!1}]),{...t,...Qt(this._config.popperConfig,[t])}}_selectMenuItem({key:t,target:e}){const i=ye.find(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)",this._menu).filter((t=>Ht(t)));i.length&&Ut(i,e,t===Ti,!i.includes(e)).focus()}static jQueryInterface(t){return this.each((function(){const e=qi.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}static clearMenus(t){if(2===t.button||"keyup"===t.type&&"Tab"!==t.key)return;const e=ye.find(Ni);for(const i of e){const e=qi.getInstance(i);if(!e||!1===e._config.autoClose)continue;const n=t.composedPath(),s=n.includes(e._menu);if(n.includes(e._element)||"inside"===e._config.autoClose&&!s||"outside"===e._config.autoClose&&s)continue;if(e._menu.contains(t.target)&&("keyup"===t.type&&"Tab"===t.key||/input|select|option|textarea|form/i.test(t.target.tagName)))continue;const o={relatedTarget:e._element};"click"===t.type&&(o.clickEvent=t),e._completeHide(o)}}static dataApiKeydownHandler(t){const e=/input|textarea/i.test(t.target.tagName),i="Escape"===t.key,n=[Ai,Ti].includes(t.key);if(!n&&!i)return;if(e&&!i)return;t.preventDefault();const s=this.matches(Ii)?this:ye.prev(this,Ii)[0]||ye.next(this,Ii)[0]||ye.findOne(Ii,t.delegateTarget.parentNode),o=qi.getOrCreateInstance(s);if(n)return t.stopPropagation(),o.show(),void o._selectMenuItem(t);o._isShown()&&(t.stopPropagation(),o.hide(),s.focus())}}ue.on(document,Si,Ii,qi.dataApiKeydownHandler),ue.on(document,Si,Pi,qi.dataApiKeydownHandler),ue.on(document,Li,qi.clearMenus),ue.on(document,Di,qi.clearMenus),ue.on(document,Li,Ii,(function(t){t.preventDefault(),qi.getOrCreateInstance(this).toggle()})),Kt(qi);const Vi="backdrop",Yi="show",Ki=`mousedown.bs.${Vi}`,Qi={className:"modal-backdrop",clickCallback:null,isAnimated:!1,isVisible:!0,rootElement:"body"},Xi={className:"string",clickCallback:"(function|null)",isAnimated:"boolean",isVisible:"boolean",rootElement:"(element|string)"};class Ui extends _e{constructor(t){super(),this._config=this._getConfig(t),this._isAppended=!1,this._element=null}static get Default(){return Qi}static get DefaultType(){return Xi}static get NAME(){return Vi}show(t){if(!this._config.isVisible)return void Qt(t);this._append();const e=this._getElement();this._config.isAnimated&&Rt(e),e.classList.add(Yi),this._emulateAnimation((()=>{Qt(t)}))}hide(t){this._config.isVisible?(this._getElement().classList.remove(Yi),this._emulateAnimation((()=>{this.dispose(),Qt(t)}))):Qt(t)}dispose(){this._isAppended&&(ue.off(this._element,Ki),this._element.remove(),this._isAppended=!1)}_getElement(){if(!this._element){const t=document.createElement("div");t.className=this._config.className,this._config.isAnimated&&t.classList.add("fade"),this._element=t}return this._element}_configAfterMerge(t){return t.rootElement=Ft(t.rootElement),t}_append(){if(this._isAppended)return;const t=this._getElement();this._config.rootElement.append(t),ue.on(t,Ki,(()=>{Qt(this._config.clickCallback)})),this._isAppended=!0}_emulateAnimation(t){Xt(t,this._getElement(),this._config.isAnimated)}}const Gi=".bs.focustrap",Ji=`focusin${Gi}`,Zi=`keydown.tab${Gi}`,tn="backward",en={autofocus:!0,trapElement:null},nn={autofocus:"boolean",trapElement:"element"};class sn extends _e{constructor(t){super(),this._config=this._getConfig(t),this._isActive=!1,this._lastTabNavDirection=null}static get Default(){return en}static get DefaultType(){return nn}static get NAME(){return"focustrap"}activate(){this._isActive||(this._config.autofocus&&this._config.trapElement.focus(),ue.off(document,Gi),ue.on(document,Ji,(t=>this._handleFocusin(t))),ue.on(document,Zi,(t=>this._handleKeydown(t))),this._isActive=!0)}deactivate(){this._isActive&&(this._isActive=!1,ue.off(document,Gi))}_handleFocusin(t){const{trapElement:e}=this._config;if(t.target===document||t.target===e||e.contains(t.target))return;const i=ye.focusableChildren(e);0===i.length?e.focus():this._lastTabNavDirection===tn?i[i.length-1].focus():i[0].focus()}_handleKeydown(t){"Tab"===t.key&&(this._lastTabNavDirection=t.shiftKey?tn:"forward")}}const on=".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",rn=".sticky-top",an="padding-right",ln="margin-right";class cn{constructor(){this._element=document.body}getWidth(){const t=document.documentElement.clientWidth;return Math.abs(window.innerWidth-t)}hide(){const t=this.getWidth();this._disableOverFlow(),this._setElementAttributes(this._element,an,(e=>e+t)),this._setElementAttributes(on,an,(e=>e+t)),this._setElementAttributes(rn,ln,(e=>e-t))}reset(){this._resetElementAttributes(this._element,"overflow"),this._resetElementAttributes(this._element,an),this._resetElementAttributes(on,an),this._resetElementAttributes(rn,ln)}isOverflowing(){return this.getWidth()>0}_disableOverFlow(){this._saveInitialAttribute(this._element,"overflow"),this._element.style.overflow="hidden"}_setElementAttributes(t,e,i){const n=this.getWidth();this._applyManipulationCallback(t,(t=>{if(t!==this._element&&window.innerWidth>t.clientWidth+n)return;this._saveInitialAttribute(t,e);const s=window.getComputedStyle(t).getPropertyValue(e);t.style.setProperty(e,`${i(Number.parseFloat(s))}px`)}))}_saveInitialAttribute(t,e){const i=t.style.getPropertyValue(e);i&&ge.setDataAttribute(t,e,i)}_resetElementAttributes(t,e){this._applyManipulationCallback(t,(t=>{const i=ge.getDataAttribute(t,e);null!==i?(ge.removeDataAttribute(t,e),t.style.setProperty(e,i)):t.style.removeProperty(e)}))}_applyManipulationCallback(t,e){if(jt(t))e(t);else for(const i of ye.find(t,this._element))e(i)}}const hn=".bs.modal",dn=`hide${hn}`,un=`hidePrevented${hn}`,fn=`hidden${hn}`,pn=`show${hn}`,mn=`shown${hn}`,gn=`resize${hn}`,_n=`click.dismiss${hn}`,bn=`mousedown.dismiss${hn}`,vn=`keydown.dismiss${hn}`,yn=`click${hn}.data-api`,wn="modal-open",En="show",An="modal-static",Tn={backdrop:!0,focus:!0,keyboard:!0},Cn={backdrop:"(boolean|string)",focus:"boolean",keyboard:"boolean"};class On extends be{constructor(t,e){super(t,e),this._dialog=ye.findOne(".modal-dialog",this._element),this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._isShown=!1,this._isTransitioning=!1,this._scrollBar=new cn,this._addEventListeners()}static get Default(){return Tn}static get DefaultType(){return Cn}static get NAME(){return"modal"}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||this._isTransitioning||ue.trigger(this._element,pn,{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._isTransitioning=!0,this._scrollBar.hide(),document.body.classList.add(wn),this._adjustDialog(),this._backdrop.show((()=>this._showElement(t))))}hide(){this._isShown&&!this._isTransitioning&&(ue.trigger(this._element,dn).defaultPrevented||(this._isShown=!1,this._isTransitioning=!0,this._focustrap.deactivate(),this._element.classList.remove(En),this._queueCallback((()=>this._hideModal()),this._element,this._isAnimated())))}dispose(){ue.off(window,hn),ue.off(this._dialog,hn),this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}handleUpdate(){this._adjustDialog()}_initializeBackDrop(){return new Ui({isVisible:Boolean(this._config.backdrop),isAnimated:this._isAnimated()})}_initializeFocusTrap(){return new sn({trapElement:this._element})}_showElement(t){document.body.contains(this._element)||document.body.append(this._element),this._element.style.display="block",this._element.removeAttribute("aria-hidden"),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.scrollTop=0;const e=ye.findOne(".modal-body",this._dialog);e&&(e.scrollTop=0),Rt(this._element),this._element.classList.add(En),this._queueCallback((()=>{this._config.focus&&this._focustrap.activate(),this._isTransitioning=!1,ue.trigger(this._element,mn,{relatedTarget:t})}),this._dialog,this._isAnimated())}_addEventListeners(){ue.on(this._element,vn,(t=>{"Escape"===t.key&&(this._config.keyboard?this.hide():this._triggerBackdropTransition())})),ue.on(window,gn,(()=>{this._isShown&&!this._isTransitioning&&this._adjustDialog()})),ue.on(this._element,bn,(t=>{ue.one(this._element,_n,(e=>{this._element===t.target&&this._element===e.target&&("static"!==this._config.backdrop?this._config.backdrop&&this.hide():this._triggerBackdropTransition())}))}))}_hideModal(){this._element.style.display="none",this._element.setAttribute("aria-hidden",!0),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._isTransitioning=!1,this._backdrop.hide((()=>{document.body.classList.remove(wn),this._resetAdjustments(),this._scrollBar.reset(),ue.trigger(this._element,fn)}))}_isAnimated(){return this._element.classList.contains("fade")}_triggerBackdropTransition(){if(ue.trigger(this._element,un).defaultPrevented)return;const t=this._element.scrollHeight>document.documentElement.clientHeight,e=this._element.style.overflowY;"hidden"===e||this._element.classList.contains(An)||(t||(this._element.style.overflowY="hidden"),this._element.classList.add(An),this._queueCallback((()=>{this._element.classList.remove(An),this._queueCallback((()=>{this._element.style.overflowY=e}),this._dialog)}),this._dialog),this._element.focus())}_adjustDialog(){const t=this._element.scrollHeight>document.documentElement.clientHeight,e=this._scrollBar.getWidth(),i=e>0;if(i&&!t){const t=Yt()?"paddingLeft":"paddingRight";this._element.style[t]=`${e}px`}if(!i&&t){const t=Yt()?"paddingRight":"paddingLeft";this._element.style[t]=`${e}px`}}_resetAdjustments(){this._element.style.paddingLeft="",this._element.style.paddingRight=""}static jQueryInterface(t,e){return this.each((function(){const i=On.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t](e)}}))}}ue.on(document,yn,'[data-bs-toggle="modal"]',(function(t){const e=ye.getElementFromSelector(this);["A","AREA"].includes(this.tagName)&&t.preventDefault(),ue.one(e,pn,(t=>{t.defaultPrevented||ue.one(e,fn,(()=>{Ht(this)&&this.focus()}))}));const i=ye.findOne(".modal.show");i&&On.getInstance(i).hide(),On.getOrCreateInstance(e).toggle(this)})),we(On),Kt(On);const xn=".bs.offcanvas",kn=".data-api",Ln=`load${xn}${kn}`,Sn="show",Dn="showing",$n="hiding",In=".offcanvas.show",Nn=`show${xn}`,Pn=`shown${xn}`,Mn=`hide${xn}`,jn=`hidePrevented${xn}`,Fn=`hidden${xn}`,Hn=`resize${xn}`,Bn=`click${xn}${kn}`,Wn=`keydown.dismiss${xn}`,zn={backdrop:!0,keyboard:!0,scroll:!1},Rn={backdrop:"(boolean|string)",keyboard:"boolean",scroll:"boolean"};class qn extends be{constructor(t,e){super(t,e),this._isShown=!1,this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._addEventListeners()}static get Default(){return zn}static get DefaultType(){return Rn}static get NAME(){return"offcanvas"}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||ue.trigger(this._element,Nn,{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._backdrop.show(),this._config.scroll||(new cn).hide(),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.classList.add(Dn),this._queueCallback((()=>{this._config.scroll&&!this._config.backdrop||this._focustrap.activate(),this._element.classList.add(Sn),this._element.classList.remove(Dn),ue.trigger(this._element,Pn,{relatedTarget:t})}),this._element,!0))}hide(){this._isShown&&(ue.trigger(this._element,Mn).defaultPrevented||(this._focustrap.deactivate(),this._element.blur(),this._isShown=!1,this._element.classList.add($n),this._backdrop.hide(),this._queueCallback((()=>{this._element.classList.remove(Sn,$n),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._config.scroll||(new cn).reset(),ue.trigger(this._element,Fn)}),this._element,!0)))}dispose(){this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}_initializeBackDrop(){const t=Boolean(this._config.backdrop);return new Ui({className:"offcanvas-backdrop",isVisible:t,isAnimated:!0,rootElement:this._element.parentNode,clickCallback:t?()=>{"static"!==this._config.backdrop?this.hide():ue.trigger(this._element,jn)}:null})}_initializeFocusTrap(){return new sn({trapElement:this._element})}_addEventListeners(){ue.on(this._element,Wn,(t=>{"Escape"===t.key&&(this._config.keyboard?this.hide():ue.trigger(this._element,jn))}))}static jQueryInterface(t){return this.each((function(){const e=qn.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}ue.on(document,Bn,'[data-bs-toggle="offcanvas"]',(function(t){const e=ye.getElementFromSelector(this);if(["A","AREA"].includes(this.tagName)&&t.preventDefault(),Bt(this))return;ue.one(e,Fn,(()=>{Ht(this)&&this.focus()}));const i=ye.findOne(In);i&&i!==e&&qn.getInstance(i).hide(),qn.getOrCreateInstance(e).toggle(this)})),ue.on(window,Ln,(()=>{for(const t of ye.find(In))qn.getOrCreateInstance(t).show()})),ue.on(window,Hn,(()=>{for(const t of ye.find("[aria-modal][class*=show][class*=offcanvas-]"))"fixed"!==getComputedStyle(t).position&&qn.getOrCreateInstance(t).hide()})),we(qn),Kt(qn);const Vn={"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","srcset","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},Yn=new Set(["background","cite","href","itemtype","longdesc","poster","src","xlink:href"]),Kn=/^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i,Qn=(t,e)=>{const i=t.nodeName.toLowerCase();return e.includes(i)?!Yn.has(i)||Boolean(Kn.test(t.nodeValue)):e.filter((t=>t instanceof RegExp)).some((t=>t.test(i)))},Xn={allowList:Vn,content:{},extraClass:"",html:!1,sanitize:!0,sanitizeFn:null,template:"
"},Un={allowList:"object",content:"object",extraClass:"(string|function)",html:"boolean",sanitize:"boolean",sanitizeFn:"(null|function)",template:"string"},Gn={entry:"(string|element|function|null)",selector:"(string|element)"};class Jn extends _e{constructor(t){super(),this._config=this._getConfig(t)}static get Default(){return Xn}static get DefaultType(){return Un}static get NAME(){return"TemplateFactory"}getContent(){return Object.values(this._config.content).map((t=>this._resolvePossibleFunction(t))).filter(Boolean)}hasContent(){return this.getContent().length>0}changeContent(t){return this._checkContent(t),this._config.content={...this._config.content,...t},this}toHtml(){const t=document.createElement("div");t.innerHTML=this._maybeSanitize(this._config.template);for(const[e,i]of Object.entries(this._config.content))this._setContent(t,i,e);const e=t.children[0],i=this._resolvePossibleFunction(this._config.extraClass);return i&&e.classList.add(...i.split(" ")),e}_typeCheckConfig(t){super._typeCheckConfig(t),this._checkContent(t.content)}_checkContent(t){for(const[e,i]of Object.entries(t))super._typeCheckConfig({selector:e,entry:i},Gn)}_setContent(t,e,i){const n=ye.findOne(i,t);n&&((e=this._resolvePossibleFunction(e))?jt(e)?this._putElementInTemplate(Ft(e),n):this._config.html?n.innerHTML=this._maybeSanitize(e):n.textContent=e:n.remove())}_maybeSanitize(t){return this._config.sanitize?function(t,e,i){if(!t.length)return t;if(i&&"function"==typeof i)return i(t);const n=(new window.DOMParser).parseFromString(t,"text/html"),s=[].concat(...n.body.querySelectorAll("*"));for(const t of s){const i=t.nodeName.toLowerCase();if(!Object.keys(e).includes(i)){t.remove();continue}const n=[].concat(...t.attributes),s=[].concat(e["*"]||[],e[i]||[]);for(const e of n)Qn(e,s)||t.removeAttribute(e.nodeName)}return n.body.innerHTML}(t,this._config.allowList,this._config.sanitizeFn):t}_resolvePossibleFunction(t){return Qt(t,[this])}_putElementInTemplate(t,e){if(this._config.html)return e.innerHTML="",void e.append(t);e.textContent=t.textContent}}const Zn=new Set(["sanitize","allowList","sanitizeFn"]),ts="fade",es="show",is=".modal",ns="hide.bs.modal",ss="hover",os="focus",rs={AUTO:"auto",TOP:"top",RIGHT:Yt()?"left":"right",BOTTOM:"bottom",LEFT:Yt()?"right":"left"},as={allowList:Vn,animation:!0,boundary:"clippingParents",container:!1,customClass:"",delay:0,fallbackPlacements:["top","right","bottom","left"],html:!1,offset:[0,6],placement:"top",popperConfig:null,sanitize:!0,sanitizeFn:null,selector:!1,template:'',title:"",trigger:"hover focus"},ls={allowList:"object",animation:"boolean",boundary:"(string|element)",container:"(string|element|boolean)",customClass:"(string|function)",delay:"(number|object)",fallbackPlacements:"array",html:"boolean",offset:"(array|string|function)",placement:"(string|function)",popperConfig:"(null|object|function)",sanitize:"boolean",sanitizeFn:"(null|function)",selector:"(string|boolean)",template:"string",title:"(string|element|function)",trigger:"string"};class cs extends be{constructor(t,i){if(void 0===e)throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");super(t,i),this._isEnabled=!0,this._timeout=0,this._isHovered=null,this._activeTrigger={},this._popper=null,this._templateFactory=null,this._newContent=null,this.tip=null,this._setListeners(),this._config.selector||this._fixTitle()}static get Default(){return as}static get DefaultType(){return ls}static get NAME(){return"tooltip"}enable(){this._isEnabled=!0}disable(){this._isEnabled=!1}toggleEnabled(){this._isEnabled=!this._isEnabled}toggle(){this._isEnabled&&(this._activeTrigger.click=!this._activeTrigger.click,this._isShown()?this._leave():this._enter())}dispose(){clearTimeout(this._timeout),ue.off(this._element.closest(is),ns,this._hideModalHandler),this._element.getAttribute("data-bs-original-title")&&this._element.setAttribute("title",this._element.getAttribute("data-bs-original-title")),this._disposePopper(),super.dispose()}show(){if("none"===this._element.style.display)throw new Error("Please use show on visible elements");if(!this._isWithContent()||!this._isEnabled)return;const t=ue.trigger(this._element,this.constructor.eventName("show")),e=(Wt(this._element)||this._element.ownerDocument.documentElement).contains(this._element);if(t.defaultPrevented||!e)return;this._disposePopper();const i=this._getTipElement();this._element.setAttribute("aria-describedby",i.getAttribute("id"));const{container:n}=this._config;if(this._element.ownerDocument.documentElement.contains(this.tip)||(n.append(i),ue.trigger(this._element,this.constructor.eventName("inserted"))),this._popper=this._createPopper(i),i.classList.add(es),"ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))ue.on(t,"mouseover",zt);this._queueCallback((()=>{ue.trigger(this._element,this.constructor.eventName("shown")),!1===this._isHovered&&this._leave(),this._isHovered=!1}),this.tip,this._isAnimated())}hide(){if(this._isShown()&&!ue.trigger(this._element,this.constructor.eventName("hide")).defaultPrevented){if(this._getTipElement().classList.remove(es),"ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))ue.off(t,"mouseover",zt);this._activeTrigger.click=!1,this._activeTrigger[os]=!1,this._activeTrigger[ss]=!1,this._isHovered=null,this._queueCallback((()=>{this._isWithActiveTrigger()||(this._isHovered||this._disposePopper(),this._element.removeAttribute("aria-describedby"),ue.trigger(this._element,this.constructor.eventName("hidden")))}),this.tip,this._isAnimated())}}update(){this._popper&&this._popper.update()}_isWithContent(){return Boolean(this._getTitle())}_getTipElement(){return this.tip||(this.tip=this._createTipElement(this._newContent||this._getContentForTemplate())),this.tip}_createTipElement(t){const e=this._getTemplateFactory(t).toHtml();if(!e)return null;e.classList.remove(ts,es),e.classList.add(`bs-${this.constructor.NAME}-auto`);const i=(t=>{do{t+=Math.floor(1e6*Math.random())}while(document.getElementById(t));return t})(this.constructor.NAME).toString();return e.setAttribute("id",i),this._isAnimated()&&e.classList.add(ts),e}setContent(t){this._newContent=t,this._isShown()&&(this._disposePopper(),this.show())}_getTemplateFactory(t){return this._templateFactory?this._templateFactory.changeContent(t):this._templateFactory=new Jn({...this._config,content:t,extraClass:this._resolvePossibleFunction(this._config.customClass)}),this._templateFactory}_getContentForTemplate(){return{".tooltip-inner":this._getTitle()}}_getTitle(){return this._resolvePossibleFunction(this._config.title)||this._element.getAttribute("data-bs-original-title")}_initializeOnDelegatedTarget(t){return this.constructor.getOrCreateInstance(t.delegateTarget,this._getDelegateConfig())}_isAnimated(){return this._config.animation||this.tip&&this.tip.classList.contains(ts)}_isShown(){return this.tip&&this.tip.classList.contains(es)}_createPopper(t){const e=Qt(this._config.placement,[this,t,this._element]),i=rs[e.toUpperCase()];return St(this._element,t,this._getPopperConfig(i))}_getOffset(){const{offset:t}=this._config;return"string"==typeof t?t.split(",").map((t=>Number.parseInt(t,10))):"function"==typeof t?e=>t(e,this._element):t}_resolvePossibleFunction(t){return Qt(t,[this._element])}_getPopperConfig(t){const e={placement:t,modifiers:[{name:"flip",options:{fallbackPlacements:this._config.fallbackPlacements}},{name:"offset",options:{offset:this._getOffset()}},{name:"preventOverflow",options:{boundary:this._config.boundary}},{name:"arrow",options:{element:`.${this.constructor.NAME}-arrow`}},{name:"preSetPlacement",enabled:!0,phase:"beforeMain",fn:t=>{this._getTipElement().setAttribute("data-popper-placement",t.state.placement)}}]};return{...e,...Qt(this._config.popperConfig,[e])}}_setListeners(){const t=this._config.trigger.split(" ");for(const e of t)if("click"===e)ue.on(this._element,this.constructor.eventName("click"),this._config.selector,(t=>{this._initializeOnDelegatedTarget(t).toggle()}));else if("manual"!==e){const t=e===ss?this.constructor.eventName("mouseenter"):this.constructor.eventName("focusin"),i=e===ss?this.constructor.eventName("mouseleave"):this.constructor.eventName("focusout");ue.on(this._element,t,this._config.selector,(t=>{const e=this._initializeOnDelegatedTarget(t);e._activeTrigger["focusin"===t.type?os:ss]=!0,e._enter()})),ue.on(this._element,i,this._config.selector,(t=>{const e=this._initializeOnDelegatedTarget(t);e._activeTrigger["focusout"===t.type?os:ss]=e._element.contains(t.relatedTarget),e._leave()}))}this._hideModalHandler=()=>{this._element&&this.hide()},ue.on(this._element.closest(is),ns,this._hideModalHandler)}_fixTitle(){const t=this._element.getAttribute("title");t&&(this._element.getAttribute("aria-label")||this._element.textContent.trim()||this._element.setAttribute("aria-label",t),this._element.setAttribute("data-bs-original-title",t),this._element.removeAttribute("title"))}_enter(){this._isShown()||this._isHovered?this._isHovered=!0:(this._isHovered=!0,this._setTimeout((()=>{this._isHovered&&this.show()}),this._config.delay.show))}_leave(){this._isWithActiveTrigger()||(this._isHovered=!1,this._setTimeout((()=>{this._isHovered||this.hide()}),this._config.delay.hide))}_setTimeout(t,e){clearTimeout(this._timeout),this._timeout=setTimeout(t,e)}_isWithActiveTrigger(){return Object.values(this._activeTrigger).includes(!0)}_getConfig(t){const e=ge.getDataAttributes(this._element);for(const t of Object.keys(e))Zn.has(t)&&delete e[t];return t={...e,..."object"==typeof t&&t?t:{}},t=this._mergeConfigObj(t),t=this._configAfterMerge(t),this._typeCheckConfig(t),t}_configAfterMerge(t){return t.container=!1===t.container?document.body:Ft(t.container),"number"==typeof t.delay&&(t.delay={show:t.delay,hide:t.delay}),"number"==typeof t.title&&(t.title=t.title.toString()),"number"==typeof t.content&&(t.content=t.content.toString()),t}_getDelegateConfig(){const t={};for(const[e,i]of Object.entries(this._config))this.constructor.Default[e]!==i&&(t[e]=i);return t.selector=!1,t.trigger="manual",t}_disposePopper(){this._popper&&(this._popper.destroy(),this._popper=null),this.tip&&(this.tip.remove(),this.tip=null)}static jQueryInterface(t){return this.each((function(){const e=cs.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}Kt(cs);const hs={...cs.Default,content:"",offset:[0,8],placement:"right",template:'',trigger:"click"},ds={...cs.DefaultType,content:"(null|string|element|function)"};class us extends cs{static get Default(){return hs}static get DefaultType(){return ds}static get NAME(){return"popover"}_isWithContent(){return this._getTitle()||this._getContent()}_getContentForTemplate(){return{".popover-header":this._getTitle(),".popover-body":this._getContent()}}_getContent(){return this._resolvePossibleFunction(this._config.content)}static jQueryInterface(t){return this.each((function(){const e=us.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}Kt(us);const fs=".bs.scrollspy",ps=`activate${fs}`,ms=`click${fs}`,gs=`load${fs}.data-api`,_s="active",bs="[href]",vs=".nav-link",ys=`${vs}, .nav-item > ${vs}, .list-group-item`,ws={offset:null,rootMargin:"0px 0px -25%",smoothScroll:!1,target:null,threshold:[.1,.5,1]},Es={offset:"(number|null)",rootMargin:"string",smoothScroll:"boolean",target:"element",threshold:"array"};class As extends be{constructor(t,e){super(t,e),this._targetLinks=new Map,this._observableSections=new Map,this._rootElement="visible"===getComputedStyle(this._element).overflowY?null:this._element,this._activeTarget=null,this._observer=null,this._previousScrollData={visibleEntryTop:0,parentScrollTop:0},this.refresh()}static get Default(){return ws}static get DefaultType(){return Es}static get NAME(){return"scrollspy"}refresh(){this._initializeTargetsAndObservables(),this._maybeEnableSmoothScroll(),this._observer?this._observer.disconnect():this._observer=this._getNewObserver();for(const t of this._observableSections.values())this._observer.observe(t)}dispose(){this._observer.disconnect(),super.dispose()}_configAfterMerge(t){return t.target=Ft(t.target)||document.body,t.rootMargin=t.offset?`${t.offset}px 0px -30%`:t.rootMargin,"string"==typeof t.threshold&&(t.threshold=t.threshold.split(",").map((t=>Number.parseFloat(t)))),t}_maybeEnableSmoothScroll(){this._config.smoothScroll&&(ue.off(this._config.target,ms),ue.on(this._config.target,ms,bs,(t=>{const e=this._observableSections.get(t.target.hash);if(e){t.preventDefault();const i=this._rootElement||window,n=e.offsetTop-this._element.offsetTop;if(i.scrollTo)return void i.scrollTo({top:n,behavior:"smooth"});i.scrollTop=n}})))}_getNewObserver(){const t={root:this._rootElement,threshold:this._config.threshold,rootMargin:this._config.rootMargin};return new IntersectionObserver((t=>this._observerCallback(t)),t)}_observerCallback(t){const e=t=>this._targetLinks.get(`#${t.target.id}`),i=t=>{this._previousScrollData.visibleEntryTop=t.target.offsetTop,this._process(e(t))},n=(this._rootElement||document.documentElement).scrollTop,s=n>=this._previousScrollData.parentScrollTop;this._previousScrollData.parentScrollTop=n;for(const o of t){if(!o.isIntersecting){this._activeTarget=null,this._clearActiveClass(e(o));continue}const t=o.target.offsetTop>=this._previousScrollData.visibleEntryTop;if(s&&t){if(i(o),!n)return}else s||t||i(o)}}_initializeTargetsAndObservables(){this._targetLinks=new Map,this._observableSections=new Map;const t=ye.find(bs,this._config.target);for(const e of t){if(!e.hash||Bt(e))continue;const t=ye.findOne(decodeURI(e.hash),this._element);Ht(t)&&(this._targetLinks.set(decodeURI(e.hash),e),this._observableSections.set(e.hash,t))}}_process(t){this._activeTarget!==t&&(this._clearActiveClass(this._config.target),this._activeTarget=t,t.classList.add(_s),this._activateParents(t),ue.trigger(this._element,ps,{relatedTarget:t}))}_activateParents(t){if(t.classList.contains("dropdown-item"))ye.findOne(".dropdown-toggle",t.closest(".dropdown")).classList.add(_s);else for(const e of ye.parents(t,".nav, .list-group"))for(const t of ye.prev(e,ys))t.classList.add(_s)}_clearActiveClass(t){t.classList.remove(_s);const e=ye.find(`${bs}.${_s}`,t);for(const t of e)t.classList.remove(_s)}static jQueryInterface(t){return this.each((function(){const e=As.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t]()}}))}}ue.on(window,gs,(()=>{for(const t of ye.find('[data-bs-spy="scroll"]'))As.getOrCreateInstance(t)})),Kt(As);const Ts=".bs.tab",Cs=`hide${Ts}`,Os=`hidden${Ts}`,xs=`show${Ts}`,ks=`shown${Ts}`,Ls=`click${Ts}`,Ss=`keydown${Ts}`,Ds=`load${Ts}`,$s="ArrowLeft",Is="ArrowRight",Ns="ArrowUp",Ps="ArrowDown",Ms="Home",js="End",Fs="active",Hs="fade",Bs="show",Ws=".dropdown-toggle",zs=`:not(${Ws})`,Rs='[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]',qs=`.nav-link${zs}, .list-group-item${zs}, [role="tab"]${zs}, ${Rs}`,Vs=`.${Fs}[data-bs-toggle="tab"], .${Fs}[data-bs-toggle="pill"], .${Fs}[data-bs-toggle="list"]`;class Ys extends be{constructor(t){super(t),this._parent=this._element.closest('.list-group, .nav, [role="tablist"]'),this._parent&&(this._setInitialAttributes(this._parent,this._getChildren()),ue.on(this._element,Ss,(t=>this._keydown(t))))}static get NAME(){return"tab"}show(){const t=this._element;if(this._elemIsActive(t))return;const e=this._getActiveElem(),i=e?ue.trigger(e,Cs,{relatedTarget:t}):null;ue.trigger(t,xs,{relatedTarget:e}).defaultPrevented||i&&i.defaultPrevented||(this._deactivate(e,t),this._activate(t,e))}_activate(t,e){t&&(t.classList.add(Fs),this._activate(ye.getElementFromSelector(t)),this._queueCallback((()=>{"tab"===t.getAttribute("role")?(t.removeAttribute("tabindex"),t.setAttribute("aria-selected",!0),this._toggleDropDown(t,!0),ue.trigger(t,ks,{relatedTarget:e})):t.classList.add(Bs)}),t,t.classList.contains(Hs)))}_deactivate(t,e){t&&(t.classList.remove(Fs),t.blur(),this._deactivate(ye.getElementFromSelector(t)),this._queueCallback((()=>{"tab"===t.getAttribute("role")?(t.setAttribute("aria-selected",!1),t.setAttribute("tabindex","-1"),this._toggleDropDown(t,!1),ue.trigger(t,Os,{relatedTarget:e})):t.classList.remove(Bs)}),t,t.classList.contains(Hs)))}_keydown(t){if(![$s,Is,Ns,Ps,Ms,js].includes(t.key))return;t.stopPropagation(),t.preventDefault();const e=this._getChildren().filter((t=>!Bt(t)));let i;if([Ms,js].includes(t.key))i=e[t.key===Ms?0:e.length-1];else{const n=[Is,Ps].includes(t.key);i=Ut(e,t.target,n,!0)}i&&(i.focus({preventScroll:!0}),Ys.getOrCreateInstance(i).show())}_getChildren(){return ye.find(qs,this._parent)}_getActiveElem(){return this._getChildren().find((t=>this._elemIsActive(t)))||null}_setInitialAttributes(t,e){this._setAttributeIfNotExists(t,"role","tablist");for(const t of e)this._setInitialAttributesOnChild(t)}_setInitialAttributesOnChild(t){t=this._getInnerElement(t);const e=this._elemIsActive(t),i=this._getOuterElement(t);t.setAttribute("aria-selected",e),i!==t&&this._setAttributeIfNotExists(i,"role","presentation"),e||t.setAttribute("tabindex","-1"),this._setAttributeIfNotExists(t,"role","tab"),this._setInitialAttributesOnTargetPanel(t)}_setInitialAttributesOnTargetPanel(t){const e=ye.getElementFromSelector(t);e&&(this._setAttributeIfNotExists(e,"role","tabpanel"),t.id&&this._setAttributeIfNotExists(e,"aria-labelledby",`${t.id}`))}_toggleDropDown(t,e){const i=this._getOuterElement(t);if(!i.classList.contains("dropdown"))return;const n=(t,n)=>{const s=ye.findOne(t,i);s&&s.classList.toggle(n,e)};n(Ws,Fs),n(".dropdown-menu",Bs),i.setAttribute("aria-expanded",e)}_setAttributeIfNotExists(t,e,i){t.hasAttribute(e)||t.setAttribute(e,i)}_elemIsActive(t){return t.classList.contains(Fs)}_getInnerElement(t){return t.matches(qs)?t:ye.findOne(qs,t)}_getOuterElement(t){return t.closest(".nav-item, .list-group-item")||t}static jQueryInterface(t){return this.each((function(){const e=Ys.getOrCreateInstance(this);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t]()}}))}}ue.on(document,Ls,Rs,(function(t){["A","AREA"].includes(this.tagName)&&t.preventDefault(),Bt(this)||Ys.getOrCreateInstance(this).show()})),ue.on(window,Ds,(()=>{for(const t of ye.find(Vs))Ys.getOrCreateInstance(t)})),Kt(Ys);const Ks=".bs.toast",Qs=`mouseover${Ks}`,Xs=`mouseout${Ks}`,Us=`focusin${Ks}`,Gs=`focusout${Ks}`,Js=`hide${Ks}`,Zs=`hidden${Ks}`,to=`show${Ks}`,eo=`shown${Ks}`,io="hide",no="show",so="showing",oo={animation:"boolean",autohide:"boolean",delay:"number"},ro={animation:!0,autohide:!0,delay:5e3};class ao extends be{constructor(t,e){super(t,e),this._timeout=null,this._hasMouseInteraction=!1,this._hasKeyboardInteraction=!1,this._setListeners()}static get Default(){return ro}static get DefaultType(){return oo}static get NAME(){return"toast"}show(){ue.trigger(this._element,to).defaultPrevented||(this._clearTimeout(),this._config.animation&&this._element.classList.add("fade"),this._element.classList.remove(io),Rt(this._element),this._element.classList.add(no,so),this._queueCallback((()=>{this._element.classList.remove(so),ue.trigger(this._element,eo),this._maybeScheduleHide()}),this._element,this._config.animation))}hide(){this.isShown()&&(ue.trigger(this._element,Js).defaultPrevented||(this._element.classList.add(so),this._queueCallback((()=>{this._element.classList.add(io),this._element.classList.remove(so,no),ue.trigger(this._element,Zs)}),this._element,this._config.animation)))}dispose(){this._clearTimeout(),this.isShown()&&this._element.classList.remove(no),super.dispose()}isShown(){return this._element.classList.contains(no)}_maybeScheduleHide(){this._config.autohide&&(this._hasMouseInteraction||this._hasKeyboardInteraction||(this._timeout=setTimeout((()=>{this.hide()}),this._config.delay)))}_onInteraction(t,e){switch(t.type){case"mouseover":case"mouseout":this._hasMouseInteraction=e;break;case"focusin":case"focusout":this._hasKeyboardInteraction=e}if(e)return void this._clearTimeout();const i=t.relatedTarget;this._element===i||this._element.contains(i)||this._maybeScheduleHide()}_setListeners(){ue.on(this._element,Qs,(t=>this._onInteraction(t,!0))),ue.on(this._element,Xs,(t=>this._onInteraction(t,!1))),ue.on(this._element,Us,(t=>this._onInteraction(t,!0))),ue.on(this._element,Gs,(t=>this._onInteraction(t,!1)))}_clearTimeout(){clearTimeout(this._timeout),this._timeout=null}static jQueryInterface(t){return this.each((function(){const e=ao.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}function lo(t){"loading"!=document.readyState?t():document.addEventListener("DOMContentLoaded",t)}we(ao),Kt(ao),lo((function(){[].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]')).map((function(t){return new cs(t,{delay:{show:500,hide:100}})}))})),lo((function(){document.getElementById("pst-back-to-top").addEventListener("click",(function(){document.body.scrollTop=0,document.documentElement.scrollTop=0}))})),lo((function(){var t=document.getElementById("pst-back-to-top"),e=document.getElementsByClassName("bd-header")[0].getBoundingClientRect();window.addEventListener("scroll",(function(){this.oldScroll>this.scrollY&&this.scrollY>e.bottom?t.style.display="block":t.style.display="none",this.oldScroll=this.scrollY}))}))})(); +//# sourceMappingURL=bootstrap.js.map \ No newline at end of file diff --git a/_static/scripts/bootstrap.js.LICENSE.txt b/_static/scripts/bootstrap.js.LICENSE.txt new file mode 100644 index 000000000..10f979d07 --- /dev/null +++ b/_static/scripts/bootstrap.js.LICENSE.txt @@ -0,0 +1,5 @@ +/*! + * Bootstrap v5.3.2 (https://getbootstrap.com/) + * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) + * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) + */ diff --git a/_static/scripts/bootstrap.js.map b/_static/scripts/bootstrap.js.map new file mode 100644 index 000000000..e5bc15752 --- /dev/null +++ b/_static/scripts/bootstrap.js.map @@ -0,0 +1 @@ +{"version":3,"file":"scripts/bootstrap.js","mappings":";mBACA,IAAIA,EAAsB,CCA1BA,EAAwB,CAACC,EAASC,KACjC,IAAI,IAAIC,KAAOD,EACXF,EAAoBI,EAAEF,EAAYC,KAASH,EAAoBI,EAAEH,EAASE,IAC5EE,OAAOC,eAAeL,EAASE,EAAK,CAAEI,YAAY,EAAMC,IAAKN,EAAWC,IAE1E,ECNDH,EAAwB,CAACS,EAAKC,IAAUL,OAAOM,UAAUC,eAAeC,KAAKJ,EAAKC,GCClFV,EAAyBC,IACH,oBAAXa,QAA0BA,OAAOC,aAC1CV,OAAOC,eAAeL,EAASa,OAAOC,YAAa,CAAEC,MAAO,WAE7DX,OAAOC,eAAeL,EAAS,aAAc,CAAEe,OAAO,GAAO,ipBCLvD,IAAI,EAAM,MACNC,EAAS,SACTC,EAAQ,QACRC,EAAO,OACPC,EAAO,OACPC,EAAiB,CAAC,EAAKJ,EAAQC,EAAOC,GACtCG,EAAQ,QACRC,EAAM,MACNC,EAAkB,kBAClBC,EAAW,WACXC,EAAS,SACTC,EAAY,YACZC,EAAmCP,EAAeQ,QAAO,SAAUC,EAAKC,GACjF,OAAOD,EAAIE,OAAO,CAACD,EAAY,IAAMT,EAAOS,EAAY,IAAMR,GAChE,GAAG,IACQ,EAA0B,GAAGS,OAAOX,EAAgB,CAACD,IAAOS,QAAO,SAAUC,EAAKC,GAC3F,OAAOD,EAAIE,OAAO,CAACD,EAAWA,EAAY,IAAMT,EAAOS,EAAY,IAAMR,GAC3E,GAAG,IAEQU,EAAa,aACbC,EAAO,OACPC,EAAY,YAEZC,EAAa,aACbC,EAAO,OACPC,EAAY,YAEZC,EAAc,cACdC,EAAQ,QACRC,EAAa,aACbC,EAAiB,CAACT,EAAYC,EAAMC,EAAWC,EAAYC,EAAMC,EAAWC,EAAaC,EAAOC,GC9B5F,SAASE,EAAYC,GAClC,OAAOA,GAAWA,EAAQC,UAAY,IAAIC,cAAgB,IAC5D,CCFe,SAASC,EAAUC,GAChC,GAAY,MAARA,EACF,OAAOC,OAGT,GAAwB,oBAApBD,EAAKE,WAAkC,CACzC,IAAIC,EAAgBH,EAAKG,cACzB,OAAOA,GAAgBA,EAAcC,aAAwBH,MAC/D,CAEA,OAAOD,CACT,CCTA,SAASK,EAAUL,GAEjB,OAAOA,aADUD,EAAUC,GAAMM,SACIN,aAAgBM,OACvD,CAEA,SAASC,EAAcP,GAErB,OAAOA,aADUD,EAAUC,GAAMQ,aACIR,aAAgBQ,WACvD,CAEA,SAASC,EAAaT,GAEpB,MAA0B,oBAAfU,aAKJV,aADUD,EAAUC,GAAMU,YACIV,aAAgBU,WACvD,CCwDA,SACEC,KAAM,cACNC,SAAS,EACTC,MAAO,QACPC,GA5EF,SAAqBC,GACnB,IAAIC,EAAQD,EAAKC,MACjB3D,OAAO4D,KAAKD,EAAME,UAAUC,SAAQ,SAAUR,GAC5C,IAAIS,EAAQJ,EAAMK,OAAOV,IAAS,CAAC,EAC/BW,EAAaN,EAAMM,WAAWX,IAAS,CAAC,EACxCf,EAAUoB,EAAME,SAASP,GAExBJ,EAAcX,IAAaD,EAAYC,KAO5CvC,OAAOkE,OAAO3B,EAAQwB,MAAOA,GAC7B/D,OAAO4D,KAAKK,GAAYH,SAAQ,SAAUR,GACxC,IAAI3C,EAAQsD,EAAWX,IAET,IAAV3C,EACF4B,EAAQ4B,gBAAgBb,GAExBf,EAAQ6B,aAAad,GAAgB,IAAV3C,EAAiB,GAAKA,EAErD,IACF,GACF,EAoDE0D,OAlDF,SAAgBC,GACd,IAAIX,EAAQW,EAAMX,MACdY,EAAgB,CAClBlD,OAAQ,CACNmD,SAAUb,EAAMc,QAAQC,SACxB5D,KAAM,IACN6D,IAAK,IACLC,OAAQ,KAEVC,MAAO,CACLL,SAAU,YAEZlD,UAAW,CAAC,GASd,OAPAtB,OAAOkE,OAAOP,EAAME,SAASxC,OAAO0C,MAAOQ,EAAclD,QACzDsC,EAAMK,OAASO,EAEXZ,EAAME,SAASgB,OACjB7E,OAAOkE,OAAOP,EAAME,SAASgB,MAAMd,MAAOQ,EAAcM,OAGnD,WACL7E,OAAO4D,KAAKD,EAAME,UAAUC,SAAQ,SAAUR,GAC5C,IAAIf,EAAUoB,EAAME,SAASP,GACzBW,EAAaN,EAAMM,WAAWX,IAAS,CAAC,EAGxCS,EAFkB/D,OAAO4D,KAAKD,EAAMK,OAAOzD,eAAe+C,GAAQK,EAAMK,OAAOV,GAAQiB,EAAcjB,IAE7E9B,QAAO,SAAUuC,EAAOe,GAElD,OADAf,EAAMe,GAAY,GACXf,CACT,GAAG,CAAC,GAECb,EAAcX,IAAaD,EAAYC,KAI5CvC,OAAOkE,OAAO3B,EAAQwB,MAAOA,GAC7B/D,OAAO4D,KAAKK,GAAYH,SAAQ,SAAUiB,GACxCxC,EAAQ4B,gBAAgBY,EAC1B,IACF,GACF,CACF,EASEC,SAAU,CAAC,kBCjFE,SAASC,EAAiBvD,GACvC,OAAOA,EAAUwD,MAAM,KAAK,EAC9B,CCHO,IAAI,EAAMC,KAAKC,IACX,EAAMD,KAAKE,IACXC,EAAQH,KAAKG,MCFT,SAASC,IACtB,IAAIC,EAASC,UAAUC,cAEvB,OAAc,MAAVF,GAAkBA,EAAOG,QAAUC,MAAMC,QAAQL,EAAOG,QACnDH,EAAOG,OAAOG,KAAI,SAAUC,GACjC,OAAOA,EAAKC,MAAQ,IAAMD,EAAKE,OACjC,IAAGC,KAAK,KAGHT,UAAUU,SACnB,CCTe,SAASC,IACtB,OAAQ,iCAAiCC,KAAKd,IAChD,CCCe,SAASe,EAAsB/D,EAASgE,EAAcC,QAC9C,IAAjBD,IACFA,GAAe,QAGO,IAApBC,IACFA,GAAkB,GAGpB,IAAIC,EAAalE,EAAQ+D,wBACrBI,EAAS,EACTC,EAAS,EAETJ,GAAgBrD,EAAcX,KAChCmE,EAASnE,EAAQqE,YAAc,GAAItB,EAAMmB,EAAWI,OAAStE,EAAQqE,aAAmB,EACxFD,EAASpE,EAAQuE,aAAe,GAAIxB,EAAMmB,EAAWM,QAAUxE,EAAQuE,cAAoB,GAG7F,IACIE,GADOhE,EAAUT,GAAWG,EAAUH,GAAWK,QAC3BoE,eAEtBC,GAAoBb,KAAsBI,EAC1CU,GAAKT,EAAW3F,MAAQmG,GAAoBD,EAAiBA,EAAeG,WAAa,IAAMT,EAC/FU,GAAKX,EAAW9B,KAAOsC,GAAoBD,EAAiBA,EAAeK,UAAY,IAAMV,EAC7FE,EAAQJ,EAAWI,MAAQH,EAC3BK,EAASN,EAAWM,OAASJ,EACjC,MAAO,CACLE,MAAOA,EACPE,OAAQA,EACRpC,IAAKyC,EACLvG,MAAOqG,EAAIL,EACXjG,OAAQwG,EAAIL,EACZjG,KAAMoG,EACNA,EAAGA,EACHE,EAAGA,EAEP,CCrCe,SAASE,EAAc/E,GACpC,IAAIkE,EAAaH,EAAsB/D,GAGnCsE,EAAQtE,EAAQqE,YAChBG,EAASxE,EAAQuE,aAUrB,OARI3B,KAAKoC,IAAId,EAAWI,MAAQA,IAAU,IACxCA,EAAQJ,EAAWI,OAGjB1B,KAAKoC,IAAId,EAAWM,OAASA,IAAW,IAC1CA,EAASN,EAAWM,QAGf,CACLG,EAAG3E,EAAQ4E,WACXC,EAAG7E,EAAQ8E,UACXR,MAAOA,EACPE,OAAQA,EAEZ,CCvBe,SAASS,EAASC,EAAQC,GACvC,IAAIC,EAAWD,EAAME,aAAeF,EAAME,cAE1C,GAAIH,EAAOD,SAASE,GAClB,OAAO,EAEJ,GAAIC,GAAYvE,EAAauE,GAAW,CACzC,IAAIE,EAAOH,EAEX,EAAG,CACD,GAAIG,GAAQJ,EAAOK,WAAWD,GAC5B,OAAO,EAITA,EAAOA,EAAKE,YAAcF,EAAKG,IACjC,OAASH,EACX,CAGF,OAAO,CACT,CCrBe,SAAS,EAAiBtF,GACvC,OAAOG,EAAUH,GAAS0F,iBAAiB1F,EAC7C,CCFe,SAAS2F,EAAe3F,GACrC,MAAO,CAAC,QAAS,KAAM,MAAM4F,QAAQ7F,EAAYC,KAAa,CAChE,CCFe,SAAS6F,EAAmB7F,GAEzC,QAASS,EAAUT,GAAWA,EAAQO,cACtCP,EAAQ8F,WAAazF,OAAOyF,UAAUC,eACxC,CCFe,SAASC,EAAchG,GACpC,MAA6B,SAAzBD,EAAYC,GACPA,EAMPA,EAAQiG,cACRjG,EAAQwF,aACR3E,EAAab,GAAWA,EAAQyF,KAAO,OAEvCI,EAAmB7F,EAGvB,CCVA,SAASkG,EAAoBlG,GAC3B,OAAKW,EAAcX,IACoB,UAAvC,EAAiBA,GAASiC,SAInBjC,EAAQmG,aAHN,IAIX,CAwCe,SAASC,EAAgBpG,GAItC,IAHA,IAAIK,EAASF,EAAUH,GACnBmG,EAAeD,EAAoBlG,GAEhCmG,GAAgBR,EAAeQ,IAA6D,WAA5C,EAAiBA,GAAclE,UACpFkE,EAAeD,EAAoBC,GAGrC,OAAIA,IAA+C,SAA9BpG,EAAYoG,IAA0D,SAA9BpG,EAAYoG,IAAwE,WAA5C,EAAiBA,GAAclE,UAC3H5B,EAGF8F,GAhDT,SAA4BnG,GAC1B,IAAIqG,EAAY,WAAWvC,KAAKd,KAGhC,GAFW,WAAWc,KAAKd,MAEfrC,EAAcX,IAII,UAFX,EAAiBA,GAEnBiC,SACb,OAAO,KAIX,IAAIqE,EAAcN,EAAchG,GAMhC,IAJIa,EAAayF,KACfA,EAAcA,EAAYb,MAGrB9E,EAAc2F,IAAgB,CAAC,OAAQ,QAAQV,QAAQ7F,EAAYuG,IAAgB,GAAG,CAC3F,IAAIC,EAAM,EAAiBD,GAI3B,GAAsB,SAAlBC,EAAIC,WAA4C,SAApBD,EAAIE,aAA0C,UAAhBF,EAAIG,UAAiF,IAA1D,CAAC,YAAa,eAAed,QAAQW,EAAII,aAAsBN,GAAgC,WAAnBE,EAAII,YAA2BN,GAAaE,EAAIK,QAAyB,SAAfL,EAAIK,OACjO,OAAON,EAEPA,EAAcA,EAAYd,UAE9B,CAEA,OAAO,IACT,CAgByBqB,CAAmB7G,IAAYK,CACxD,CCpEe,SAASyG,EAAyB3H,GAC/C,MAAO,CAAC,MAAO,UAAUyG,QAAQzG,IAAc,EAAI,IAAM,GAC3D,CCDO,SAAS4H,EAAOjE,EAAK1E,EAAOyE,GACjC,OAAO,EAAQC,EAAK,EAAQ1E,EAAOyE,GACrC,CCFe,SAASmE,EAAmBC,GACzC,OAAOxJ,OAAOkE,OAAO,CAAC,ECDf,CACLS,IAAK,EACL9D,MAAO,EACPD,OAAQ,EACRE,KAAM,GDHuC0I,EACjD,CEHe,SAASC,EAAgB9I,EAAOiD,GAC7C,OAAOA,EAAKpC,QAAO,SAAUkI,EAAS5J,GAEpC,OADA4J,EAAQ5J,GAAOa,EACR+I,CACT,GAAG,CAAC,EACN,CC4EA,SACEpG,KAAM,QACNC,SAAS,EACTC,MAAO,OACPC,GApEF,SAAeC,GACb,IAAIiG,EAEAhG,EAAQD,EAAKC,MACbL,EAAOI,EAAKJ,KACZmB,EAAUf,EAAKe,QACfmF,EAAejG,EAAME,SAASgB,MAC9BgF,EAAgBlG,EAAMmG,cAAcD,cACpCE,EAAgB9E,EAAiBtB,EAAMjC,WACvCsI,EAAOX,EAAyBU,GAEhCE,EADa,CAACnJ,EAAMD,GAAOsH,QAAQ4B,IAAkB,EAClC,SAAW,QAElC,GAAKH,GAAiBC,EAAtB,CAIA,IAAIL,EAxBgB,SAAyBU,EAASvG,GAItD,OAAO4F,EAAsC,iBAH7CW,EAA6B,mBAAZA,EAAyBA,EAAQlK,OAAOkE,OAAO,CAAC,EAAGP,EAAMwG,MAAO,CAC/EzI,UAAWiC,EAAMjC,aACbwI,GACkDA,EAAUT,EAAgBS,EAASlJ,GAC7F,CAmBsBoJ,CAAgB3F,EAAQyF,QAASvG,GACjD0G,EAAY/C,EAAcsC,GAC1BU,EAAmB,MAATN,EAAe,EAAMlJ,EAC/ByJ,EAAmB,MAATP,EAAepJ,EAASC,EAClC2J,EAAU7G,EAAMwG,MAAM7I,UAAU2I,GAAOtG,EAAMwG,MAAM7I,UAAU0I,GAAQH,EAAcG,GAAQrG,EAAMwG,MAAM9I,OAAO4I,GAC9GQ,EAAYZ,EAAcG,GAAQrG,EAAMwG,MAAM7I,UAAU0I,GACxDU,EAAoB/B,EAAgBiB,GACpCe,EAAaD,EAA6B,MAATV,EAAeU,EAAkBE,cAAgB,EAAIF,EAAkBG,aAAe,EAAI,EAC3HC,EAAoBN,EAAU,EAAIC,EAAY,EAG9CpF,EAAMmE,EAAcc,GACpBlF,EAAMuF,EAAaN,EAAUJ,GAAOT,EAAce,GAClDQ,EAASJ,EAAa,EAAIN,EAAUJ,GAAO,EAAIa,EAC/CE,EAAS1B,EAAOjE,EAAK0F,EAAQ3F,GAE7B6F,EAAWjB,EACfrG,EAAMmG,cAAcxG,KAASqG,EAAwB,CAAC,GAAyBsB,GAAYD,EAAQrB,EAAsBuB,aAAeF,EAASD,EAAQpB,EAnBzJ,CAoBF,EAkCEtF,OAhCF,SAAgBC,GACd,IAAIX,EAAQW,EAAMX,MAEdwH,EADU7G,EAAMG,QACWlC,QAC3BqH,OAAoC,IAArBuB,EAA8B,sBAAwBA,EAErD,MAAhBvB,IAKwB,iBAAjBA,IACTA,EAAejG,EAAME,SAASxC,OAAO+J,cAAcxB,MAOhDpC,EAAS7D,EAAME,SAASxC,OAAQuI,KAIrCjG,EAAME,SAASgB,MAAQ+E,EACzB,EASE5E,SAAU,CAAC,iBACXqG,iBAAkB,CAAC,oBCxFN,SAASC,EAAa5J,GACnC,OAAOA,EAAUwD,MAAM,KAAK,EAC9B,CCOA,IAAIqG,EAAa,CACf5G,IAAK,OACL9D,MAAO,OACPD,OAAQ,OACRE,KAAM,QAeD,SAAS0K,GAAYlH,GAC1B,IAAImH,EAEApK,EAASiD,EAAMjD,OACfqK,EAAapH,EAAMoH,WACnBhK,EAAY4C,EAAM5C,UAClBiK,EAAYrH,EAAMqH,UAClBC,EAAUtH,EAAMsH,QAChBpH,EAAWF,EAAME,SACjBqH,EAAkBvH,EAAMuH,gBACxBC,EAAWxH,EAAMwH,SACjBC,EAAezH,EAAMyH,aACrBC,EAAU1H,EAAM0H,QAChBC,EAAaL,EAAQ1E,EACrBA,OAAmB,IAAf+E,EAAwB,EAAIA,EAChCC,EAAaN,EAAQxE,EACrBA,OAAmB,IAAf8E,EAAwB,EAAIA,EAEhCC,EAAgC,mBAAjBJ,EAA8BA,EAAa,CAC5D7E,EAAGA,EACHE,IACG,CACHF,EAAGA,EACHE,GAGFF,EAAIiF,EAAMjF,EACVE,EAAI+E,EAAM/E,EACV,IAAIgF,EAAOR,EAAQrL,eAAe,KAC9B8L,EAAOT,EAAQrL,eAAe,KAC9B+L,EAAQxL,EACRyL,EAAQ,EACRC,EAAM5J,OAEV,GAAIkJ,EAAU,CACZ,IAAIpD,EAAeC,EAAgBtH,GAC/BoL,EAAa,eACbC,EAAY,cAEZhE,IAAiBhG,EAAUrB,IAGmB,WAA5C,EAFJqH,EAAeN,EAAmB/G,IAECmD,UAAsC,aAAbA,IAC1DiI,EAAa,eACbC,EAAY,gBAOZhL,IAAc,IAAQA,IAAcZ,GAAQY,IAAcb,IAAU8K,IAAczK,KACpFqL,EAAQ3L,EAGRwG,IAFc4E,GAAWtD,IAAiB8D,GAAOA,EAAIxF,eAAiBwF,EAAIxF,eAAeD,OACzF2B,EAAa+D,IACEf,EAAW3E,OAC1BK,GAAKyE,EAAkB,GAAK,GAG1BnK,IAAcZ,IAASY,IAAc,GAAOA,IAAcd,GAAW+K,IAAczK,KACrFoL,EAAQzL,EAGRqG,IAFc8E,GAAWtD,IAAiB8D,GAAOA,EAAIxF,eAAiBwF,EAAIxF,eAAeH,MACzF6B,EAAagE,IACEhB,EAAW7E,MAC1BK,GAAK2E,EAAkB,GAAK,EAEhC,CAEA,IAgBMc,EAhBFC,EAAe5M,OAAOkE,OAAO,CAC/BM,SAAUA,GACTsH,GAAYP,GAEXsB,GAAyB,IAAjBd,EAlFd,SAA2BrI,EAAM8I,GAC/B,IAAItF,EAAIxD,EAAKwD,EACTE,EAAI1D,EAAK0D,EACT0F,EAAMN,EAAIO,kBAAoB,EAClC,MAAO,CACL7F,EAAG5B,EAAM4B,EAAI4F,GAAOA,GAAO,EAC3B1F,EAAG9B,EAAM8B,EAAI0F,GAAOA,GAAO,EAE/B,CA0EsCE,CAAkB,CACpD9F,EAAGA,EACHE,GACC1E,EAAUrB,IAAW,CACtB6F,EAAGA,EACHE,GAMF,OAHAF,EAAI2F,EAAM3F,EACVE,EAAIyF,EAAMzF,EAENyE,EAGK7L,OAAOkE,OAAO,CAAC,EAAG0I,IAAeD,EAAiB,CAAC,GAAkBJ,GAASF,EAAO,IAAM,GAAIM,EAAeL,GAASF,EAAO,IAAM,GAAIO,EAAe5D,WAAayD,EAAIO,kBAAoB,IAAM,EAAI,aAAe7F,EAAI,OAASE,EAAI,MAAQ,eAAiBF,EAAI,OAASE,EAAI,SAAUuF,IAG5R3M,OAAOkE,OAAO,CAAC,EAAG0I,IAAenB,EAAkB,CAAC,GAAmBc,GAASF,EAAOjF,EAAI,KAAO,GAAIqE,EAAgBa,GAASF,EAAOlF,EAAI,KAAO,GAAIuE,EAAgB1C,UAAY,GAAI0C,GAC9L,CA4CA,UACEnI,KAAM,gBACNC,SAAS,EACTC,MAAO,cACPC,GA9CF,SAAuBwJ,GACrB,IAAItJ,EAAQsJ,EAAMtJ,MACdc,EAAUwI,EAAMxI,QAChByI,EAAwBzI,EAAQoH,gBAChCA,OAA4C,IAA1BqB,GAA0CA,EAC5DC,EAAoB1I,EAAQqH,SAC5BA,OAAiC,IAAtBqB,GAAsCA,EACjDC,EAAwB3I,EAAQsH,aAChCA,OAAyC,IAA1BqB,GAA0CA,EACzDR,EAAe,CACjBlL,UAAWuD,EAAiBtB,EAAMjC,WAClCiK,UAAWL,EAAa3H,EAAMjC,WAC9BL,OAAQsC,EAAME,SAASxC,OACvBqK,WAAY/H,EAAMwG,MAAM9I,OACxBwK,gBAAiBA,EACjBG,QAAoC,UAA3BrI,EAAMc,QAAQC,UAGgB,MAArCf,EAAMmG,cAAcD,gBACtBlG,EAAMK,OAAO3C,OAASrB,OAAOkE,OAAO,CAAC,EAAGP,EAAMK,OAAO3C,OAAQmK,GAAYxL,OAAOkE,OAAO,CAAC,EAAG0I,EAAc,CACvGhB,QAASjI,EAAMmG,cAAcD,cAC7BrF,SAAUb,EAAMc,QAAQC,SACxBoH,SAAUA,EACVC,aAAcA,OAIe,MAA7BpI,EAAMmG,cAAcjF,QACtBlB,EAAMK,OAAOa,MAAQ7E,OAAOkE,OAAO,CAAC,EAAGP,EAAMK,OAAOa,MAAO2G,GAAYxL,OAAOkE,OAAO,CAAC,EAAG0I,EAAc,CACrGhB,QAASjI,EAAMmG,cAAcjF,MAC7BL,SAAU,WACVsH,UAAU,EACVC,aAAcA,OAIlBpI,EAAMM,WAAW5C,OAASrB,OAAOkE,OAAO,CAAC,EAAGP,EAAMM,WAAW5C,OAAQ,CACnE,wBAAyBsC,EAAMjC,WAEnC,EAQE2L,KAAM,CAAC,GCrKT,IAAIC,GAAU,CACZA,SAAS,GAsCX,UACEhK,KAAM,iBACNC,SAAS,EACTC,MAAO,QACPC,GAAI,WAAe,EACnBY,OAxCF,SAAgBX,GACd,IAAIC,EAAQD,EAAKC,MACb4J,EAAW7J,EAAK6J,SAChB9I,EAAUf,EAAKe,QACf+I,EAAkB/I,EAAQgJ,OAC1BA,OAA6B,IAApBD,GAAoCA,EAC7CE,EAAkBjJ,EAAQkJ,OAC1BA,OAA6B,IAApBD,GAAoCA,EAC7C9K,EAASF,EAAUiB,EAAME,SAASxC,QAClCuM,EAAgB,GAAGjM,OAAOgC,EAAMiK,cAActM,UAAWqC,EAAMiK,cAAcvM,QAYjF,OAVIoM,GACFG,EAAc9J,SAAQ,SAAU+J,GAC9BA,EAAaC,iBAAiB,SAAUP,EAASQ,OAAQT,GAC3D,IAGEK,GACF/K,EAAOkL,iBAAiB,SAAUP,EAASQ,OAAQT,IAG9C,WACDG,GACFG,EAAc9J,SAAQ,SAAU+J,GAC9BA,EAAaG,oBAAoB,SAAUT,EAASQ,OAAQT,GAC9D,IAGEK,GACF/K,EAAOoL,oBAAoB,SAAUT,EAASQ,OAAQT,GAE1D,CACF,EASED,KAAM,CAAC,GC/CT,IAAIY,GAAO,CACTnN,KAAM,QACND,MAAO,OACPD,OAAQ,MACR+D,IAAK,UAEQ,SAASuJ,GAAqBxM,GAC3C,OAAOA,EAAUyM,QAAQ,0BAA0B,SAAUC,GAC3D,OAAOH,GAAKG,EACd,GACF,CCVA,IAAI,GAAO,CACTnN,MAAO,MACPC,IAAK,SAEQ,SAASmN,GAA8B3M,GACpD,OAAOA,EAAUyM,QAAQ,cAAc,SAAUC,GAC/C,OAAO,GAAKA,EACd,GACF,CCPe,SAASE,GAAgB3L,GACtC,IAAI6J,EAAM9J,EAAUC,GAGpB,MAAO,CACL4L,WAHe/B,EAAIgC,YAInBC,UAHcjC,EAAIkC,YAKtB,CCNe,SAASC,GAAoBpM,GAQ1C,OAAO+D,EAAsB8B,EAAmB7F,IAAUzB,KAAOwN,GAAgB/L,GAASgM,UAC5F,CCXe,SAASK,GAAerM,GAErC,IAAIsM,EAAoB,EAAiBtM,GACrCuM,EAAWD,EAAkBC,SAC7BC,EAAYF,EAAkBE,UAC9BC,EAAYH,EAAkBG,UAElC,MAAO,6BAA6B3I,KAAKyI,EAAWE,EAAYD,EAClE,CCLe,SAASE,GAAgBtM,GACtC,MAAI,CAAC,OAAQ,OAAQ,aAAawF,QAAQ7F,EAAYK,KAAU,EAEvDA,EAAKG,cAAcoM,KAGxBhM,EAAcP,IAASiM,GAAejM,GACjCA,EAGFsM,GAAgB1G,EAAc5F,GACvC,CCJe,SAASwM,GAAkB5M,EAAS6M,GACjD,IAAIC,OAES,IAATD,IACFA,EAAO,IAGT,IAAIvB,EAAeoB,GAAgB1M,GAC/B+M,EAASzB,KAAqE,OAAlDwB,EAAwB9M,EAAQO,oBAAyB,EAASuM,EAAsBH,MACpH1C,EAAM9J,EAAUmL,GAChB0B,EAASD,EAAS,CAAC9C,GAAK7K,OAAO6K,EAAIxF,gBAAkB,GAAI4H,GAAef,GAAgBA,EAAe,IAAMA,EAC7G2B,EAAcJ,EAAKzN,OAAO4N,GAC9B,OAAOD,EAASE,EAChBA,EAAY7N,OAAOwN,GAAkB5G,EAAcgH,IACrD,CCzBe,SAASE,GAAiBC,GACvC,OAAO1P,OAAOkE,OAAO,CAAC,EAAGwL,EAAM,CAC7B5O,KAAM4O,EAAKxI,EACXvC,IAAK+K,EAAKtI,EACVvG,MAAO6O,EAAKxI,EAAIwI,EAAK7I,MACrBjG,OAAQ8O,EAAKtI,EAAIsI,EAAK3I,QAE1B,CCqBA,SAAS4I,GAA2BpN,EAASqN,EAAgBlL,GAC3D,OAAOkL,IAAmBxO,EAAWqO,GCzBxB,SAAyBlN,EAASmC,GAC/C,IAAI8H,EAAM9J,EAAUH,GAChBsN,EAAOzH,EAAmB7F,GAC1ByE,EAAiBwF,EAAIxF,eACrBH,EAAQgJ,EAAKhF,YACb9D,EAAS8I,EAAKjF,aACd1D,EAAI,EACJE,EAAI,EAER,GAAIJ,EAAgB,CAClBH,EAAQG,EAAeH,MACvBE,EAASC,EAAeD,OACxB,IAAI+I,EAAiB1J,KAEjB0J,IAAmBA,GAA+B,UAAbpL,KACvCwC,EAAIF,EAAeG,WACnBC,EAAIJ,EAAeK,UAEvB,CAEA,MAAO,CACLR,MAAOA,EACPE,OAAQA,EACRG,EAAGA,EAAIyH,GAAoBpM,GAC3B6E,EAAGA,EAEP,CDDwD2I,CAAgBxN,EAASmC,IAAa1B,EAAU4M,GAdxG,SAAoCrN,EAASmC,GAC3C,IAAIgL,EAAOpJ,EAAsB/D,GAAS,EAAoB,UAAbmC,GASjD,OARAgL,EAAK/K,IAAM+K,EAAK/K,IAAMpC,EAAQyN,UAC9BN,EAAK5O,KAAO4O,EAAK5O,KAAOyB,EAAQ0N,WAChCP,EAAK9O,OAAS8O,EAAK/K,IAAMpC,EAAQqI,aACjC8E,EAAK7O,MAAQ6O,EAAK5O,KAAOyB,EAAQsI,YACjC6E,EAAK7I,MAAQtE,EAAQsI,YACrB6E,EAAK3I,OAASxE,EAAQqI,aACtB8E,EAAKxI,EAAIwI,EAAK5O,KACd4O,EAAKtI,EAAIsI,EAAK/K,IACP+K,CACT,CAG0HQ,CAA2BN,EAAgBlL,GAAY+K,GEtBlK,SAAyBlN,GACtC,IAAI8M,EAEAQ,EAAOzH,EAAmB7F,GAC1B4N,EAAY7B,GAAgB/L,GAC5B2M,EAA0D,OAAlDG,EAAwB9M,EAAQO,oBAAyB,EAASuM,EAAsBH,KAChGrI,EAAQ,EAAIgJ,EAAKO,YAAaP,EAAKhF,YAAaqE,EAAOA,EAAKkB,YAAc,EAAGlB,EAAOA,EAAKrE,YAAc,GACvG9D,EAAS,EAAI8I,EAAKQ,aAAcR,EAAKjF,aAAcsE,EAAOA,EAAKmB,aAAe,EAAGnB,EAAOA,EAAKtE,aAAe,GAC5G1D,GAAKiJ,EAAU5B,WAAaI,GAAoBpM,GAChD6E,GAAK+I,EAAU1B,UAMnB,MAJiD,QAA7C,EAAiBS,GAAQW,GAAMS,YACjCpJ,GAAK,EAAI2I,EAAKhF,YAAaqE,EAAOA,EAAKrE,YAAc,GAAKhE,GAGrD,CACLA,MAAOA,EACPE,OAAQA,EACRG,EAAGA,EACHE,EAAGA,EAEP,CFCkMmJ,CAAgBnI,EAAmB7F,IACrO,CG1Be,SAASiO,GAAe9M,GACrC,IAOIkI,EAPAtK,EAAYoC,EAAKpC,UACjBiB,EAAUmB,EAAKnB,QACfb,EAAYgC,EAAKhC,UACjBqI,EAAgBrI,EAAYuD,EAAiBvD,GAAa,KAC1DiK,EAAYjK,EAAY4J,EAAa5J,GAAa,KAClD+O,EAAUnP,EAAU4F,EAAI5F,EAAUuF,MAAQ,EAAItE,EAAQsE,MAAQ,EAC9D6J,EAAUpP,EAAU8F,EAAI9F,EAAUyF,OAAS,EAAIxE,EAAQwE,OAAS,EAGpE,OAAQgD,GACN,KAAK,EACH6B,EAAU,CACR1E,EAAGuJ,EACHrJ,EAAG9F,EAAU8F,EAAI7E,EAAQwE,QAE3B,MAEF,KAAKnG,EACHgL,EAAU,CACR1E,EAAGuJ,EACHrJ,EAAG9F,EAAU8F,EAAI9F,EAAUyF,QAE7B,MAEF,KAAKlG,EACH+K,EAAU,CACR1E,EAAG5F,EAAU4F,EAAI5F,EAAUuF,MAC3BO,EAAGsJ,GAEL,MAEF,KAAK5P,EACH8K,EAAU,CACR1E,EAAG5F,EAAU4F,EAAI3E,EAAQsE,MACzBO,EAAGsJ,GAEL,MAEF,QACE9E,EAAU,CACR1E,EAAG5F,EAAU4F,EACbE,EAAG9F,EAAU8F,GAInB,IAAIuJ,EAAW5G,EAAgBV,EAAyBU,GAAiB,KAEzE,GAAgB,MAAZ4G,EAAkB,CACpB,IAAI1G,EAAmB,MAAb0G,EAAmB,SAAW,QAExC,OAAQhF,GACN,KAAK1K,EACH2K,EAAQ+E,GAAY/E,EAAQ+E,IAAarP,EAAU2I,GAAO,EAAI1H,EAAQ0H,GAAO,GAC7E,MAEF,KAAK/I,EACH0K,EAAQ+E,GAAY/E,EAAQ+E,IAAarP,EAAU2I,GAAO,EAAI1H,EAAQ0H,GAAO,GAKnF,CAEA,OAAO2B,CACT,CC3De,SAASgF,GAAejN,EAAOc,QAC5B,IAAZA,IACFA,EAAU,CAAC,GAGb,IAAIoM,EAAWpM,EACXqM,EAAqBD,EAASnP,UAC9BA,OAAmC,IAAvBoP,EAAgCnN,EAAMjC,UAAYoP,EAC9DC,EAAoBF,EAASnM,SAC7BA,OAAiC,IAAtBqM,EAA+BpN,EAAMe,SAAWqM,EAC3DC,EAAoBH,EAASI,SAC7BA,OAAiC,IAAtBD,EAA+B7P,EAAkB6P,EAC5DE,EAAwBL,EAASM,aACjCA,OAAyC,IAA1BD,EAAmC9P,EAAW8P,EAC7DE,EAAwBP,EAASQ,eACjCA,OAA2C,IAA1BD,EAAmC/P,EAAS+P,EAC7DE,EAAuBT,EAASU,YAChCA,OAAuC,IAAzBD,GAA0CA,EACxDE,EAAmBX,EAAS3G,QAC5BA,OAA+B,IAArBsH,EAA8B,EAAIA,EAC5ChI,EAAgBD,EAAsC,iBAAZW,EAAuBA,EAAUT,EAAgBS,EAASlJ,IACpGyQ,EAAaJ,IAAmBhQ,EAASC,EAAYD,EACrDqK,EAAa/H,EAAMwG,MAAM9I,OACzBkB,EAAUoB,EAAME,SAAS0N,EAAcE,EAAaJ,GACpDK,EJkBS,SAAyBnP,EAAS0O,EAAUE,EAAczM,GACvE,IAAIiN,EAAmC,oBAAbV,EAlB5B,SAA4B1O,GAC1B,IAAIpB,EAAkBgO,GAAkB5G,EAAchG,IAElDqP,EADoB,CAAC,WAAY,SAASzJ,QAAQ,EAAiB5F,GAASiC,WAAa,GACnDtB,EAAcX,GAAWoG,EAAgBpG,GAAWA,EAE9F,OAAKS,EAAU4O,GAKRzQ,EAAgBgI,QAAO,SAAUyG,GACtC,OAAO5M,EAAU4M,IAAmBpI,EAASoI,EAAgBgC,IAAmD,SAAhCtP,EAAYsN,EAC9F,IANS,EAOX,CAK6DiC,CAAmBtP,GAAW,GAAGZ,OAAOsP,GAC/F9P,EAAkB,GAAGQ,OAAOgQ,EAAqB,CAACR,IAClDW,EAAsB3Q,EAAgB,GACtC4Q,EAAe5Q,EAAgBK,QAAO,SAAUwQ,EAASpC,GAC3D,IAAIF,EAAOC,GAA2BpN,EAASqN,EAAgBlL,GAK/D,OAJAsN,EAAQrN,IAAM,EAAI+K,EAAK/K,IAAKqN,EAAQrN,KACpCqN,EAAQnR,MAAQ,EAAI6O,EAAK7O,MAAOmR,EAAQnR,OACxCmR,EAAQpR,OAAS,EAAI8O,EAAK9O,OAAQoR,EAAQpR,QAC1CoR,EAAQlR,KAAO,EAAI4O,EAAK5O,KAAMkR,EAAQlR,MAC/BkR,CACT,GAAGrC,GAA2BpN,EAASuP,EAAqBpN,IAK5D,OAJAqN,EAAalL,MAAQkL,EAAalR,MAAQkR,EAAajR,KACvDiR,EAAahL,OAASgL,EAAanR,OAASmR,EAAapN,IACzDoN,EAAa7K,EAAI6K,EAAajR,KAC9BiR,EAAa3K,EAAI2K,EAAapN,IACvBoN,CACT,CInC2BE,CAAgBjP,EAAUT,GAAWA,EAAUA,EAAQ2P,gBAAkB9J,EAAmBzE,EAAME,SAASxC,QAAS4P,EAAUE,EAAczM,GACjKyN,EAAsB7L,EAAsB3C,EAAME,SAASvC,WAC3DuI,EAAgB2G,GAAe,CACjClP,UAAW6Q,EACX5P,QAASmJ,EACThH,SAAU,WACVhD,UAAWA,IAET0Q,EAAmB3C,GAAiBzP,OAAOkE,OAAO,CAAC,EAAGwH,EAAY7B,IAClEwI,EAAoBhB,IAAmBhQ,EAAS+Q,EAAmBD,EAGnEG,EAAkB,CACpB3N,IAAK+M,EAAmB/M,IAAM0N,EAAkB1N,IAAM6E,EAAc7E,IACpE/D,OAAQyR,EAAkBzR,OAAS8Q,EAAmB9Q,OAAS4I,EAAc5I,OAC7EE,KAAM4Q,EAAmB5Q,KAAOuR,EAAkBvR,KAAO0I,EAAc1I,KACvED,MAAOwR,EAAkBxR,MAAQ6Q,EAAmB7Q,MAAQ2I,EAAc3I,OAExE0R,EAAa5O,EAAMmG,cAAckB,OAErC,GAAIqG,IAAmBhQ,GAAUkR,EAAY,CAC3C,IAAIvH,EAASuH,EAAW7Q,GACxB1B,OAAO4D,KAAK0O,GAAiBxO,SAAQ,SAAUhE,GAC7C,IAAI0S,EAAW,CAAC3R,EAAOD,GAAQuH,QAAQrI,IAAQ,EAAI,GAAK,EACpDkK,EAAO,CAAC,EAAKpJ,GAAQuH,QAAQrI,IAAQ,EAAI,IAAM,IACnDwS,EAAgBxS,IAAQkL,EAAOhB,GAAQwI,CACzC,GACF,CAEA,OAAOF,CACT,CCyEA,UACEhP,KAAM,OACNC,SAAS,EACTC,MAAO,OACPC,GA5HF,SAAcC,GACZ,IAAIC,EAAQD,EAAKC,MACbc,EAAUf,EAAKe,QACfnB,EAAOI,EAAKJ,KAEhB,IAAIK,EAAMmG,cAAcxG,GAAMmP,MAA9B,CAoCA,IAhCA,IAAIC,EAAoBjO,EAAQkM,SAC5BgC,OAAsC,IAAtBD,GAAsCA,EACtDE,EAAmBnO,EAAQoO,QAC3BC,OAAoC,IAArBF,GAAqCA,EACpDG,EAA8BtO,EAAQuO,mBACtC9I,EAAUzF,EAAQyF,QAClB+G,EAAWxM,EAAQwM,SACnBE,EAAe1M,EAAQ0M,aACvBI,EAAc9M,EAAQ8M,YACtB0B,EAAwBxO,EAAQyO,eAChCA,OAA2C,IAA1BD,GAA0CA,EAC3DE,EAAwB1O,EAAQ0O,sBAChCC,EAAqBzP,EAAMc,QAAQ/C,UACnCqI,EAAgB9E,EAAiBmO,GAEjCJ,EAAqBD,IADHhJ,IAAkBqJ,GACqCF,EAjC/E,SAAuCxR,GACrC,GAAIuD,EAAiBvD,KAAeX,EAClC,MAAO,GAGT,IAAIsS,EAAoBnF,GAAqBxM,GAC7C,MAAO,CAAC2M,GAA8B3M,GAAY2R,EAAmBhF,GAA8BgF,GACrG,CA0B6IC,CAA8BF,GAA3E,CAAClF,GAAqBkF,KAChHG,EAAa,CAACH,GAAoBzR,OAAOqR,GAAoBxR,QAAO,SAAUC,EAAKC,GACrF,OAAOD,EAAIE,OAAOsD,EAAiBvD,KAAeX,ECvCvC,SAA8B4C,EAAOc,QAClC,IAAZA,IACFA,EAAU,CAAC,GAGb,IAAIoM,EAAWpM,EACX/C,EAAYmP,EAASnP,UACrBuP,EAAWJ,EAASI,SACpBE,EAAeN,EAASM,aACxBjH,EAAU2G,EAAS3G,QACnBgJ,EAAiBrC,EAASqC,eAC1BM,EAAwB3C,EAASsC,sBACjCA,OAAkD,IAA1BK,EAAmC,EAAgBA,EAC3E7H,EAAYL,EAAa5J,GACzB6R,EAAa5H,EAAYuH,EAAiB3R,EAAsBA,EAAoB4H,QAAO,SAAUzH,GACvG,OAAO4J,EAAa5J,KAAeiK,CACrC,IAAK3K,EACDyS,EAAoBF,EAAWpK,QAAO,SAAUzH,GAClD,OAAOyR,EAAsBhL,QAAQzG,IAAc,CACrD,IAEiC,IAA7B+R,EAAkBC,SACpBD,EAAoBF,GAItB,IAAII,EAAYF,EAAkBjS,QAAO,SAAUC,EAAKC,GAOtD,OANAD,EAAIC,GAAakP,GAAejN,EAAO,CACrCjC,UAAWA,EACXuP,SAAUA,EACVE,aAAcA,EACdjH,QAASA,IACRjF,EAAiBvD,IACbD,CACT,GAAG,CAAC,GACJ,OAAOzB,OAAO4D,KAAK+P,GAAWC,MAAK,SAAUC,EAAGC,GAC9C,OAAOH,EAAUE,GAAKF,EAAUG,EAClC,GACF,CDC6DC,CAAqBpQ,EAAO,CACnFjC,UAAWA,EACXuP,SAAUA,EACVE,aAAcA,EACdjH,QAASA,EACTgJ,eAAgBA,EAChBC,sBAAuBA,IACpBzR,EACP,GAAG,IACCsS,EAAgBrQ,EAAMwG,MAAM7I,UAC5BoK,EAAa/H,EAAMwG,MAAM9I,OACzB4S,EAAY,IAAIC,IAChBC,GAAqB,EACrBC,EAAwBb,EAAW,GAE9Bc,EAAI,EAAGA,EAAId,EAAWG,OAAQW,IAAK,CAC1C,IAAI3S,EAAY6R,EAAWc,GAEvBC,EAAiBrP,EAAiBvD,GAElC6S,EAAmBjJ,EAAa5J,KAAeT,EAC/CuT,EAAa,CAAC,EAAK5T,GAAQuH,QAAQmM,IAAmB,EACtDrK,EAAMuK,EAAa,QAAU,SAC7B1F,EAAW8B,GAAejN,EAAO,CACnCjC,UAAWA,EACXuP,SAAUA,EACVE,aAAcA,EACdI,YAAaA,EACbrH,QAASA,IAEPuK,EAAoBD,EAAaD,EAAmB1T,EAAQC,EAAOyT,EAAmB3T,EAAS,EAE/FoT,EAAc/J,GAAOyB,EAAWzB,KAClCwK,EAAoBvG,GAAqBuG,IAG3C,IAAIC,EAAmBxG,GAAqBuG,GACxCE,EAAS,GAUb,GARIhC,GACFgC,EAAOC,KAAK9F,EAASwF,IAAmB,GAGtCxB,GACF6B,EAAOC,KAAK9F,EAAS2F,IAAsB,EAAG3F,EAAS4F,IAAqB,GAG1EC,EAAOE,OAAM,SAAUC,GACzB,OAAOA,CACT,IAAI,CACFV,EAAwB1S,EACxByS,GAAqB,EACrB,KACF,CAEAF,EAAUc,IAAIrT,EAAWiT,EAC3B,CAEA,GAAIR,EAqBF,IAnBA,IAEIa,EAAQ,SAAeC,GACzB,IAAIC,EAAmB3B,EAAW4B,MAAK,SAAUzT,GAC/C,IAAIiT,EAASV,EAAU9T,IAAIuB,GAE3B,GAAIiT,EACF,OAAOA,EAAOS,MAAM,EAAGH,GAAIJ,OAAM,SAAUC,GACzC,OAAOA,CACT,GAEJ,IAEA,GAAII,EAEF,OADAd,EAAwBc,EACjB,OAEX,EAESD,EAnBY/B,EAAiB,EAAI,EAmBZ+B,EAAK,GAGpB,UAFFD,EAAMC,GADmBA,KAOpCtR,EAAMjC,YAAc0S,IACtBzQ,EAAMmG,cAAcxG,GAAMmP,OAAQ,EAClC9O,EAAMjC,UAAY0S,EAClBzQ,EAAM0R,OAAQ,EA5GhB,CA8GF,EAQEhK,iBAAkB,CAAC,UACnBgC,KAAM,CACJoF,OAAO,IE7IX,SAAS6C,GAAexG,EAAUY,EAAM6F,GAQtC,YAPyB,IAArBA,IACFA,EAAmB,CACjBrO,EAAG,EACHE,EAAG,IAIA,CACLzC,IAAKmK,EAASnK,IAAM+K,EAAK3I,OAASwO,EAAiBnO,EACnDvG,MAAOiO,EAASjO,MAAQ6O,EAAK7I,MAAQ0O,EAAiBrO,EACtDtG,OAAQkO,EAASlO,OAAS8O,EAAK3I,OAASwO,EAAiBnO,EACzDtG,KAAMgO,EAAShO,KAAO4O,EAAK7I,MAAQ0O,EAAiBrO,EAExD,CAEA,SAASsO,GAAsB1G,GAC7B,MAAO,CAAC,EAAKjO,EAAOD,EAAQE,GAAM2U,MAAK,SAAUC,GAC/C,OAAO5G,EAAS4G,IAAS,CAC3B,GACF,CA+BA,UACEpS,KAAM,OACNC,SAAS,EACTC,MAAO,OACP6H,iBAAkB,CAAC,mBACnB5H,GAlCF,SAAcC,GACZ,IAAIC,EAAQD,EAAKC,MACbL,EAAOI,EAAKJ,KACZ0Q,EAAgBrQ,EAAMwG,MAAM7I,UAC5BoK,EAAa/H,EAAMwG,MAAM9I,OACzBkU,EAAmB5R,EAAMmG,cAAc6L,gBACvCC,EAAoBhF,GAAejN,EAAO,CAC5C0N,eAAgB,cAEdwE,EAAoBjF,GAAejN,EAAO,CAC5C4N,aAAa,IAEXuE,EAA2BR,GAAeM,EAAmB5B,GAC7D+B,EAAsBT,GAAeO,EAAmBnK,EAAY6J,GACpES,EAAoBR,GAAsBM,GAC1CG,EAAmBT,GAAsBO,GAC7CpS,EAAMmG,cAAcxG,GAAQ,CAC1BwS,yBAA0BA,EAC1BC,oBAAqBA,EACrBC,kBAAmBA,EACnBC,iBAAkBA,GAEpBtS,EAAMM,WAAW5C,OAASrB,OAAOkE,OAAO,CAAC,EAAGP,EAAMM,WAAW5C,OAAQ,CACnE,+BAAgC2U,EAChC,sBAAuBC,GAE3B,GCJA,IACE3S,KAAM,SACNC,SAAS,EACTC,MAAO,OACPwB,SAAU,CAAC,iBACXvB,GA5BF,SAAgBa,GACd,IAAIX,EAAQW,EAAMX,MACdc,EAAUH,EAAMG,QAChBnB,EAAOgB,EAAMhB,KACb4S,EAAkBzR,EAAQuG,OAC1BA,OAA6B,IAApBkL,EAA6B,CAAC,EAAG,GAAKA,EAC/C7I,EAAO,EAAW7L,QAAO,SAAUC,EAAKC,GAE1C,OADAD,EAAIC,GA5BD,SAAiCA,EAAWyI,EAAOa,GACxD,IAAIjB,EAAgB9E,EAAiBvD,GACjCyU,EAAiB,CAACrV,EAAM,GAAKqH,QAAQ4B,IAAkB,GAAK,EAAI,EAEhErG,EAAyB,mBAAXsH,EAAwBA,EAAOhL,OAAOkE,OAAO,CAAC,EAAGiG,EAAO,CACxEzI,UAAWA,KACPsJ,EACFoL,EAAW1S,EAAK,GAChB2S,EAAW3S,EAAK,GAIpB,OAFA0S,EAAWA,GAAY,EACvBC,GAAYA,GAAY,GAAKF,EACtB,CAACrV,EAAMD,GAAOsH,QAAQ4B,IAAkB,EAAI,CACjD7C,EAAGmP,EACHjP,EAAGgP,GACD,CACFlP,EAAGkP,EACHhP,EAAGiP,EAEP,CASqBC,CAAwB5U,EAAWiC,EAAMwG,MAAOa,GAC1DvJ,CACT,GAAG,CAAC,GACA8U,EAAwBlJ,EAAK1J,EAAMjC,WACnCwF,EAAIqP,EAAsBrP,EAC1BE,EAAImP,EAAsBnP,EAEW,MAArCzD,EAAMmG,cAAcD,gBACtBlG,EAAMmG,cAAcD,cAAc3C,GAAKA,EACvCvD,EAAMmG,cAAcD,cAAczC,GAAKA,GAGzCzD,EAAMmG,cAAcxG,GAAQ+J,CAC9B,GC1BA,IACE/J,KAAM,gBACNC,SAAS,EACTC,MAAO,OACPC,GApBF,SAAuBC,GACrB,IAAIC,EAAQD,EAAKC,MACbL,EAAOI,EAAKJ,KAKhBK,EAAMmG,cAAcxG,GAAQkN,GAAe,CACzClP,UAAWqC,EAAMwG,MAAM7I,UACvBiB,QAASoB,EAAMwG,MAAM9I,OACrBqD,SAAU,WACVhD,UAAWiC,EAAMjC,WAErB,EAQE2L,KAAM,CAAC,GCgHT,IACE/J,KAAM,kBACNC,SAAS,EACTC,MAAO,OACPC,GA/HF,SAAyBC,GACvB,IAAIC,EAAQD,EAAKC,MACbc,EAAUf,EAAKe,QACfnB,EAAOI,EAAKJ,KACZoP,EAAoBjO,EAAQkM,SAC5BgC,OAAsC,IAAtBD,GAAsCA,EACtDE,EAAmBnO,EAAQoO,QAC3BC,OAAoC,IAArBF,GAAsCA,EACrD3B,EAAWxM,EAAQwM,SACnBE,EAAe1M,EAAQ0M,aACvBI,EAAc9M,EAAQ8M,YACtBrH,EAAUzF,EAAQyF,QAClBsM,EAAkB/R,EAAQgS,OAC1BA,OAA6B,IAApBD,GAAoCA,EAC7CE,EAAwBjS,EAAQkS,aAChCA,OAAyC,IAA1BD,EAAmC,EAAIA,EACtD5H,EAAW8B,GAAejN,EAAO,CACnCsN,SAAUA,EACVE,aAAcA,EACdjH,QAASA,EACTqH,YAAaA,IAEXxH,EAAgB9E,EAAiBtB,EAAMjC,WACvCiK,EAAYL,EAAa3H,EAAMjC,WAC/BkV,GAAmBjL,EACnBgF,EAAWtH,EAAyBU,GACpC8I,ECrCY,MDqCSlC,ECrCH,IAAM,IDsCxB9G,EAAgBlG,EAAMmG,cAAcD,cACpCmK,EAAgBrQ,EAAMwG,MAAM7I,UAC5BoK,EAAa/H,EAAMwG,MAAM9I,OACzBwV,EAA4C,mBAAjBF,EAA8BA,EAAa3W,OAAOkE,OAAO,CAAC,EAAGP,EAAMwG,MAAO,CACvGzI,UAAWiC,EAAMjC,aACbiV,EACFG,EAA2D,iBAAtBD,EAAiC,CACxElG,SAAUkG,EACVhE,QAASgE,GACP7W,OAAOkE,OAAO,CAChByM,SAAU,EACVkC,QAAS,GACRgE,GACCE,EAAsBpT,EAAMmG,cAAckB,OAASrH,EAAMmG,cAAckB,OAAOrH,EAAMjC,WAAa,KACjG2L,EAAO,CACTnG,EAAG,EACHE,EAAG,GAGL,GAAKyC,EAAL,CAIA,GAAI8I,EAAe,CACjB,IAAIqE,EAEAC,EAAwB,MAAbtG,EAAmB,EAAM7P,EACpCoW,EAAuB,MAAbvG,EAAmB/P,EAASC,EACtCoJ,EAAmB,MAAb0G,EAAmB,SAAW,QACpC3F,EAASnB,EAAc8G,GACvBtL,EAAM2F,EAAS8D,EAASmI,GACxB7R,EAAM4F,EAAS8D,EAASoI,GACxBC,EAAWV,GAAU/K,EAAWzB,GAAO,EAAI,EAC3CmN,EAASzL,IAAc1K,EAAQ+S,EAAc/J,GAAOyB,EAAWzB,GAC/DoN,EAAS1L,IAAc1K,GAASyK,EAAWzB,IAAQ+J,EAAc/J,GAGjEL,EAAejG,EAAME,SAASgB,MAC9BwF,EAAYoM,GAAU7M,EAAetC,EAAcsC,GAAgB,CACrE/C,MAAO,EACPE,OAAQ,GAENuQ,GAAqB3T,EAAMmG,cAAc,oBAAsBnG,EAAMmG,cAAc,oBAAoBI,QxBhFtG,CACLvF,IAAK,EACL9D,MAAO,EACPD,OAAQ,EACRE,KAAM,GwB6EFyW,GAAkBD,GAAmBL,GACrCO,GAAkBF,GAAmBJ,GAMrCO,GAAWnO,EAAO,EAAG0K,EAAc/J,GAAMI,EAAUJ,IACnDyN,GAAYd,EAAkB5C,EAAc/J,GAAO,EAAIkN,EAAWM,GAAWF,GAAkBT,EAA4BnG,SAAWyG,EAASK,GAAWF,GAAkBT,EAA4BnG,SACxMgH,GAAYf,GAAmB5C,EAAc/J,GAAO,EAAIkN,EAAWM,GAAWD,GAAkBV,EAA4BnG,SAAW0G,EAASI,GAAWD,GAAkBV,EAA4BnG,SACzMjG,GAAoB/G,EAAME,SAASgB,OAAS8D,EAAgBhF,EAAME,SAASgB,OAC3E+S,GAAelN,GAAiC,MAAbiG,EAAmBjG,GAAkBsF,WAAa,EAAItF,GAAkBuF,YAAc,EAAI,EAC7H4H,GAAwH,OAAjGb,EAA+C,MAAvBD,OAA8B,EAASA,EAAoBpG,IAAqBqG,EAAwB,EAEvJc,GAAY9M,EAAS2M,GAAYE,GACjCE,GAAkBzO,EAAOmN,EAAS,EAAQpR,EAF9B2F,EAAS0M,GAAYG,GAAsBD,IAEKvS,EAAK2F,EAAQyL,EAAS,EAAQrR,EAAK0S,IAAa1S,GAChHyE,EAAc8G,GAAYoH,GAC1B1K,EAAKsD,GAAYoH,GAAkB/M,CACrC,CAEA,GAAI8H,EAAc,CAChB,IAAIkF,GAEAC,GAAyB,MAAbtH,EAAmB,EAAM7P,EAErCoX,GAAwB,MAAbvH,EAAmB/P,EAASC,EAEvCsX,GAAUtO,EAAcgJ,GAExBuF,GAAmB,MAAZvF,EAAkB,SAAW,QAEpCwF,GAAOF,GAAUrJ,EAASmJ,IAE1BK,GAAOH,GAAUrJ,EAASoJ,IAE1BK,IAAuD,IAAxC,CAAC,EAAKzX,GAAMqH,QAAQ4B,GAEnCyO,GAAyH,OAAjGR,GAAgD,MAAvBjB,OAA8B,EAASA,EAAoBlE,IAAoBmF,GAAyB,EAEzJS,GAAaF,GAAeF,GAAOF,GAAUnE,EAAcoE,IAAQ1M,EAAW0M,IAAQI,GAAuB1B,EAA4BjE,QAEzI6F,GAAaH,GAAeJ,GAAUnE,EAAcoE,IAAQ1M,EAAW0M,IAAQI,GAAuB1B,EAA4BjE,QAAUyF,GAE5IK,GAAmBlC,GAAU8B,G1BzH9B,SAAwBlT,EAAK1E,EAAOyE,GACzC,IAAIwT,EAAItP,EAAOjE,EAAK1E,EAAOyE,GAC3B,OAAOwT,EAAIxT,EAAMA,EAAMwT,CACzB,C0BsHoDC,CAAeJ,GAAYN,GAASO,IAAcpP,EAAOmN,EAASgC,GAAaJ,GAAMF,GAAS1B,EAASiC,GAAaJ,IAEpKzO,EAAcgJ,GAAW8F,GACzBtL,EAAKwF,GAAW8F,GAAmBR,EACrC,CAEAxU,EAAMmG,cAAcxG,GAAQ+J,CAvE5B,CAwEF,EAQEhC,iBAAkB,CAAC,WE1HN,SAASyN,GAAiBC,EAAyBrQ,EAAcsD,QAC9D,IAAZA,IACFA,GAAU,GAGZ,ICnBoCrJ,ECJOJ,EFuBvCyW,EAA0B9V,EAAcwF,GACxCuQ,EAAuB/V,EAAcwF,IAf3C,SAAyBnG,GACvB,IAAImN,EAAOnN,EAAQ+D,wBACfI,EAASpB,EAAMoK,EAAK7I,OAAStE,EAAQqE,aAAe,EACpDD,EAASrB,EAAMoK,EAAK3I,QAAUxE,EAAQuE,cAAgB,EAC1D,OAAkB,IAAXJ,GAA2B,IAAXC,CACzB,CAU4DuS,CAAgBxQ,GACtEJ,EAAkBF,EAAmBM,GACrCgH,EAAOpJ,EAAsByS,EAAyBE,EAAsBjN,GAC5EyB,EAAS,CACXc,WAAY,EACZE,UAAW,GAET7C,EAAU,CACZ1E,EAAG,EACHE,EAAG,GAkBL,OAfI4R,IAA4BA,IAA4BhN,MACxB,SAA9B1J,EAAYoG,IAChBkG,GAAetG,MACbmF,GCnCgC9K,EDmCT+F,KClCdhG,EAAUC,IAAUO,EAAcP,GCJxC,CACL4L,YAFyChM,EDQbI,GCNR4L,WACpBE,UAAWlM,EAAQkM,WDGZH,GAAgB3L,IDoCnBO,EAAcwF,KAChBkD,EAAUtF,EAAsBoC,GAAc,IACtCxB,GAAKwB,EAAauH,WAC1BrE,EAAQxE,GAAKsB,EAAasH,WACjB1H,IACTsD,EAAQ1E,EAAIyH,GAAoBrG,KAI7B,CACLpB,EAAGwI,EAAK5O,KAAO2M,EAAOc,WAAa3C,EAAQ1E,EAC3CE,EAAGsI,EAAK/K,IAAM8I,EAAOgB,UAAY7C,EAAQxE,EACzCP,MAAO6I,EAAK7I,MACZE,OAAQ2I,EAAK3I,OAEjB,CGvDA,SAASoS,GAAMC,GACb,IAAItT,EAAM,IAAIoO,IACVmF,EAAU,IAAIC,IACdC,EAAS,GAKb,SAAS3F,EAAK4F,GACZH,EAAQI,IAAID,EAASlW,MACN,GAAG3B,OAAO6X,EAASxU,UAAY,GAAIwU,EAASnO,kBAAoB,IACtEvH,SAAQ,SAAU4V,GACzB,IAAKL,EAAQM,IAAID,GAAM,CACrB,IAAIE,EAAc9T,EAAI3F,IAAIuZ,GAEtBE,GACFhG,EAAKgG,EAET,CACF,IACAL,EAAO3E,KAAK4E,EACd,CAQA,OAzBAJ,EAAUtV,SAAQ,SAAU0V,GAC1B1T,EAAIiP,IAAIyE,EAASlW,KAAMkW,EACzB,IAiBAJ,EAAUtV,SAAQ,SAAU0V,GACrBH,EAAQM,IAAIH,EAASlW,OAExBsQ,EAAK4F,EAET,IACOD,CACT,CCvBA,IAAIM,GAAkB,CACpBnY,UAAW,SACX0X,UAAW,GACX1U,SAAU,YAGZ,SAASoV,KACP,IAAK,IAAI1B,EAAO2B,UAAUrG,OAAQsG,EAAO,IAAIpU,MAAMwS,GAAO6B,EAAO,EAAGA,EAAO7B,EAAM6B,IAC/ED,EAAKC,GAAQF,UAAUE,GAGzB,OAAQD,EAAKvE,MAAK,SAAUlT,GAC1B,QAASA,GAAoD,mBAAlCA,EAAQ+D,sBACrC,GACF,CAEO,SAAS4T,GAAgBC,QACL,IAArBA,IACFA,EAAmB,CAAC,GAGtB,IAAIC,EAAoBD,EACpBE,EAAwBD,EAAkBE,iBAC1CA,OAA6C,IAA1BD,EAAmC,GAAKA,EAC3DE,EAAyBH,EAAkBI,eAC3CA,OAA4C,IAA3BD,EAAoCV,GAAkBU,EAC3E,OAAO,SAAsBjZ,EAAWD,EAAQoD,QAC9B,IAAZA,IACFA,EAAU+V,GAGZ,ICxC6B/W,EAC3BgX,EDuCE9W,EAAQ,CACVjC,UAAW,SACXgZ,iBAAkB,GAClBjW,QAASzE,OAAOkE,OAAO,CAAC,EAAG2V,GAAiBW,GAC5C1Q,cAAe,CAAC,EAChBjG,SAAU,CACRvC,UAAWA,EACXD,OAAQA,GAEV4C,WAAY,CAAC,EACbD,OAAQ,CAAC,GAEP2W,EAAmB,GACnBC,GAAc,EACdrN,EAAW,CACb5J,MAAOA,EACPkX,WAAY,SAAoBC,GAC9B,IAAIrW,EAAsC,mBAArBqW,EAAkCA,EAAiBnX,EAAMc,SAAWqW,EACzFC,IACApX,EAAMc,QAAUzE,OAAOkE,OAAO,CAAC,EAAGsW,EAAgB7W,EAAMc,QAASA,GACjEd,EAAMiK,cAAgB,CACpBtM,UAAW0B,EAAU1B,GAAa6N,GAAkB7N,GAAaA,EAAU4Q,eAAiB/C,GAAkB7N,EAAU4Q,gBAAkB,GAC1I7Q,OAAQ8N,GAAkB9N,IAI5B,IElE4B+X,EAC9B4B,EFiEMN,EDhCG,SAAwBtB,GAErC,IAAIsB,EAAmBvB,GAAMC,GAE7B,OAAO/W,EAAeb,QAAO,SAAUC,EAAK+B,GAC1C,OAAO/B,EAAIE,OAAO+Y,EAAiBvR,QAAO,SAAUqQ,GAClD,OAAOA,EAAShW,QAAUA,CAC5B,IACF,GAAG,GACL,CCuB+ByX,EElEK7B,EFkEsB,GAAGzX,OAAO2Y,EAAkB3W,EAAMc,QAAQ2U,WEjE9F4B,EAAS5B,EAAU5X,QAAO,SAAUwZ,EAAQE,GAC9C,IAAIC,EAAWH,EAAOE,EAAQ5X,MAK9B,OAJA0X,EAAOE,EAAQ5X,MAAQ6X,EAAWnb,OAAOkE,OAAO,CAAC,EAAGiX,EAAUD,EAAS,CACrEzW,QAASzE,OAAOkE,OAAO,CAAC,EAAGiX,EAAS1W,QAASyW,EAAQzW,SACrD4I,KAAMrN,OAAOkE,OAAO,CAAC,EAAGiX,EAAS9N,KAAM6N,EAAQ7N,QAC5C6N,EACEF,CACT,GAAG,CAAC,GAEGhb,OAAO4D,KAAKoX,GAAQlV,KAAI,SAAUhG,GACvC,OAAOkb,EAAOlb,EAChB,MF4DM,OAJA6D,EAAM+W,iBAAmBA,EAAiBvR,QAAO,SAAUiS,GACzD,OAAOA,EAAE7X,OACX,IA+FFI,EAAM+W,iBAAiB5W,SAAQ,SAAUJ,GACvC,IAAIJ,EAAOI,EAAKJ,KACZ+X,EAAe3X,EAAKe,QACpBA,OAA2B,IAAjB4W,EAA0B,CAAC,EAAIA,EACzChX,EAASX,EAAKW,OAElB,GAAsB,mBAAXA,EAAuB,CAChC,IAAIiX,EAAYjX,EAAO,CACrBV,MAAOA,EACPL,KAAMA,EACNiK,SAAUA,EACV9I,QAASA,IAKXkW,EAAiB/F,KAAK0G,GAFT,WAAmB,EAGlC,CACF,IA/GS/N,EAASQ,QAClB,EAMAwN,YAAa,WACX,IAAIX,EAAJ,CAIA,IAAIY,EAAkB7X,EAAME,SACxBvC,EAAYka,EAAgBla,UAC5BD,EAASma,EAAgBna,OAG7B,GAAKyY,GAAiBxY,EAAWD,GAAjC,CAKAsC,EAAMwG,MAAQ,CACZ7I,UAAWwX,GAAiBxX,EAAWqH,EAAgBtH,GAAoC,UAA3BsC,EAAMc,QAAQC,UAC9ErD,OAAQiG,EAAcjG,IAOxBsC,EAAM0R,OAAQ,EACd1R,EAAMjC,UAAYiC,EAAMc,QAAQ/C,UAKhCiC,EAAM+W,iBAAiB5W,SAAQ,SAAU0V,GACvC,OAAO7V,EAAMmG,cAAc0P,EAASlW,MAAQtD,OAAOkE,OAAO,CAAC,EAAGsV,EAASnM,KACzE,IAEA,IAAK,IAAIoO,EAAQ,EAAGA,EAAQ9X,EAAM+W,iBAAiBhH,OAAQ+H,IACzD,IAAoB,IAAhB9X,EAAM0R,MAAV,CAMA,IAAIqG,EAAwB/X,EAAM+W,iBAAiBe,GAC/ChY,EAAKiY,EAAsBjY,GAC3BkY,EAAyBD,EAAsBjX,QAC/CoM,OAAsC,IAA3B8K,EAAoC,CAAC,EAAIA,EACpDrY,EAAOoY,EAAsBpY,KAEf,mBAAPG,IACTE,EAAQF,EAAG,CACTE,MAAOA,EACPc,QAASoM,EACTvN,KAAMA,EACNiK,SAAUA,KACN5J,EAdR,MAHEA,EAAM0R,OAAQ,EACdoG,GAAS,CAzBb,CATA,CAqDF,EAGA1N,QC1I2BtK,ED0IV,WACf,OAAO,IAAImY,SAAQ,SAAUC,GAC3BtO,EAASgO,cACTM,EAAQlY,EACV,GACF,EC7IG,WAUL,OATK8W,IACHA,EAAU,IAAImB,SAAQ,SAAUC,GAC9BD,QAAQC,UAAUC,MAAK,WACrBrB,OAAUsB,EACVF,EAAQpY,IACV,GACF,KAGKgX,CACT,GDmIIuB,QAAS,WACPjB,IACAH,GAAc,CAChB,GAGF,IAAKd,GAAiBxY,EAAWD,GAC/B,OAAOkM,EAmCT,SAASwN,IACPJ,EAAiB7W,SAAQ,SAAUL,GACjC,OAAOA,GACT,IACAkX,EAAmB,EACrB,CAEA,OAvCApN,EAASsN,WAAWpW,GAASqX,MAAK,SAAUnY,IACrCiX,GAAenW,EAAQwX,eAC1BxX,EAAQwX,cAActY,EAE1B,IAmCO4J,CACT,CACF,CACO,IAAI2O,GAA4BhC,KGzLnC,GAA4BA,GAAgB,CAC9CI,iBAFqB,CAAC6B,GAAgB,GAAe,GAAe,EAAa,GAAQ,GAAM,GAAiB,EAAO,MCJrH,GAA4BjC,GAAgB,CAC9CI,iBAFqB,CAAC6B,GAAgB,GAAe,GAAe,KCatE,MAAMC,GAAa,IAAIlI,IACjBmI,GAAO,CACX,GAAAtH,CAAIxS,EAASzC,EAAKyN,GACX6O,GAAWzC,IAAIpX,IAClB6Z,GAAWrH,IAAIxS,EAAS,IAAI2R,KAE9B,MAAMoI,EAAcF,GAAWjc,IAAIoC,GAI9B+Z,EAAY3C,IAAI7Z,IAA6B,IAArBwc,EAAYC,KAKzCD,EAAYvH,IAAIjV,EAAKyN,GAHnBiP,QAAQC,MAAM,+EAA+E7W,MAAM8W,KAAKJ,EAAY1Y,QAAQ,MAIhI,EACAzD,IAAG,CAACoC,EAASzC,IACPsc,GAAWzC,IAAIpX,IACV6Z,GAAWjc,IAAIoC,GAASpC,IAAIL,IAE9B,KAET,MAAA6c,CAAOpa,EAASzC,GACd,IAAKsc,GAAWzC,IAAIpX,GAClB,OAEF,MAAM+Z,EAAcF,GAAWjc,IAAIoC,GACnC+Z,EAAYM,OAAO9c,GAGM,IAArBwc,EAAYC,MACdH,GAAWQ,OAAOra,EAEtB,GAYIsa,GAAiB,gBAOjBC,GAAgBC,IAChBA,GAAYna,OAAOoa,KAAOpa,OAAOoa,IAAIC,SAEvCF,EAAWA,EAAS5O,QAAQ,iBAAiB,CAAC+O,EAAOC,IAAO,IAAIH,IAAIC,OAAOE,QAEtEJ,GA4CHK,GAAuB7a,IAC3BA,EAAQ8a,cAAc,IAAIC,MAAMT,IAAgB,EAE5C,GAAYU,MACXA,GAA4B,iBAAXA,UAGO,IAAlBA,EAAOC,SAChBD,EAASA,EAAO,SAEgB,IAApBA,EAAOE,UAEjBC,GAAaH,GAEb,GAAUA,GACLA,EAAOC,OAASD,EAAO,GAAKA,EAEf,iBAAXA,GAAuBA,EAAO7J,OAAS,EACzCrL,SAAS+C,cAAc0R,GAAcS,IAEvC,KAEHI,GAAYpb,IAChB,IAAK,GAAUA,IAAgD,IAApCA,EAAQqb,iBAAiBlK,OAClD,OAAO,EAET,MAAMmK,EAAgF,YAA7D5V,iBAAiB1F,GAASub,iBAAiB,cAE9DC,EAAgBxb,EAAQyb,QAAQ,uBACtC,IAAKD,EACH,OAAOF,EAET,GAAIE,IAAkBxb,EAAS,CAC7B,MAAM0b,EAAU1b,EAAQyb,QAAQ,WAChC,GAAIC,GAAWA,EAAQlW,aAAegW,EACpC,OAAO,EAET,GAAgB,OAAZE,EACF,OAAO,CAEX,CACA,OAAOJ,CAAgB,EAEnBK,GAAa3b,IACZA,GAAWA,EAAQkb,WAAaU,KAAKC,gBAGtC7b,EAAQ8b,UAAU7W,SAAS,mBAGC,IAArBjF,EAAQ+b,SACV/b,EAAQ+b,SAEV/b,EAAQgc,aAAa,aAAoD,UAArChc,EAAQic,aAAa,aAE5DC,GAAiBlc,IACrB,IAAK8F,SAASC,gBAAgBoW,aAC5B,OAAO,KAIT,GAAmC,mBAAxBnc,EAAQqF,YAA4B,CAC7C,MAAM+W,EAAOpc,EAAQqF,cACrB,OAAO+W,aAAgBtb,WAAasb,EAAO,IAC7C,CACA,OAAIpc,aAAmBc,WACdd,EAIJA,EAAQwF,WAGN0W,GAAelc,EAAQwF,YAFrB,IAEgC,EAErC6W,GAAO,OAUPC,GAAStc,IACbA,EAAQuE,YAAY,EAGhBgY,GAAY,IACZlc,OAAOmc,SAAW1W,SAAS6G,KAAKqP,aAAa,qBACxC3b,OAAOmc,OAET,KAEHC,GAA4B,GAgB5BC,GAAQ,IAAuC,QAAjC5W,SAASC,gBAAgB4W,IACvCC,GAAqBC,IAhBAC,QAiBN,KACjB,MAAMC,EAAIR,KAEV,GAAIQ,EAAG,CACL,MAAMhc,EAAO8b,EAAOG,KACdC,EAAqBF,EAAE7b,GAAGH,GAChCgc,EAAE7b,GAAGH,GAAQ8b,EAAOK,gBACpBH,EAAE7b,GAAGH,GAAMoc,YAAcN,EACzBE,EAAE7b,GAAGH,GAAMqc,WAAa,KACtBL,EAAE7b,GAAGH,GAAQkc,EACNJ,EAAOK,gBAElB,GA5B0B,YAAxBpX,SAASuX,YAENZ,GAA0BtL,QAC7BrL,SAASyF,iBAAiB,oBAAoB,KAC5C,IAAK,MAAMuR,KAAYL,GACrBK,GACF,IAGJL,GAA0BpK,KAAKyK,IAE/BA,GAkBA,EAEEQ,GAAU,CAACC,EAAkB9F,EAAO,GAAI+F,EAAeD,IACxB,mBAArBA,EAAkCA,KAAoB9F,GAAQ+F,EAExEC,GAAyB,CAACX,EAAUY,EAAmBC,GAAoB,KAC/E,IAAKA,EAEH,YADAL,GAAQR,GAGV,MACMc,EAhKiC5d,KACvC,IAAKA,EACH,OAAO,EAIT,IAAI,mBACF6d,EAAkB,gBAClBC,GACEzd,OAAOqF,iBAAiB1F,GAC5B,MAAM+d,EAA0BC,OAAOC,WAAWJ,GAC5CK,EAAuBF,OAAOC,WAAWH,GAG/C,OAAKC,GAA4BG,GAKjCL,EAAqBA,EAAmBlb,MAAM,KAAK,GACnDmb,EAAkBA,EAAgBnb,MAAM,KAAK,GAtDf,KAuDtBqb,OAAOC,WAAWJ,GAAsBG,OAAOC,WAAWH,KANzD,CAMoG,EA2IpFK,CAAiCT,GADlC,EAExB,IAAIU,GAAS,EACb,MAAMC,EAAU,EACdrR,aAEIA,IAAW0Q,IAGfU,GAAS,EACTV,EAAkBjS,oBAAoB6O,GAAgB+D,GACtDf,GAAQR,GAAS,EAEnBY,EAAkBnS,iBAAiB+O,GAAgB+D,GACnDC,YAAW,KACJF,GACHvD,GAAqB6C,EACvB,GACCE,EAAiB,EAYhBW,GAAuB,CAAC1R,EAAM2R,EAAeC,EAAeC,KAChE,MAAMC,EAAa9R,EAAKsE,OACxB,IAAI+H,EAAQrM,EAAKjH,QAAQ4Y,GAIzB,OAAe,IAAXtF,GACMuF,GAAiBC,EAAiB7R,EAAK8R,EAAa,GAAK9R,EAAK,IAExEqM,GAASuF,EAAgB,GAAK,EAC1BC,IACFxF,GAASA,EAAQyF,GAAcA,GAE1B9R,EAAKjK,KAAKC,IAAI,EAAGD,KAAKE,IAAIoW,EAAOyF,EAAa,KAAI,EAerDC,GAAiB,qBACjBC,GAAiB,OACjBC,GAAgB,SAChBC,GAAgB,CAAC,EACvB,IAAIC,GAAW,EACf,MAAMC,GAAe,CACnBC,WAAY,YACZC,WAAY,YAERC,GAAe,IAAIrI,IAAI,CAAC,QAAS,WAAY,UAAW,YAAa,cAAe,aAAc,iBAAkB,YAAa,WAAY,YAAa,cAAe,YAAa,UAAW,WAAY,QAAS,oBAAqB,aAAc,YAAa,WAAY,cAAe,cAAe,cAAe,YAAa,eAAgB,gBAAiB,eAAgB,gBAAiB,aAAc,QAAS,OAAQ,SAAU,QAAS,SAAU,SAAU,UAAW,WAAY,OAAQ,SAAU,eAAgB,SAAU,OAAQ,mBAAoB,mBAAoB,QAAS,QAAS,WAM/lB,SAASsI,GAAarf,EAASsf,GAC7B,OAAOA,GAAO,GAAGA,MAAQN,QAAgBhf,EAAQgf,UAAYA,IAC/D,CACA,SAASO,GAAiBvf,GACxB,MAAMsf,EAAMD,GAAarf,GAGzB,OAFAA,EAAQgf,SAAWM,EACnBP,GAAcO,GAAOP,GAAcO,IAAQ,CAAC,EACrCP,GAAcO,EACvB,CAiCA,SAASE,GAAYC,EAAQC,EAAUC,EAAqB,MAC1D,OAAOliB,OAAOmiB,OAAOH,GAAQ7M,MAAKiN,GAASA,EAAMH,WAAaA,GAAYG,EAAMF,qBAAuBA,GACzG,CACA,SAASG,GAAoBC,EAAmB1B,EAAS2B,GACvD,MAAMC,EAAiC,iBAAZ5B,EAErBqB,EAAWO,EAAcD,EAAqB3B,GAAW2B,EAC/D,IAAIE,EAAYC,GAAaJ,GAI7B,OAHKX,GAAahI,IAAI8I,KACpBA,EAAYH,GAEP,CAACE,EAAaP,EAAUQ,EACjC,CACA,SAASE,GAAWpgB,EAAS+f,EAAmB1B,EAAS2B,EAAoBK,GAC3E,GAAiC,iBAAtBN,IAAmC/f,EAC5C,OAEF,IAAKigB,EAAaP,EAAUQ,GAAaJ,GAAoBC,EAAmB1B,EAAS2B,GAIzF,GAAID,KAAqBd,GAAc,CACrC,MAAMqB,EAAepf,GACZ,SAAU2e,GACf,IAAKA,EAAMU,eAAiBV,EAAMU,gBAAkBV,EAAMW,iBAAmBX,EAAMW,eAAevb,SAAS4a,EAAMU,eAC/G,OAAOrf,EAAGjD,KAAKwiB,KAAMZ,EAEzB,EAEFH,EAAWY,EAAaZ,EAC1B,CACA,MAAMD,EAASF,GAAiBvf,GAC1B0gB,EAAWjB,EAAOS,KAAeT,EAAOS,GAAa,CAAC,GACtDS,EAAmBnB,GAAYkB,EAAUhB,EAAUO,EAAc5B,EAAU,MACjF,GAAIsC,EAEF,YADAA,EAAiBN,OAASM,EAAiBN,QAAUA,GAGvD,MAAMf,EAAMD,GAAaK,EAAUK,EAAkBnU,QAAQgT,GAAgB,KACvE1d,EAAK+e,EA5Db,SAAoCjgB,EAASwa,EAAUtZ,GACrD,OAAO,SAASmd,EAAQwB,GACtB,MAAMe,EAAc5gB,EAAQ6gB,iBAAiBrG,GAC7C,IAAK,IAAI,OACPxN,GACE6S,EAAO7S,GAAUA,IAAWyT,KAAMzT,EAASA,EAAOxH,WACpD,IAAK,MAAMsb,KAAcF,EACvB,GAAIE,IAAe9T,EASnB,OANA+T,GAAWlB,EAAO,CAChBW,eAAgBxT,IAEdqR,EAAQgC,QACVW,GAAaC,IAAIjhB,EAAS6f,EAAMqB,KAAM1G,EAAUtZ,GAE3CA,EAAGigB,MAAMnU,EAAQ,CAAC6S,GAG/B,CACF,CAwC2BuB,CAA2BphB,EAASqe,EAASqB,GAvExE,SAA0B1f,EAASkB,GACjC,OAAO,SAASmd,EAAQwB,GAOtB,OANAkB,GAAWlB,EAAO,CAChBW,eAAgBxgB,IAEdqe,EAAQgC,QACVW,GAAaC,IAAIjhB,EAAS6f,EAAMqB,KAAMhgB,GAEjCA,EAAGigB,MAAMnhB,EAAS,CAAC6f,GAC5B,CACF,CA6DoFwB,CAAiBrhB,EAAS0f,GAC5Gxe,EAAGye,mBAAqBM,EAAc5B,EAAU,KAChDnd,EAAGwe,SAAWA,EACdxe,EAAGmf,OAASA,EACZnf,EAAG8d,SAAWM,EACdoB,EAASpB,GAAOpe,EAChBlB,EAAQuL,iBAAiB2U,EAAWhf,EAAI+e,EAC1C,CACA,SAASqB,GAActhB,EAASyf,EAAQS,EAAW7B,EAASsB,GAC1D,MAAMze,EAAKse,GAAYC,EAAOS,GAAY7B,EAASsB,GAC9Cze,IAGLlB,EAAQyL,oBAAoByU,EAAWhf,EAAIqgB,QAAQ5B,WAC5CF,EAAOS,GAAWhf,EAAG8d,UAC9B,CACA,SAASwC,GAAyBxhB,EAASyf,EAAQS,EAAWuB,GAC5D,MAAMC,EAAoBjC,EAAOS,IAAc,CAAC,EAChD,IAAK,MAAOyB,EAAY9B,KAAUpiB,OAAOmkB,QAAQF,GAC3CC,EAAWE,SAASJ,IACtBH,GAActhB,EAASyf,EAAQS,EAAWL,EAAMH,SAAUG,EAAMF,mBAGtE,CACA,SAASQ,GAAaN,GAGpB,OADAA,EAAQA,EAAMjU,QAAQiT,GAAgB,IAC/BI,GAAaY,IAAUA,CAChC,CACA,MAAMmB,GAAe,CACnB,EAAAc,CAAG9hB,EAAS6f,EAAOxB,EAAS2B,GAC1BI,GAAWpgB,EAAS6f,EAAOxB,EAAS2B,GAAoB,EAC1D,EACA,GAAA+B,CAAI/hB,EAAS6f,EAAOxB,EAAS2B,GAC3BI,GAAWpgB,EAAS6f,EAAOxB,EAAS2B,GAAoB,EAC1D,EACA,GAAAiB,CAAIjhB,EAAS+f,EAAmB1B,EAAS2B,GACvC,GAAiC,iBAAtBD,IAAmC/f,EAC5C,OAEF,MAAOigB,EAAaP,EAAUQ,GAAaJ,GAAoBC,EAAmB1B,EAAS2B,GACrFgC,EAAc9B,IAAcH,EAC5BN,EAASF,GAAiBvf,GAC1B0hB,EAAoBjC,EAAOS,IAAc,CAAC,EAC1C+B,EAAclC,EAAkBmC,WAAW,KACjD,QAAwB,IAAbxC,EAAX,CAQA,GAAIuC,EACF,IAAK,MAAME,KAAgB1kB,OAAO4D,KAAKoe,GACrC+B,GAAyBxhB,EAASyf,EAAQ0C,EAAcpC,EAAkBlN,MAAM,IAGpF,IAAK,MAAOuP,EAAavC,KAAUpiB,OAAOmkB,QAAQF,GAAoB,CACpE,MAAMC,EAAaS,EAAYxW,QAAQkT,GAAe,IACjDkD,IAAejC,EAAkB8B,SAASF,IAC7CL,GAActhB,EAASyf,EAAQS,EAAWL,EAAMH,SAAUG,EAAMF,mBAEpE,CAXA,KAPA,CAEE,IAAKliB,OAAO4D,KAAKqgB,GAAmBvQ,OAClC,OAEFmQ,GAActhB,EAASyf,EAAQS,EAAWR,EAAUO,EAAc5B,EAAU,KAE9E,CAYF,EACA,OAAAgE,CAAQriB,EAAS6f,EAAOpI,GACtB,GAAqB,iBAAVoI,IAAuB7f,EAChC,OAAO,KAET,MAAM+c,EAAIR,KAGV,IAAI+F,EAAc,KACdC,GAAU,EACVC,GAAiB,EACjBC,GAAmB,EAJH5C,IADFM,GAAaN,IAMZ9C,IACjBuF,EAAcvF,EAAEhC,MAAM8E,EAAOpI,GAC7BsF,EAAE/c,GAASqiB,QAAQC,GACnBC,GAAWD,EAAYI,uBACvBF,GAAkBF,EAAYK,gCAC9BF,EAAmBH,EAAYM,sBAEjC,MAAMC,EAAM9B,GAAW,IAAIhG,MAAM8E,EAAO,CACtC0C,UACAO,YAAY,IACVrL,GAUJ,OATIgL,GACFI,EAAIE,iBAEFP,GACFxiB,EAAQ8a,cAAc+H,GAEpBA,EAAIJ,kBAAoBH,GAC1BA,EAAYS,iBAEPF,CACT,GAEF,SAAS9B,GAAWljB,EAAKmlB,EAAO,CAAC,GAC/B,IAAK,MAAOzlB,EAAKa,KAAUX,OAAOmkB,QAAQoB,GACxC,IACEnlB,EAAIN,GAAOa,CACb,CAAE,MAAO6kB,GACPxlB,OAAOC,eAAeG,EAAKN,EAAK,CAC9B2lB,cAAc,EACdtlB,IAAG,IACMQ,GAGb,CAEF,OAAOP,CACT,CASA,SAASslB,GAAc/kB,GACrB,GAAc,SAAVA,EACF,OAAO,EAET,GAAc,UAAVA,EACF,OAAO,EAET,GAAIA,IAAU4f,OAAO5f,GAAOkC,WAC1B,OAAO0d,OAAO5f,GAEhB,GAAc,KAAVA,GAA0B,SAAVA,EAClB,OAAO,KAET,GAAqB,iBAAVA,EACT,OAAOA,EAET,IACE,OAAOglB,KAAKC,MAAMC,mBAAmBllB,GACvC,CAAE,MAAO6kB,GACP,OAAO7kB,CACT,CACF,CACA,SAASmlB,GAAiBhmB,GACxB,OAAOA,EAAIqO,QAAQ,UAAU4X,GAAO,IAAIA,EAAItjB,iBAC9C,CACA,MAAMujB,GAAc,CAClB,gBAAAC,CAAiB1jB,EAASzC,EAAKa,GAC7B4B,EAAQ6B,aAAa,WAAW0hB,GAAiBhmB,KAAQa,EAC3D,EACA,mBAAAulB,CAAoB3jB,EAASzC,GAC3ByC,EAAQ4B,gBAAgB,WAAW2hB,GAAiBhmB,KACtD,EACA,iBAAAqmB,CAAkB5jB,GAChB,IAAKA,EACH,MAAO,CAAC,EAEV,MAAM0B,EAAa,CAAC,EACdmiB,EAASpmB,OAAO4D,KAAKrB,EAAQ8jB,SAASld,QAAOrJ,GAAOA,EAAI2kB,WAAW,QAAU3kB,EAAI2kB,WAAW,cAClG,IAAK,MAAM3kB,KAAOsmB,EAAQ,CACxB,IAAIE,EAAUxmB,EAAIqO,QAAQ,MAAO,IACjCmY,EAAUA,EAAQC,OAAO,GAAG9jB,cAAgB6jB,EAAQlR,MAAM,EAAGkR,EAAQ5S,QACrEzP,EAAWqiB,GAAWZ,GAAcnjB,EAAQ8jB,QAAQvmB,GACtD,CACA,OAAOmE,CACT,EACAuiB,iBAAgB,CAACjkB,EAASzC,IACjB4lB,GAAcnjB,EAAQic,aAAa,WAAWsH,GAAiBhmB,QAgB1E,MAAM2mB,GAEJ,kBAAWC,GACT,MAAO,CAAC,CACV,CACA,sBAAWC,GACT,MAAO,CAAC,CACV,CACA,eAAWpH,GACT,MAAM,IAAIqH,MAAM,sEAClB,CACA,UAAAC,CAAWC,GAIT,OAHAA,EAAS9D,KAAK+D,gBAAgBD,GAC9BA,EAAS9D,KAAKgE,kBAAkBF,GAChC9D,KAAKiE,iBAAiBH,GACfA,CACT,CACA,iBAAAE,CAAkBF,GAChB,OAAOA,CACT,CACA,eAAAC,CAAgBD,EAAQvkB,GACtB,MAAM2kB,EAAa,GAAU3kB,GAAWyjB,GAAYQ,iBAAiBjkB,EAAS,UAAY,CAAC,EAE3F,MAAO,IACFygB,KAAKmE,YAAYT,WACM,iBAAfQ,EAA0BA,EAAa,CAAC,KAC/C,GAAU3kB,GAAWyjB,GAAYG,kBAAkB5jB,GAAW,CAAC,KAC7C,iBAAXukB,EAAsBA,EAAS,CAAC,EAE/C,CACA,gBAAAG,CAAiBH,EAAQM,EAAcpE,KAAKmE,YAAYR,aACtD,IAAK,MAAO7hB,EAAUuiB,KAAkBrnB,OAAOmkB,QAAQiD,GAAc,CACnE,MAAMzmB,EAAQmmB,EAAOhiB,GACfwiB,EAAY,GAAU3mB,GAAS,UAjiBrC4c,OADSA,EAkiB+C5c,GAhiBnD,GAAG4c,IAELvd,OAAOM,UAAUuC,SAASrC,KAAK+c,GAAQL,MAAM,eAAe,GAAGza,cA+hBlE,IAAK,IAAI8kB,OAAOF,GAAehhB,KAAKihB,GAClC,MAAM,IAAIE,UAAU,GAAGxE,KAAKmE,YAAY5H,KAAKkI,0BAA0B3iB,qBAA4BwiB,yBAAiCD,MAExI,CAtiBW9J,KAuiBb,EAqBF,MAAMmK,WAAsBjB,GAC1B,WAAAU,CAAY5kB,EAASukB,GACnBa,SACAplB,EAAUmb,GAAWnb,MAIrBygB,KAAK4E,SAAWrlB,EAChBygB,KAAK6E,QAAU7E,KAAK6D,WAAWC,GAC/BzK,GAAKtH,IAAIiO,KAAK4E,SAAU5E,KAAKmE,YAAYW,SAAU9E,MACrD,CAGA,OAAA+E,GACE1L,GAAKM,OAAOqG,KAAK4E,SAAU5E,KAAKmE,YAAYW,UAC5CvE,GAAaC,IAAIR,KAAK4E,SAAU5E,KAAKmE,YAAYa,WACjD,IAAK,MAAMC,KAAgBjoB,OAAOkoB,oBAAoBlF,MACpDA,KAAKiF,GAAgB,IAEzB,CACA,cAAAE,CAAe9I,EAAU9c,EAAS6lB,GAAa,GAC7CpI,GAAuBX,EAAU9c,EAAS6lB,EAC5C,CACA,UAAAvB,CAAWC,GAIT,OAHAA,EAAS9D,KAAK+D,gBAAgBD,EAAQ9D,KAAK4E,UAC3Cd,EAAS9D,KAAKgE,kBAAkBF,GAChC9D,KAAKiE,iBAAiBH,GACfA,CACT,CAGA,kBAAOuB,CAAY9lB,GACjB,OAAO8Z,GAAKlc,IAAIud,GAAWnb,GAAUygB,KAAK8E,SAC5C,CACA,0BAAOQ,CAAoB/lB,EAASukB,EAAS,CAAC,GAC5C,OAAO9D,KAAKqF,YAAY9lB,IAAY,IAAIygB,KAAKzgB,EAA2B,iBAAXukB,EAAsBA,EAAS,KAC9F,CACA,kBAAWyB,GACT,MA5CY,OA6Cd,CACA,mBAAWT,GACT,MAAO,MAAM9E,KAAKzD,MACpB,CACA,oBAAWyI,GACT,MAAO,IAAIhF,KAAK8E,UAClB,CACA,gBAAOU,CAAUllB,GACf,MAAO,GAAGA,IAAO0f,KAAKgF,WACxB,EAUF,MAAMS,GAAclmB,IAClB,IAAIwa,EAAWxa,EAAQic,aAAa,kBACpC,IAAKzB,GAAyB,MAAbA,EAAkB,CACjC,IAAI2L,EAAgBnmB,EAAQic,aAAa,QAMzC,IAAKkK,IAAkBA,EAActE,SAAS,OAASsE,EAAcjE,WAAW,KAC9E,OAAO,KAILiE,EAActE,SAAS,OAASsE,EAAcjE,WAAW,OAC3DiE,EAAgB,IAAIA,EAAcxjB,MAAM,KAAK,MAE/C6X,EAAW2L,GAAmC,MAAlBA,EAAwB5L,GAAc4L,EAAcC,QAAU,IAC5F,CACA,OAAO5L,CAAQ,EAEX6L,GAAiB,CACrBzT,KAAI,CAAC4H,EAAUxa,EAAU8F,SAASC,kBACzB,GAAG3G,UAAUsB,QAAQ3C,UAAU8iB,iBAAiB5iB,KAAK+B,EAASwa,IAEvE8L,QAAO,CAAC9L,EAAUxa,EAAU8F,SAASC,kBAC5BrF,QAAQ3C,UAAU8K,cAAc5K,KAAK+B,EAASwa,GAEvD+L,SAAQ,CAACvmB,EAASwa,IACT,GAAGpb,UAAUY,EAAQumB,UAAU3f,QAAOzB,GAASA,EAAMqhB,QAAQhM,KAEtE,OAAAiM,CAAQzmB,EAASwa,GACf,MAAMiM,EAAU,GAChB,IAAIC,EAAW1mB,EAAQwF,WAAWiW,QAAQjB,GAC1C,KAAOkM,GACLD,EAAQpU,KAAKqU,GACbA,EAAWA,EAASlhB,WAAWiW,QAAQjB,GAEzC,OAAOiM,CACT,EACA,IAAAE,CAAK3mB,EAASwa,GACZ,IAAIoM,EAAW5mB,EAAQ6mB,uBACvB,KAAOD,GAAU,CACf,GAAIA,EAASJ,QAAQhM,GACnB,MAAO,CAACoM,GAEVA,EAAWA,EAASC,sBACtB,CACA,MAAO,EACT,EAEA,IAAAvhB,CAAKtF,EAASwa,GACZ,IAAIlV,EAAOtF,EAAQ8mB,mBACnB,KAAOxhB,GAAM,CACX,GAAIA,EAAKkhB,QAAQhM,GACf,MAAO,CAAClV,GAEVA,EAAOA,EAAKwhB,kBACd,CACA,MAAO,EACT,EACA,iBAAAC,CAAkB/mB,GAChB,MAAMgnB,EAAa,CAAC,IAAK,SAAU,QAAS,WAAY,SAAU,UAAW,aAAc,4BAA4BzjB,KAAIiX,GAAY,GAAGA,2BAAiC7W,KAAK,KAChL,OAAO8c,KAAK7N,KAAKoU,EAAYhnB,GAAS4G,QAAOqgB,IAAOtL,GAAWsL,IAAO7L,GAAU6L,IAClF,EACA,sBAAAC,CAAuBlnB,GACrB,MAAMwa,EAAW0L,GAAYlmB,GAC7B,OAAIwa,GACK6L,GAAeC,QAAQ9L,GAAYA,EAErC,IACT,EACA,sBAAA2M,CAAuBnnB,GACrB,MAAMwa,EAAW0L,GAAYlmB,GAC7B,OAAOwa,EAAW6L,GAAeC,QAAQ9L,GAAY,IACvD,EACA,+BAAA4M,CAAgCpnB,GAC9B,MAAMwa,EAAW0L,GAAYlmB,GAC7B,OAAOwa,EAAW6L,GAAezT,KAAK4H,GAAY,EACpD,GAUI6M,GAAuB,CAACC,EAAWC,EAAS,UAChD,MAAMC,EAAa,gBAAgBF,EAAU7B,YACvC1kB,EAAOumB,EAAUtK,KACvBgE,GAAac,GAAGhc,SAAU0hB,EAAY,qBAAqBzmB,OAAU,SAAU8e,GAI7E,GAHI,CAAC,IAAK,QAAQgC,SAASpB,KAAKgH,UAC9B5H,EAAMkD,iBAEJpH,GAAW8E,MACb,OAEF,MAAMzT,EAASqZ,GAAec,uBAAuB1G,OAASA,KAAKhF,QAAQ,IAAI1a,KAC9DumB,EAAUvB,oBAAoB/Y,GAGtCua,IACX,GAAE,EAiBEG,GAAc,YACdC,GAAc,QAAQD,KACtBE,GAAe,SAASF,KAQ9B,MAAMG,WAAc1C,GAElB,eAAWnI,GACT,MAfW,OAgBb,CAGA,KAAA8K,GAEE,GADmB9G,GAAaqB,QAAQ5B,KAAK4E,SAAUsC,IACxClF,iBACb,OAEFhC,KAAK4E,SAASvJ,UAAU1B,OAlBF,QAmBtB,MAAMyL,EAAapF,KAAK4E,SAASvJ,UAAU7W,SApBrB,QAqBtBwb,KAAKmF,gBAAe,IAAMnF,KAAKsH,mBAAmBtH,KAAK4E,SAAUQ,EACnE,CAGA,eAAAkC,GACEtH,KAAK4E,SAASjL,SACd4G,GAAaqB,QAAQ5B,KAAK4E,SAAUuC,IACpCnH,KAAK+E,SACP,CAGA,sBAAOtI,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAO+c,GAAM9B,oBAAoBtF,MACvC,GAAsB,iBAAX8D,EAAX,CAGA,QAAqB/K,IAAjB1O,EAAKyZ,IAAyBA,EAAOrC,WAAW,MAAmB,gBAAXqC,EAC1D,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,GAAQ9D,KAJb,CAKF,GACF,EAOF4G,GAAqBQ,GAAO,SAM5BjL,GAAmBiL,IAcnB,MAKMI,GAAyB,4BAO/B,MAAMC,WAAe/C,GAEnB,eAAWnI,GACT,MAfW,QAgBb,CAGA,MAAAmL,GAEE1H,KAAK4E,SAASxjB,aAAa,eAAgB4e,KAAK4E,SAASvJ,UAAUqM,OAjB3C,UAkB1B,CAGA,sBAAOjL,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAOod,GAAOnC,oBAAoBtF,MACzB,WAAX8D,GACFzZ,EAAKyZ,IAET,GACF,EAOFvD,GAAac,GAAGhc,SAjCe,2BAiCmBmiB,IAAwBpI,IACxEA,EAAMkD,iBACN,MAAMqF,EAASvI,EAAM7S,OAAOyO,QAAQwM,IACvBC,GAAOnC,oBAAoBqC,GACnCD,QAAQ,IAOfvL,GAAmBsL,IAcnB,MACMG,GAAc,YACdC,GAAmB,aAAaD,KAChCE,GAAkB,YAAYF,KAC9BG,GAAiB,WAAWH,KAC5BI,GAAoB,cAAcJ,KAClCK,GAAkB,YAAYL,KAK9BM,GAAY,CAChBC,YAAa,KACbC,aAAc,KACdC,cAAe,MAEXC,GAAgB,CACpBH,YAAa,kBACbC,aAAc,kBACdC,cAAe,mBAOjB,MAAME,WAAc9E,GAClB,WAAAU,CAAY5kB,EAASukB,GACnBa,QACA3E,KAAK4E,SAAWrlB,EACXA,GAAYgpB,GAAMC,gBAGvBxI,KAAK6E,QAAU7E,KAAK6D,WAAWC,GAC/B9D,KAAKyI,QAAU,EACfzI,KAAK0I,sBAAwB5H,QAAQlhB,OAAO+oB,cAC5C3I,KAAK4I,cACP,CAGA,kBAAWlF,GACT,OAAOwE,EACT,CACA,sBAAWvE,GACT,OAAO2E,EACT,CACA,eAAW/L,GACT,MA/CW,OAgDb,CAGA,OAAAwI,GACExE,GAAaC,IAAIR,KAAK4E,SAAUgD,GAClC,CAGA,MAAAiB,CAAOzJ,GACAY,KAAK0I,sBAIN1I,KAAK8I,wBAAwB1J,KAC/BY,KAAKyI,QAAUrJ,EAAM2J,SAJrB/I,KAAKyI,QAAUrJ,EAAM4J,QAAQ,GAAGD,OAMpC,CACA,IAAAE,CAAK7J,GACCY,KAAK8I,wBAAwB1J,KAC/BY,KAAKyI,QAAUrJ,EAAM2J,QAAU/I,KAAKyI,SAEtCzI,KAAKkJ,eACLrM,GAAQmD,KAAK6E,QAAQsD,YACvB,CACA,KAAAgB,CAAM/J,GACJY,KAAKyI,QAAUrJ,EAAM4J,SAAW5J,EAAM4J,QAAQtY,OAAS,EAAI,EAAI0O,EAAM4J,QAAQ,GAAGD,QAAU/I,KAAKyI,OACjG,CACA,YAAAS,GACE,MAAME,EAAYjnB,KAAKoC,IAAIyb,KAAKyI,SAChC,GAAIW,GAnEgB,GAoElB,OAEF,MAAM9b,EAAY8b,EAAYpJ,KAAKyI,QACnCzI,KAAKyI,QAAU,EACVnb,GAGLuP,GAAQvP,EAAY,EAAI0S,KAAK6E,QAAQwD,cAAgBrI,KAAK6E,QAAQuD,aACpE,CACA,WAAAQ,GACM5I,KAAK0I,uBACPnI,GAAac,GAAGrB,KAAK4E,SAAUoD,IAAmB5I,GAASY,KAAK6I,OAAOzJ,KACvEmB,GAAac,GAAGrB,KAAK4E,SAAUqD,IAAiB7I,GAASY,KAAKiJ,KAAK7J,KACnEY,KAAK4E,SAASvJ,UAAU5E,IAlFG,mBAoF3B8J,GAAac,GAAGrB,KAAK4E,SAAUiD,IAAkBzI,GAASY,KAAK6I,OAAOzJ,KACtEmB,GAAac,GAAGrB,KAAK4E,SAAUkD,IAAiB1I,GAASY,KAAKmJ,MAAM/J,KACpEmB,GAAac,GAAGrB,KAAK4E,SAAUmD,IAAgB3I,GAASY,KAAKiJ,KAAK7J,KAEtE,CACA,uBAAA0J,CAAwB1J,GACtB,OAAOY,KAAK0I,wBA3FS,QA2FiBtJ,EAAMiK,aA5FrB,UA4FyDjK,EAAMiK,YACxF,CAGA,kBAAOb,GACL,MAAO,iBAAkBnjB,SAASC,iBAAmB7C,UAAU6mB,eAAiB,CAClF,EAeF,MAEMC,GAAc,eACdC,GAAiB,YAKjBC,GAAa,OACbC,GAAa,OACbC,GAAiB,OACjBC,GAAkB,QAClBC,GAAc,QAAQN,KACtBO,GAAa,OAAOP,KACpBQ,GAAkB,UAAUR,KAC5BS,GAAqB,aAAaT,KAClCU,GAAqB,aAAaV,KAClCW,GAAmB,YAAYX,KAC/BY,GAAwB,OAAOZ,KAAcC,KAC7CY,GAAyB,QAAQb,KAAcC,KAC/Ca,GAAsB,WACtBC,GAAsB,SAMtBC,GAAkB,UAClBC,GAAgB,iBAChBC,GAAuBF,GAAkBC,GAKzCE,GAAmB,CACvB,UAAoBd,GACpB,WAAqBD,IAEjBgB,GAAY,CAChBC,SAAU,IACVC,UAAU,EACVC,MAAO,QACPC,MAAM,EACNC,OAAO,EACPC,MAAM,GAEFC,GAAgB,CACpBN,SAAU,mBAEVC,SAAU,UACVC,MAAO,mBACPC,KAAM,mBACNC,MAAO,UACPC,KAAM,WAOR,MAAME,WAAiBzG,GACrB,WAAAP,CAAY5kB,EAASukB,GACnBa,MAAMplB,EAASukB,GACf9D,KAAKoL,UAAY,KACjBpL,KAAKqL,eAAiB,KACtBrL,KAAKsL,YAAa,EAClBtL,KAAKuL,aAAe,KACpBvL,KAAKwL,aAAe,KACpBxL,KAAKyL,mBAAqB7F,GAAeC,QArCjB,uBAqC8C7F,KAAK4E,UAC3E5E,KAAK0L,qBACD1L,KAAK6E,QAAQkG,OAASV,IACxBrK,KAAK2L,OAET,CAGA,kBAAWjI,GACT,OAAOiH,EACT,CACA,sBAAWhH,GACT,OAAOuH,EACT,CACA,eAAW3O,GACT,MAnFW,UAoFb,CAGA,IAAA1X,GACEmb,KAAK4L,OAAOnC,GACd,CACA,eAAAoC,IAIOxmB,SAASymB,QAAUnR,GAAUqF,KAAK4E,WACrC5E,KAAKnb,MAET,CACA,IAAAqhB,GACElG,KAAK4L,OAAOlC,GACd,CACA,KAAAoB,GACM9K,KAAKsL,YACPlR,GAAqB4F,KAAK4E,UAE5B5E,KAAK+L,gBACP,CACA,KAAAJ,GACE3L,KAAK+L,iBACL/L,KAAKgM,kBACLhM,KAAKoL,UAAYa,aAAY,IAAMjM,KAAK6L,mBAAmB7L,KAAK6E,QAAQ+F,SAC1E,CACA,iBAAAsB,GACOlM,KAAK6E,QAAQkG,OAGd/K,KAAKsL,WACP/K,GAAae,IAAItB,KAAK4E,SAAUkF,IAAY,IAAM9J,KAAK2L,UAGzD3L,KAAK2L,QACP,CACA,EAAAQ,CAAG1T,GACD,MAAM2T,EAAQpM,KAAKqM,YACnB,GAAI5T,EAAQ2T,EAAM1b,OAAS,GAAK+H,EAAQ,EACtC,OAEF,GAAIuH,KAAKsL,WAEP,YADA/K,GAAae,IAAItB,KAAK4E,SAAUkF,IAAY,IAAM9J,KAAKmM,GAAG1T,KAG5D,MAAM6T,EAActM,KAAKuM,cAAcvM,KAAKwM,cAC5C,GAAIF,IAAgB7T,EAClB,OAEF,MAAMtC,EAAQsC,EAAQ6T,EAAc7C,GAAaC,GACjD1J,KAAK4L,OAAOzV,EAAOiW,EAAM3T,GAC3B,CACA,OAAAsM,GACM/E,KAAKwL,cACPxL,KAAKwL,aAAazG,UAEpBJ,MAAMI,SACR,CAGA,iBAAAf,CAAkBF,GAEhB,OADAA,EAAO2I,gBAAkB3I,EAAO8G,SACzB9G,CACT,CACA,kBAAA4H,GACM1L,KAAK6E,QAAQgG,UACftK,GAAac,GAAGrB,KAAK4E,SAAUmF,IAAiB3K,GAASY,KAAK0M,SAAStN,KAE9C,UAAvBY,KAAK6E,QAAQiG,QACfvK,GAAac,GAAGrB,KAAK4E,SAAUoF,IAAoB,IAAMhK,KAAK8K,UAC9DvK,GAAac,GAAGrB,KAAK4E,SAAUqF,IAAoB,IAAMjK,KAAKkM,uBAE5DlM,KAAK6E,QAAQmG,OAASzC,GAAMC,eAC9BxI,KAAK2M,yBAET,CACA,uBAAAA,GACE,IAAK,MAAMC,KAAOhH,GAAezT,KArIX,qBAqImC6N,KAAK4E,UAC5DrE,GAAac,GAAGuL,EAAK1C,IAAkB9K,GAASA,EAAMkD,mBAExD,MAmBMuK,EAAc,CAClBzE,aAAc,IAAMpI,KAAK4L,OAAO5L,KAAK8M,kBAAkBnD,KACvDtB,cAAe,IAAMrI,KAAK4L,OAAO5L,KAAK8M,kBAAkBlD,KACxDzB,YAtBkB,KACS,UAAvBnI,KAAK6E,QAAQiG,QAYjB9K,KAAK8K,QACD9K,KAAKuL,cACPwB,aAAa/M,KAAKuL,cAEpBvL,KAAKuL,aAAe1N,YAAW,IAAMmC,KAAKkM,qBAjLjB,IAiL+DlM,KAAK6E,QAAQ+F,UAAS,GAOhH5K,KAAKwL,aAAe,IAAIjD,GAAMvI,KAAK4E,SAAUiI,EAC/C,CACA,QAAAH,CAAStN,GACP,GAAI,kBAAkB/b,KAAK+b,EAAM7S,OAAOya,SACtC,OAEF,MAAM1Z,EAAYod,GAAiBtL,EAAMtiB,KACrCwQ,IACF8R,EAAMkD,iBACNtC,KAAK4L,OAAO5L,KAAK8M,kBAAkBxf,IAEvC,CACA,aAAAif,CAAchtB,GACZ,OAAOygB,KAAKqM,YAAYlnB,QAAQ5F,EAClC,CACA,0BAAAytB,CAA2BvU,GACzB,IAAKuH,KAAKyL,mBACR,OAEF,MAAMwB,EAAkBrH,GAAeC,QAAQ0E,GAAiBvK,KAAKyL,oBACrEwB,EAAgB5R,UAAU1B,OAAO2Q,IACjC2C,EAAgB9rB,gBAAgB,gBAChC,MAAM+rB,EAAqBtH,GAAeC,QAAQ,sBAAsBpN,MAAWuH,KAAKyL,oBACpFyB,IACFA,EAAmB7R,UAAU5E,IAAI6T,IACjC4C,EAAmB9rB,aAAa,eAAgB,QAEpD,CACA,eAAA4qB,GACE,MAAMzsB,EAAUygB,KAAKqL,gBAAkBrL,KAAKwM,aAC5C,IAAKjtB,EACH,OAEF,MAAM4tB,EAAkB5P,OAAO6P,SAAS7tB,EAAQic,aAAa,oBAAqB,IAClFwE,KAAK6E,QAAQ+F,SAAWuC,GAAmBnN,KAAK6E,QAAQ4H,eAC1D,CACA,MAAAb,CAAOzV,EAAO5W,EAAU,MACtB,GAAIygB,KAAKsL,WACP,OAEF,MAAMvN,EAAgBiC,KAAKwM,aACrBa,EAASlX,IAAUsT,GACnB6D,EAAc/tB,GAAWue,GAAqBkC,KAAKqM,YAAatO,EAAesP,EAAQrN,KAAK6E,QAAQoG,MAC1G,GAAIqC,IAAgBvP,EAClB,OAEF,MAAMwP,EAAmBvN,KAAKuM,cAAce,GACtCE,EAAehI,GACZjF,GAAaqB,QAAQ5B,KAAK4E,SAAUY,EAAW,CACpD1F,cAAewN,EACfhgB,UAAW0S,KAAKyN,kBAAkBtX,GAClCuD,KAAMsG,KAAKuM,cAAcxO,GACzBoO,GAAIoB,IAIR,GADmBC,EAAa3D,IACjB7H,iBACb,OAEF,IAAKjE,IAAkBuP,EAGrB,OAEF,MAAMI,EAAY5M,QAAQd,KAAKoL,WAC/BpL,KAAK8K,QACL9K,KAAKsL,YAAa,EAClBtL,KAAKgN,2BAA2BO,GAChCvN,KAAKqL,eAAiBiC,EACtB,MAAMK,EAAuBN,EA3OR,sBADF,oBA6ObO,EAAiBP,EA3OH,qBACA,qBA2OpBC,EAAYjS,UAAU5E,IAAImX,GAC1B/R,GAAOyR,GACPvP,EAAc1C,UAAU5E,IAAIkX,GAC5BL,EAAYjS,UAAU5E,IAAIkX,GAQ1B3N,KAAKmF,gBAPoB,KACvBmI,EAAYjS,UAAU1B,OAAOgU,EAAsBC,GACnDN,EAAYjS,UAAU5E,IAAI6T,IAC1BvM,EAAc1C,UAAU1B,OAAO2Q,GAAqBsD,EAAgBD,GACpE3N,KAAKsL,YAAa,EAClBkC,EAAa1D,GAAW,GAEY/L,EAAeiC,KAAK6N,eACtDH,GACF1N,KAAK2L,OAET,CACA,WAAAkC,GACE,OAAO7N,KAAK4E,SAASvJ,UAAU7W,SAhQV,QAiQvB,CACA,UAAAgoB,GACE,OAAO5G,GAAeC,QAAQ4E,GAAsBzK,KAAK4E,SAC3D,CACA,SAAAyH,GACE,OAAOzG,GAAezT,KAAKqY,GAAexK,KAAK4E,SACjD,CACA,cAAAmH,GACM/L,KAAKoL,YACP0C,cAAc9N,KAAKoL,WACnBpL,KAAKoL,UAAY,KAErB,CACA,iBAAA0B,CAAkBxf,GAChB,OAAI2O,KACK3O,IAAcqc,GAAiBD,GAAaD,GAE9Cnc,IAAcqc,GAAiBF,GAAaC,EACrD,CACA,iBAAA+D,CAAkBtX,GAChB,OAAI8F,KACK9F,IAAUuT,GAAaC,GAAiBC,GAE1CzT,IAAUuT,GAAaE,GAAkBD,EAClD,CAGA,sBAAOlN,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAO8gB,GAAS7F,oBAAoBtF,KAAM8D,GAChD,GAAsB,iBAAXA,GAIX,GAAsB,iBAAXA,EAAqB,CAC9B,QAAqB/K,IAAjB1O,EAAKyZ,IAAyBA,EAAOrC,WAAW,MAAmB,gBAAXqC,EAC1D,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,IACP,OAREzZ,EAAK8hB,GAAGrI,EASZ,GACF,EAOFvD,GAAac,GAAGhc,SAAU+kB,GAvSE,uCAuS2C,SAAUhL,GAC/E,MAAM7S,EAASqZ,GAAec,uBAAuB1G,MACrD,IAAKzT,IAAWA,EAAO8O,UAAU7W,SAAS6lB,IACxC,OAEFjL,EAAMkD,iBACN,MAAMyL,EAAW5C,GAAS7F,oBAAoB/Y,GACxCyhB,EAAahO,KAAKxE,aAAa,oBACrC,OAAIwS,GACFD,EAAS5B,GAAG6B,QACZD,EAAS7B,qBAGyC,SAAhDlJ,GAAYQ,iBAAiBxD,KAAM,UACrC+N,EAASlpB,YACTkpB,EAAS7B,sBAGX6B,EAAS7H,YACT6H,EAAS7B,oBACX,IACA3L,GAAac,GAAGzhB,OAAQuqB,IAAuB,KAC7C,MAAM8D,EAAYrI,GAAezT,KA5TR,6BA6TzB,IAAK,MAAM4b,KAAYE,EACrB9C,GAAS7F,oBAAoByI,EAC/B,IAOF5R,GAAmBgP,IAcnB,MAEM+C,GAAc,eAEdC,GAAe,OAAOD,KACtBE,GAAgB,QAAQF,KACxBG,GAAe,OAAOH,KACtBI,GAAiB,SAASJ,KAC1BK,GAAyB,QAAQL,cACjCM,GAAoB,OACpBC,GAAsB,WACtBC,GAAwB,aAExBC,GAA6B,WAAWF,OAAwBA,KAKhEG,GAAyB,8BACzBC,GAAY,CAChBpqB,OAAQ,KACRijB,QAAQ,GAEJoH,GAAgB,CACpBrqB,OAAQ,iBACRijB,OAAQ,WAOV,MAAMqH,WAAiBrK,GACrB,WAAAP,CAAY5kB,EAASukB,GACnBa,MAAMplB,EAASukB,GACf9D,KAAKgP,kBAAmB,EACxBhP,KAAKiP,cAAgB,GACrB,MAAMC,EAAatJ,GAAezT,KAAKyc,IACvC,IAAK,MAAMO,KAAQD,EAAY,CAC7B,MAAMnV,EAAW6L,GAAea,uBAAuB0I,GACjDC,EAAgBxJ,GAAezT,KAAK4H,GAAU5T,QAAOkpB,GAAgBA,IAAiBrP,KAAK4E,WAChF,OAAb7K,GAAqBqV,EAAc1e,QACrCsP,KAAKiP,cAAcrd,KAAKud,EAE5B,CACAnP,KAAKsP,sBACAtP,KAAK6E,QAAQpgB,QAChBub,KAAKuP,0BAA0BvP,KAAKiP,cAAejP,KAAKwP,YAEtDxP,KAAK6E,QAAQ6C,QACf1H,KAAK0H,QAET,CAGA,kBAAWhE,GACT,OAAOmL,EACT,CACA,sBAAWlL,GACT,OAAOmL,EACT,CACA,eAAWvS,GACT,MA9DW,UA+Db,CAGA,MAAAmL,GACM1H,KAAKwP,WACPxP,KAAKyP,OAELzP,KAAK0P,MAET,CACA,IAAAA,GACE,GAAI1P,KAAKgP,kBAAoBhP,KAAKwP,WAChC,OAEF,IAAIG,EAAiB,GAQrB,GALI3P,KAAK6E,QAAQpgB,SACfkrB,EAAiB3P,KAAK4P,uBAhEH,wCAgE4CzpB,QAAO5G,GAAWA,IAAYygB,KAAK4E,WAAU9hB,KAAIvD,GAAWwvB,GAASzJ,oBAAoB/lB,EAAS,CAC/JmoB,QAAQ,OAGRiI,EAAejf,QAAUif,EAAe,GAAGX,iBAC7C,OAGF,GADmBzO,GAAaqB,QAAQ5B,KAAK4E,SAAUuJ,IACxCnM,iBACb,OAEF,IAAK,MAAM6N,KAAkBF,EAC3BE,EAAeJ,OAEjB,MAAMK,EAAY9P,KAAK+P,gBACvB/P,KAAK4E,SAASvJ,UAAU1B,OAAO8U,IAC/BzO,KAAK4E,SAASvJ,UAAU5E,IAAIiY,IAC5B1O,KAAK4E,SAAS7jB,MAAM+uB,GAAa,EACjC9P,KAAKuP,0BAA0BvP,KAAKiP,eAAe,GACnDjP,KAAKgP,kBAAmB,EACxB,MAQMgB,EAAa,SADUF,EAAU,GAAGrL,cAAgBqL,EAAU1d,MAAM,KAE1E4N,KAAKmF,gBATY,KACfnF,KAAKgP,kBAAmB,EACxBhP,KAAK4E,SAASvJ,UAAU1B,OAAO+U,IAC/B1O,KAAK4E,SAASvJ,UAAU5E,IAAIgY,GAAqBD,IACjDxO,KAAK4E,SAAS7jB,MAAM+uB,GAAa,GACjCvP,GAAaqB,QAAQ5B,KAAK4E,SAAUwJ,GAAc,GAItBpO,KAAK4E,UAAU,GAC7C5E,KAAK4E,SAAS7jB,MAAM+uB,GAAa,GAAG9P,KAAK4E,SAASoL,MACpD,CACA,IAAAP,GACE,GAAIzP,KAAKgP,mBAAqBhP,KAAKwP,WACjC,OAGF,GADmBjP,GAAaqB,QAAQ5B,KAAK4E,SAAUyJ,IACxCrM,iBACb,OAEF,MAAM8N,EAAY9P,KAAK+P,gBACvB/P,KAAK4E,SAAS7jB,MAAM+uB,GAAa,GAAG9P,KAAK4E,SAASthB,wBAAwBwsB,OAC1EjU,GAAOmE,KAAK4E,UACZ5E,KAAK4E,SAASvJ,UAAU5E,IAAIiY,IAC5B1O,KAAK4E,SAASvJ,UAAU1B,OAAO8U,GAAqBD,IACpD,IAAK,MAAM5M,KAAW5B,KAAKiP,cAAe,CACxC,MAAM1vB,EAAUqmB,GAAec,uBAAuB9E,GAClDriB,IAAYygB,KAAKwP,SAASjwB,IAC5BygB,KAAKuP,0BAA0B,CAAC3N,IAAU,EAE9C,CACA5B,KAAKgP,kBAAmB,EAOxBhP,KAAK4E,SAAS7jB,MAAM+uB,GAAa,GACjC9P,KAAKmF,gBAPY,KACfnF,KAAKgP,kBAAmB,EACxBhP,KAAK4E,SAASvJ,UAAU1B,OAAO+U,IAC/B1O,KAAK4E,SAASvJ,UAAU5E,IAAIgY,IAC5BlO,GAAaqB,QAAQ5B,KAAK4E,SAAU0J,GAAe,GAGvBtO,KAAK4E,UAAU,EAC/C,CACA,QAAA4K,CAASjwB,EAAUygB,KAAK4E,UACtB,OAAOrlB,EAAQ8b,UAAU7W,SAASgqB,GACpC,CAGA,iBAAAxK,CAAkBF,GAGhB,OAFAA,EAAO4D,OAAS5G,QAAQgD,EAAO4D,QAC/B5D,EAAOrf,OAASiW,GAAWoJ,EAAOrf,QAC3Bqf,CACT,CACA,aAAAiM,GACE,OAAO/P,KAAK4E,SAASvJ,UAAU7W,SA3IL,uBAChB,QACC,QA0Ib,CACA,mBAAA8qB,GACE,IAAKtP,KAAK6E,QAAQpgB,OAChB,OAEF,MAAMqhB,EAAW9F,KAAK4P,uBAAuBhB,IAC7C,IAAK,MAAMrvB,KAAWumB,EAAU,CAC9B,MAAMmK,EAAWrK,GAAec,uBAAuBnnB,GACnD0wB,GACFjQ,KAAKuP,0BAA0B,CAAChwB,GAAUygB,KAAKwP,SAASS,GAE5D,CACF,CACA,sBAAAL,CAAuB7V,GACrB,MAAM+L,EAAWF,GAAezT,KAAKwc,GAA4B3O,KAAK6E,QAAQpgB,QAE9E,OAAOmhB,GAAezT,KAAK4H,EAAUiG,KAAK6E,QAAQpgB,QAAQ0B,QAAO5G,IAAYumB,EAAS1E,SAAS7hB,IACjG,CACA,yBAAAgwB,CAA0BW,EAAcC,GACtC,GAAKD,EAAaxf,OAGlB,IAAK,MAAMnR,KAAW2wB,EACpB3wB,EAAQ8b,UAAUqM,OArKK,aAqKyByI,GAChD5wB,EAAQ6B,aAAa,gBAAiB+uB,EAE1C,CAGA,sBAAO1T,CAAgBqH,GACrB,MAAMe,EAAU,CAAC,EAIjB,MAHsB,iBAAXf,GAAuB,YAAYzgB,KAAKygB,KACjDe,EAAQ6C,QAAS,GAEZ1H,KAAKuH,MAAK,WACf,MAAMld,EAAO0kB,GAASzJ,oBAAoBtF,KAAM6E,GAChD,GAAsB,iBAAXf,EAAqB,CAC9B,QAA4B,IAAjBzZ,EAAKyZ,GACd,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,IACP,CACF,GACF,EAOFvD,GAAac,GAAGhc,SAAUkpB,GAAwBK,IAAwB,SAAUxP,IAErD,MAAzBA,EAAM7S,OAAOya,SAAmB5H,EAAMW,gBAAmD,MAAjCX,EAAMW,eAAeiH,UAC/E5H,EAAMkD,iBAER,IAAK,MAAM/iB,KAAWqmB,GAAee,gCAAgC3G,MACnE+O,GAASzJ,oBAAoB/lB,EAAS,CACpCmoB,QAAQ,IACPA,QAEP,IAMAvL,GAAmB4S,IAcnB,MAAMqB,GAAS,WAETC,GAAc,eACdC,GAAiB,YAGjBC,GAAiB,UACjBC,GAAmB,YAGnBC,GAAe,OAAOJ,KACtBK,GAAiB,SAASL,KAC1BM,GAAe,OAAON,KACtBO,GAAgB,QAAQP,KACxBQ,GAAyB,QAAQR,KAAcC,KAC/CQ,GAAyB,UAAUT,KAAcC,KACjDS,GAAuB,QAAQV,KAAcC,KAC7CU,GAAoB,OAMpBC,GAAyB,4DACzBC,GAA6B,GAAGD,MAA0BD,KAC1DG,GAAgB,iBAIhBC,GAAgBnV,KAAU,UAAY,YACtCoV,GAAmBpV,KAAU,YAAc,UAC3CqV,GAAmBrV,KAAU,aAAe,eAC5CsV,GAAsBtV,KAAU,eAAiB,aACjDuV,GAAkBvV,KAAU,aAAe,cAC3CwV,GAAiBxV,KAAU,cAAgB,aAG3CyV,GAAY,CAChBC,WAAW,EACX1jB,SAAU,kBACV2jB,QAAS,UACT5pB,OAAQ,CAAC,EAAG,GACZ6pB,aAAc,KACdvzB,UAAW,UAEPwzB,GAAgB,CACpBH,UAAW,mBACX1jB,SAAU,mBACV2jB,QAAS,SACT5pB,OAAQ,0BACR6pB,aAAc,yBACdvzB,UAAW,2BAOb,MAAMyzB,WAAiBrN,GACrB,WAAAP,CAAY5kB,EAASukB,GACnBa,MAAMplB,EAASukB,GACf9D,KAAKgS,QAAU,KACfhS,KAAKiS,QAAUjS,KAAK4E,SAAS7f,WAE7Bib,KAAKkS,MAAQtM,GAAe/gB,KAAKmb,KAAK4E,SAAUuM,IAAe,IAAMvL,GAAeM,KAAKlG,KAAK4E,SAAUuM,IAAe,IAAMvL,GAAeC,QAAQsL,GAAenR,KAAKiS,SACxKjS,KAAKmS,UAAYnS,KAAKoS,eACxB,CAGA,kBAAW1O,GACT,OAAOgO,EACT,CACA,sBAAW/N,GACT,OAAOmO,EACT,CACA,eAAWvV,GACT,OAAO6T,EACT,CAGA,MAAA1I,GACE,OAAO1H,KAAKwP,WAAaxP,KAAKyP,OAASzP,KAAK0P,MAC9C,CACA,IAAAA,GACE,GAAIxU,GAAW8E,KAAK4E,WAAa5E,KAAKwP,WACpC,OAEF,MAAM1P,EAAgB,CACpBA,cAAeE,KAAK4E,UAGtB,IADkBrE,GAAaqB,QAAQ5B,KAAK4E,SAAU+L,GAAc7Q,GACtDkC,iBAAd,CASA,GANAhC,KAAKqS,gBAMD,iBAAkBhtB,SAASC,kBAAoB0a,KAAKiS,QAAQjX,QAzExC,eA0EtB,IAAK,MAAMzb,IAAW,GAAGZ,UAAU0G,SAAS6G,KAAK4Z,UAC/CvF,GAAac,GAAG9hB,EAAS,YAAaqc,IAG1CoE,KAAK4E,SAAS0N,QACdtS,KAAK4E,SAASxjB,aAAa,iBAAiB,GAC5C4e,KAAKkS,MAAM7W,UAAU5E,IAAIua,IACzBhR,KAAK4E,SAASvJ,UAAU5E,IAAIua,IAC5BzQ,GAAaqB,QAAQ5B,KAAK4E,SAAUgM,GAAe9Q,EAhBnD,CAiBF,CACA,IAAA2P,GACE,GAAIvU,GAAW8E,KAAK4E,YAAc5E,KAAKwP,WACrC,OAEF,MAAM1P,EAAgB,CACpBA,cAAeE,KAAK4E,UAEtB5E,KAAKuS,cAAczS,EACrB,CACA,OAAAiF,GACM/E,KAAKgS,SACPhS,KAAKgS,QAAQhZ,UAEf2L,MAAMI,SACR,CACA,MAAAha,GACEiV,KAAKmS,UAAYnS,KAAKoS,gBAClBpS,KAAKgS,SACPhS,KAAKgS,QAAQjnB,QAEjB,CAGA,aAAAwnB,CAAczS,GAEZ,IADkBS,GAAaqB,QAAQ5B,KAAK4E,SAAU6L,GAAc3Q,GACtDkC,iBAAd,CAMA,GAAI,iBAAkB3c,SAASC,gBAC7B,IAAK,MAAM/F,IAAW,GAAGZ,UAAU0G,SAAS6G,KAAK4Z,UAC/CvF,GAAaC,IAAIjhB,EAAS,YAAaqc,IAGvCoE,KAAKgS,SACPhS,KAAKgS,QAAQhZ,UAEfgH,KAAKkS,MAAM7W,UAAU1B,OAAOqX,IAC5BhR,KAAK4E,SAASvJ,UAAU1B,OAAOqX,IAC/BhR,KAAK4E,SAASxjB,aAAa,gBAAiB,SAC5C4hB,GAAYE,oBAAoBlD,KAAKkS,MAAO,UAC5C3R,GAAaqB,QAAQ5B,KAAK4E,SAAU8L,GAAgB5Q,EAhBpD,CAiBF,CACA,UAAA+D,CAAWC,GAET,GAAgC,iBADhCA,EAASa,MAAMd,WAAWC,IACRxlB,YAA2B,GAAUwlB,EAAOxlB,YAAgE,mBAA3CwlB,EAAOxlB,UAAUgF,sBAElG,MAAM,IAAIkhB,UAAU,GAAG4L,GAAO3L,+GAEhC,OAAOX,CACT,CACA,aAAAuO,GACE,QAAsB,IAAX,EACT,MAAM,IAAI7N,UAAU,gEAEtB,IAAIgO,EAAmBxS,KAAK4E,SACG,WAA3B5E,KAAK6E,QAAQvmB,UACfk0B,EAAmBxS,KAAKiS,QACf,GAAUjS,KAAK6E,QAAQvmB,WAChCk0B,EAAmB9X,GAAWsF,KAAK6E,QAAQvmB,WACA,iBAA3B0hB,KAAK6E,QAAQvmB,YAC7Bk0B,EAAmBxS,KAAK6E,QAAQvmB,WAElC,MAAMuzB,EAAe7R,KAAKyS,mBAC1BzS,KAAKgS,QAAU,GAAoBQ,EAAkBxS,KAAKkS,MAAOL,EACnE,CACA,QAAArC,GACE,OAAOxP,KAAKkS,MAAM7W,UAAU7W,SAASwsB,GACvC,CACA,aAAA0B,GACE,MAAMC,EAAiB3S,KAAKiS,QAC5B,GAAIU,EAAetX,UAAU7W,SArKN,WAsKrB,OAAOgtB,GAET,GAAImB,EAAetX,UAAU7W,SAvKJ,aAwKvB,OAAOitB,GAET,GAAIkB,EAAetX,UAAU7W,SAzKA,iBA0K3B,MA5JsB,MA8JxB,GAAImuB,EAAetX,UAAU7W,SA3KE,mBA4K7B,MA9JyB,SAkK3B,MAAMouB,EAAkF,QAA1E3tB,iBAAiB+a,KAAKkS,OAAOpX,iBAAiB,iBAAiB6K,OAC7E,OAAIgN,EAAetX,UAAU7W,SArLP,UAsLbouB,EAAQvB,GAAmBD,GAE7BwB,EAAQrB,GAAsBD,EACvC,CACA,aAAAc,GACE,OAAkD,OAA3CpS,KAAK4E,SAAS5J,QAnLD,UAoLtB,CACA,UAAA6X,GACE,MAAM,OACJ7qB,GACEgY,KAAK6E,QACT,MAAsB,iBAAX7c,EACFA,EAAO9F,MAAM,KAAKY,KAAInF,GAAS4f,OAAO6P,SAASzvB,EAAO,MAEzC,mBAAXqK,EACF8qB,GAAc9qB,EAAO8qB,EAAY9S,KAAK4E,UAExC5c,CACT,CACA,gBAAAyqB,GACE,MAAMM,EAAwB,CAC5Br0B,UAAWshB,KAAK0S,gBAChBtc,UAAW,CAAC,CACV9V,KAAM,kBACNmB,QAAS,CACPwM,SAAU+R,KAAK6E,QAAQ5W,WAExB,CACD3N,KAAM,SACNmB,QAAS,CACPuG,OAAQgY,KAAK6S,iBAanB,OAPI7S,KAAKmS,WAAsC,WAAzBnS,KAAK6E,QAAQ+M,WACjC5O,GAAYC,iBAAiBjD,KAAKkS,MAAO,SAAU,UACnDa,EAAsB3c,UAAY,CAAC,CACjC9V,KAAM,cACNC,SAAS,KAGN,IACFwyB,KACAlW,GAAQmD,KAAK6E,QAAQgN,aAAc,CAACkB,IAE3C,CACA,eAAAC,EAAgB,IACdl2B,EAAG,OACHyP,IAEA,MAAM6f,EAAQxG,GAAezT,KAhOF,8DAgO+B6N,KAAKkS,OAAO/rB,QAAO5G,GAAWob,GAAUpb,KAC7F6sB,EAAM1b,QAMXoN,GAAqBsO,EAAO7f,EAAQzP,IAAQ0zB,IAAmBpE,EAAMhL,SAAS7U,IAAS+lB,OACzF,CAGA,sBAAO7V,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAO0nB,GAASzM,oBAAoBtF,KAAM8D,GAChD,GAAsB,iBAAXA,EAAX,CAGA,QAA4B,IAAjBzZ,EAAKyZ,GACd,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,IAJL,CAKF,GACF,CACA,iBAAOmP,CAAW7T,GAChB,GA5QuB,IA4QnBA,EAAMuI,QAAgD,UAAfvI,EAAMqB,MA/QnC,QA+QuDrB,EAAMtiB,IACzE,OAEF,MAAMo2B,EAActN,GAAezT,KAAK+e,IACxC,IAAK,MAAMxJ,KAAUwL,EAAa,CAChC,MAAMC,EAAUpB,GAAS1M,YAAYqC,GACrC,IAAKyL,IAAyC,IAA9BA,EAAQtO,QAAQ8M,UAC9B,SAEF,MAAMyB,EAAehU,EAAMgU,eACrBC,EAAeD,EAAahS,SAAS+R,EAAQjB,OACnD,GAAIkB,EAAahS,SAAS+R,EAAQvO,WAA2C,WAA9BuO,EAAQtO,QAAQ8M,YAA2B0B,GAA8C,YAA9BF,EAAQtO,QAAQ8M,WAA2B0B,EACnJ,SAIF,GAAIF,EAAQjB,MAAM1tB,SAAS4a,EAAM7S,UAA2B,UAAf6S,EAAMqB,MA/RvC,QA+R2DrB,EAAMtiB,KAAqB,qCAAqCuG,KAAK+b,EAAM7S,OAAOya,UACvJ,SAEF,MAAMlH,EAAgB,CACpBA,cAAeqT,EAAQvO,UAEN,UAAfxF,EAAMqB,OACRX,EAAciH,WAAa3H,GAE7B+T,EAAQZ,cAAczS,EACxB,CACF,CACA,4BAAOwT,CAAsBlU,GAI3B,MAAMmU,EAAU,kBAAkBlwB,KAAK+b,EAAM7S,OAAOya,SAC9CwM,EAjTW,WAiTKpU,EAAMtiB,IACtB22B,EAAkB,CAAClD,GAAgBC,IAAkBpP,SAAShC,EAAMtiB,KAC1E,IAAK22B,IAAoBD,EACvB,OAEF,GAAID,IAAYC,EACd,OAEFpU,EAAMkD,iBAGN,MAAMoR,EAAkB1T,KAAK+F,QAAQkL,IAA0BjR,KAAO4F,GAAeM,KAAKlG,KAAMiR,IAAwB,IAAMrL,GAAe/gB,KAAKmb,KAAMiR,IAAwB,IAAMrL,GAAeC,QAAQoL,GAAwB7R,EAAMW,eAAehb,YACpPwF,EAAWwnB,GAASzM,oBAAoBoO,GAC9C,GAAID,EAIF,OAHArU,EAAMuU,kBACNppB,EAASmlB,YACTnlB,EAASyoB,gBAAgB5T,GAGvB7U,EAASilB,aAEXpQ,EAAMuU,kBACNppB,EAASklB,OACTiE,EAAgBpB,QAEpB,EAOF/R,GAAac,GAAGhc,SAAUyrB,GAAwBG,GAAwBc,GAASuB,uBACnF/S,GAAac,GAAGhc,SAAUyrB,GAAwBK,GAAeY,GAASuB,uBAC1E/S,GAAac,GAAGhc,SAAUwrB,GAAwBkB,GAASkB,YAC3D1S,GAAac,GAAGhc,SAAU0rB,GAAsBgB,GAASkB,YACzD1S,GAAac,GAAGhc,SAAUwrB,GAAwBI,IAAwB,SAAU7R,GAClFA,EAAMkD,iBACNyP,GAASzM,oBAAoBtF,MAAM0H,QACrC,IAMAvL,GAAmB4V,IAcnB,MAAM6B,GAAS,WAETC,GAAoB,OACpBC,GAAkB,gBAAgBF,KAClCG,GAAY,CAChBC,UAAW,iBACXC,cAAe,KACf7O,YAAY,EACZzK,WAAW,EAEXuZ,YAAa,QAGTC,GAAgB,CACpBH,UAAW,SACXC,cAAe,kBACf7O,WAAY,UACZzK,UAAW,UACXuZ,YAAa,oBAOf,MAAME,WAAiB3Q,GACrB,WAAAU,CAAYL,GACVa,QACA3E,KAAK6E,QAAU7E,KAAK6D,WAAWC,GAC/B9D,KAAKqU,aAAc,EACnBrU,KAAK4E,SAAW,IAClB,CAGA,kBAAWlB,GACT,OAAOqQ,EACT,CACA,sBAAWpQ,GACT,OAAOwQ,EACT,CACA,eAAW5X,GACT,OAAOqX,EACT,CAGA,IAAAlE,CAAKrT,GACH,IAAK2D,KAAK6E,QAAQlK,UAEhB,YADAkC,GAAQR,GAGV2D,KAAKsU,UACL,MAAM/0B,EAAUygB,KAAKuU,cACjBvU,KAAK6E,QAAQO,YACfvJ,GAAOtc,GAETA,EAAQ8b,UAAU5E,IAAIod,IACtB7T,KAAKwU,mBAAkB,KACrB3X,GAAQR,EAAS,GAErB,CACA,IAAAoT,CAAKpT,GACE2D,KAAK6E,QAAQlK,WAIlBqF,KAAKuU,cAAclZ,UAAU1B,OAAOka,IACpC7T,KAAKwU,mBAAkB,KACrBxU,KAAK+E,UACLlI,GAAQR,EAAS,KANjBQ,GAAQR,EAQZ,CACA,OAAA0I,GACO/E,KAAKqU,cAGV9T,GAAaC,IAAIR,KAAK4E,SAAUkP,IAChC9T,KAAK4E,SAASjL,SACdqG,KAAKqU,aAAc,EACrB,CAGA,WAAAE,GACE,IAAKvU,KAAK4E,SAAU,CAClB,MAAM6P,EAAWpvB,SAASqvB,cAAc,OACxCD,EAAST,UAAYhU,KAAK6E,QAAQmP,UAC9BhU,KAAK6E,QAAQO,YACfqP,EAASpZ,UAAU5E,IArFD,QAuFpBuJ,KAAK4E,SAAW6P,CAClB,CACA,OAAOzU,KAAK4E,QACd,CACA,iBAAAZ,CAAkBF,GAGhB,OADAA,EAAOoQ,YAAcxZ,GAAWoJ,EAAOoQ,aAChCpQ,CACT,CACA,OAAAwQ,GACE,GAAItU,KAAKqU,YACP,OAEF,MAAM90B,EAAUygB,KAAKuU,cACrBvU,KAAK6E,QAAQqP,YAAYS,OAAOp1B,GAChCghB,GAAac,GAAG9hB,EAASu0B,IAAiB,KACxCjX,GAAQmD,KAAK6E,QAAQoP,cAAc,IAErCjU,KAAKqU,aAAc,CACrB,CACA,iBAAAG,CAAkBnY,GAChBW,GAAuBX,EAAU2D,KAAKuU,cAAevU,KAAK6E,QAAQO,WACpE,EAeF,MAEMwP,GAAc,gBACdC,GAAkB,UAAUD,KAC5BE,GAAoB,cAAcF,KAGlCG,GAAmB,WACnBC,GAAY,CAChBC,WAAW,EACXC,YAAa,MAGTC,GAAgB,CACpBF,UAAW,UACXC,YAAa,WAOf,MAAME,WAAkB3R,GACtB,WAAAU,CAAYL,GACVa,QACA3E,KAAK6E,QAAU7E,KAAK6D,WAAWC,GAC/B9D,KAAKqV,WAAY,EACjBrV,KAAKsV,qBAAuB,IAC9B,CAGA,kBAAW5R,GACT,OAAOsR,EACT,CACA,sBAAWrR,GACT,OAAOwR,EACT,CACA,eAAW5Y,GACT,MAtCW,WAuCb,CAGA,QAAAgZ,GACMvV,KAAKqV,YAGLrV,KAAK6E,QAAQoQ,WACfjV,KAAK6E,QAAQqQ,YAAY5C,QAE3B/R,GAAaC,IAAInb,SAAUuvB,IAC3BrU,GAAac,GAAGhc,SAAUwvB,IAAiBzV,GAASY,KAAKwV,eAAepW,KACxEmB,GAAac,GAAGhc,SAAUyvB,IAAmB1V,GAASY,KAAKyV,eAAerW,KAC1EY,KAAKqV,WAAY,EACnB,CACA,UAAAK,GACO1V,KAAKqV,YAGVrV,KAAKqV,WAAY,EACjB9U,GAAaC,IAAInb,SAAUuvB,IAC7B,CAGA,cAAAY,CAAepW,GACb,MAAM,YACJ8V,GACElV,KAAK6E,QACT,GAAIzF,EAAM7S,SAAWlH,UAAY+Z,EAAM7S,SAAW2oB,GAAeA,EAAY1wB,SAAS4a,EAAM7S,QAC1F,OAEF,MAAM1L,EAAW+kB,GAAeU,kBAAkB4O,GAC1B,IAApBr0B,EAAS6P,OACXwkB,EAAY5C,QACHtS,KAAKsV,uBAAyBP,GACvCl0B,EAASA,EAAS6P,OAAS,GAAG4hB,QAE9BzxB,EAAS,GAAGyxB,OAEhB,CACA,cAAAmD,CAAerW,GA1ED,QA2ERA,EAAMtiB,MAGVkjB,KAAKsV,qBAAuBlW,EAAMuW,SAAWZ,GA7EzB,UA8EtB,EAeF,MAAMa,GAAyB,oDACzBC,GAA0B,cAC1BC,GAAmB,gBACnBC,GAAkB,eAMxB,MAAMC,GACJ,WAAA7R,GACEnE,KAAK4E,SAAWvf,SAAS6G,IAC3B,CAGA,QAAA+pB,GAEE,MAAMC,EAAgB7wB,SAASC,gBAAgBuC,YAC/C,OAAO1F,KAAKoC,IAAI3E,OAAOu2B,WAAaD,EACtC,CACA,IAAAzG,GACE,MAAM5rB,EAAQmc,KAAKiW,WACnBjW,KAAKoW,mBAELpW,KAAKqW,sBAAsBrW,KAAK4E,SAAUkR,IAAkBQ,GAAmBA,EAAkBzyB,IAEjGmc,KAAKqW,sBAAsBT,GAAwBE,IAAkBQ,GAAmBA,EAAkBzyB,IAC1Gmc,KAAKqW,sBAAsBR,GAAyBE,IAAiBO,GAAmBA,EAAkBzyB,GAC5G,CACA,KAAAwO,GACE2N,KAAKuW,wBAAwBvW,KAAK4E,SAAU,YAC5C5E,KAAKuW,wBAAwBvW,KAAK4E,SAAUkR,IAC5C9V,KAAKuW,wBAAwBX,GAAwBE,IACrD9V,KAAKuW,wBAAwBV,GAAyBE,GACxD,CACA,aAAAS,GACE,OAAOxW,KAAKiW,WAAa,CAC3B,CAGA,gBAAAG,GACEpW,KAAKyW,sBAAsBzW,KAAK4E,SAAU,YAC1C5E,KAAK4E,SAAS7jB,MAAM+K,SAAW,QACjC,CACA,qBAAAuqB,CAAsBtc,EAAU2c,EAAera,GAC7C,MAAMsa,EAAiB3W,KAAKiW,WAS5BjW,KAAK4W,2BAA2B7c,GARHxa,IAC3B,GAAIA,IAAYygB,KAAK4E,UAAYhlB,OAAOu2B,WAAa52B,EAAQsI,YAAc8uB,EACzE,OAEF3W,KAAKyW,sBAAsBl3B,EAASm3B,GACpC,MAAMJ,EAAkB12B,OAAOqF,iBAAiB1F,GAASub,iBAAiB4b,GAC1En3B,EAAQwB,MAAM81B,YAAYH,EAAe,GAAGra,EAASkB,OAAOC,WAAW8Y,QAAsB,GAGjG,CACA,qBAAAG,CAAsBl3B,EAASm3B,GAC7B,MAAMI,EAAcv3B,EAAQwB,MAAM+Z,iBAAiB4b,GAC/CI,GACF9T,GAAYC,iBAAiB1jB,EAASm3B,EAAeI,EAEzD,CACA,uBAAAP,CAAwBxc,EAAU2c,GAWhC1W,KAAK4W,2BAA2B7c,GAVHxa,IAC3B,MAAM5B,EAAQqlB,GAAYQ,iBAAiBjkB,EAASm3B,GAEtC,OAAV/4B,GAIJqlB,GAAYE,oBAAoB3jB,EAASm3B,GACzCn3B,EAAQwB,MAAM81B,YAAYH,EAAe/4B,IAJvC4B,EAAQwB,MAAMg2B,eAAeL,EAIgB,GAGnD,CACA,0BAAAE,CAA2B7c,EAAUid,GACnC,GAAI,GAAUjd,GACZid,EAASjd,QAGX,IAAK,MAAMkd,KAAOrR,GAAezT,KAAK4H,EAAUiG,KAAK4E,UACnDoS,EAASC,EAEb,EAeF,MAEMC,GAAc,YAGdC,GAAe,OAAOD,KACtBE,GAAyB,gBAAgBF,KACzCG,GAAiB,SAASH,KAC1BI,GAAe,OAAOJ,KACtBK,GAAgB,QAAQL,KACxBM,GAAiB,SAASN,KAC1BO,GAAsB,gBAAgBP,KACtCQ,GAA0B,oBAAoBR,KAC9CS,GAA0B,kBAAkBT,KAC5CU,GAAyB,QAAQV,cACjCW,GAAkB,aAElBC,GAAoB,OACpBC,GAAoB,eAKpBC,GAAY,CAChBvD,UAAU,EACVnC,OAAO,EACPzH,UAAU,GAENoN,GAAgB,CACpBxD,SAAU,mBACVnC,MAAO,UACPzH,SAAU,WAOZ,MAAMqN,WAAcxT,GAClB,WAAAP,CAAY5kB,EAASukB,GACnBa,MAAMplB,EAASukB,GACf9D,KAAKmY,QAAUvS,GAAeC,QArBV,gBAqBmC7F,KAAK4E,UAC5D5E,KAAKoY,UAAYpY,KAAKqY,sBACtBrY,KAAKsY,WAAatY,KAAKuY,uBACvBvY,KAAKwP,UAAW,EAChBxP,KAAKgP,kBAAmB,EACxBhP,KAAKwY,WAAa,IAAIxC,GACtBhW,KAAK0L,oBACP,CAGA,kBAAWhI,GACT,OAAOsU,EACT,CACA,sBAAWrU,GACT,OAAOsU,EACT,CACA,eAAW1b,GACT,MA1DW,OA2Db,CAGA,MAAAmL,CAAO5H,GACL,OAAOE,KAAKwP,SAAWxP,KAAKyP,OAASzP,KAAK0P,KAAK5P,EACjD,CACA,IAAA4P,CAAK5P,GACCE,KAAKwP,UAAYxP,KAAKgP,kBAGRzO,GAAaqB,QAAQ5B,KAAK4E,SAAU0S,GAAc,CAClExX,kBAEYkC,mBAGdhC,KAAKwP,UAAW,EAChBxP,KAAKgP,kBAAmB,EACxBhP,KAAKwY,WAAW/I,OAChBpqB,SAAS6G,KAAKmP,UAAU5E,IAAIohB,IAC5B7X,KAAKyY,gBACLzY,KAAKoY,UAAU1I,MAAK,IAAM1P,KAAK0Y,aAAa5Y,KAC9C,CACA,IAAA2P,GACOzP,KAAKwP,WAAYxP,KAAKgP,mBAGTzO,GAAaqB,QAAQ5B,KAAK4E,SAAUuS,IACxCnV,mBAGdhC,KAAKwP,UAAW,EAChBxP,KAAKgP,kBAAmB,EACxBhP,KAAKsY,WAAW5C,aAChB1V,KAAK4E,SAASvJ,UAAU1B,OAAOme,IAC/B9X,KAAKmF,gBAAe,IAAMnF,KAAK2Y,cAAc3Y,KAAK4E,SAAU5E,KAAK6N,gBACnE,CACA,OAAA9I,GACExE,GAAaC,IAAI5gB,OAAQs3B,IACzB3W,GAAaC,IAAIR,KAAKmY,QAASjB,IAC/BlX,KAAKoY,UAAUrT,UACf/E,KAAKsY,WAAW5C,aAChB/Q,MAAMI,SACR,CACA,YAAA6T,GACE5Y,KAAKyY,eACP,CAGA,mBAAAJ,GACE,OAAO,IAAIjE,GAAS,CAClBzZ,UAAWmG,QAAQd,KAAK6E,QAAQ4P,UAEhCrP,WAAYpF,KAAK6N,eAErB,CACA,oBAAA0K,GACE,OAAO,IAAInD,GAAU,CACnBF,YAAalV,KAAK4E,UAEtB,CACA,YAAA8T,CAAa5Y,GAENza,SAAS6G,KAAK1H,SAASwb,KAAK4E,WAC/Bvf,SAAS6G,KAAKyoB,OAAO3U,KAAK4E,UAE5B5E,KAAK4E,SAAS7jB,MAAM6wB,QAAU,QAC9B5R,KAAK4E,SAASzjB,gBAAgB,eAC9B6e,KAAK4E,SAASxjB,aAAa,cAAc,GACzC4e,KAAK4E,SAASxjB,aAAa,OAAQ,UACnC4e,KAAK4E,SAASnZ,UAAY,EAC1B,MAAMotB,EAAYjT,GAAeC,QA7GT,cA6GsC7F,KAAKmY,SAC/DU,IACFA,EAAUptB,UAAY,GAExBoQ,GAAOmE,KAAK4E,UACZ5E,KAAK4E,SAASvJ,UAAU5E,IAAIqhB,IAU5B9X,KAAKmF,gBATsB,KACrBnF,KAAK6E,QAAQyN,OACftS,KAAKsY,WAAW/C,WAElBvV,KAAKgP,kBAAmB,EACxBzO,GAAaqB,QAAQ5B,KAAK4E,SAAU2S,GAAe,CACjDzX,iBACA,GAEoCE,KAAKmY,QAASnY,KAAK6N,cAC7D,CACA,kBAAAnC,GACEnL,GAAac,GAAGrB,KAAK4E,SAAU+S,IAAyBvY,IAhJvC,WAiJXA,EAAMtiB,MAGNkjB,KAAK6E,QAAQgG,SACf7K,KAAKyP,OAGPzP,KAAK8Y,6BAA4B,IAEnCvY,GAAac,GAAGzhB,OAAQ43B,IAAgB,KAClCxX,KAAKwP,WAAaxP,KAAKgP,kBACzBhP,KAAKyY,eACP,IAEFlY,GAAac,GAAGrB,KAAK4E,SAAU8S,IAAyBtY,IAEtDmB,GAAae,IAAItB,KAAK4E,SAAU6S,IAAqBsB,IAC/C/Y,KAAK4E,WAAaxF,EAAM7S,QAAUyT,KAAK4E,WAAamU,EAAOxsB,SAGjC,WAA1ByT,KAAK6E,QAAQ4P,SAIbzU,KAAK6E,QAAQ4P,UACfzU,KAAKyP,OAJLzP,KAAK8Y,6BAKP,GACA,GAEN,CACA,UAAAH,GACE3Y,KAAK4E,SAAS7jB,MAAM6wB,QAAU,OAC9B5R,KAAK4E,SAASxjB,aAAa,eAAe,GAC1C4e,KAAK4E,SAASzjB,gBAAgB,cAC9B6e,KAAK4E,SAASzjB,gBAAgB,QAC9B6e,KAAKgP,kBAAmB,EACxBhP,KAAKoY,UAAU3I,MAAK,KAClBpqB,SAAS6G,KAAKmP,UAAU1B,OAAOke,IAC/B7X,KAAKgZ,oBACLhZ,KAAKwY,WAAWnmB,QAChBkO,GAAaqB,QAAQ5B,KAAK4E,SAAUyS,GAAe,GAEvD,CACA,WAAAxJ,GACE,OAAO7N,KAAK4E,SAASvJ,UAAU7W,SAjLT,OAkLxB,CACA,0BAAAs0B,GAEE,GADkBvY,GAAaqB,QAAQ5B,KAAK4E,SAAUwS,IACxCpV,iBACZ,OAEF,MAAMiX,EAAqBjZ,KAAK4E,SAASvX,aAAehI,SAASC,gBAAgBsC,aAC3EsxB,EAAmBlZ,KAAK4E,SAAS7jB,MAAMiL,UAEpB,WAArBktB,GAAiClZ,KAAK4E,SAASvJ,UAAU7W,SAASuzB,MAGjEkB,IACHjZ,KAAK4E,SAAS7jB,MAAMiL,UAAY,UAElCgU,KAAK4E,SAASvJ,UAAU5E,IAAIshB,IAC5B/X,KAAKmF,gBAAe,KAClBnF,KAAK4E,SAASvJ,UAAU1B,OAAOoe,IAC/B/X,KAAKmF,gBAAe,KAClBnF,KAAK4E,SAAS7jB,MAAMiL,UAAYktB,CAAgB,GAC/ClZ,KAAKmY,QAAQ,GACfnY,KAAKmY,SACRnY,KAAK4E,SAAS0N,QAChB,CAMA,aAAAmG,GACE,MAAMQ,EAAqBjZ,KAAK4E,SAASvX,aAAehI,SAASC,gBAAgBsC,aAC3E+uB,EAAiB3W,KAAKwY,WAAWvC,WACjCkD,EAAoBxC,EAAiB,EAC3C,GAAIwC,IAAsBF,EAAoB,CAC5C,MAAMn3B,EAAWma,KAAU,cAAgB,eAC3C+D,KAAK4E,SAAS7jB,MAAMe,GAAY,GAAG60B,KACrC,CACA,IAAKwC,GAAqBF,EAAoB,CAC5C,MAAMn3B,EAAWma,KAAU,eAAiB,cAC5C+D,KAAK4E,SAAS7jB,MAAMe,GAAY,GAAG60B,KACrC,CACF,CACA,iBAAAqC,GACEhZ,KAAK4E,SAAS7jB,MAAMq4B,YAAc,GAClCpZ,KAAK4E,SAAS7jB,MAAMs4B,aAAe,EACrC,CAGA,sBAAO5c,CAAgBqH,EAAQhE,GAC7B,OAAOE,KAAKuH,MAAK,WACf,MAAMld,EAAO6tB,GAAM5S,oBAAoBtF,KAAM8D,GAC7C,GAAsB,iBAAXA,EAAX,CAGA,QAA4B,IAAjBzZ,EAAKyZ,GACd,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,GAAQhE,EAJb,CAKF,GACF,EAOFS,GAAac,GAAGhc,SAAUuyB,GA9OK,4BA8O2C,SAAUxY,GAClF,MAAM7S,EAASqZ,GAAec,uBAAuB1G,MACjD,CAAC,IAAK,QAAQoB,SAASpB,KAAKgH,UAC9B5H,EAAMkD,iBAER/B,GAAae,IAAI/U,EAAQ+qB,IAAcgC,IACjCA,EAAUtX,kBAIdzB,GAAae,IAAI/U,EAAQ8qB,IAAgB,KACnC1c,GAAUqF,OACZA,KAAKsS,OACP,GACA,IAIJ,MAAMiH,EAAc3T,GAAeC,QAnQb,eAoQlB0T,GACFrB,GAAM7S,YAAYkU,GAAa9J,OAEpByI,GAAM5S,oBAAoB/Y,GAClCmb,OAAO1H,KACd,IACA4G,GAAqBsR,IAMrB/b,GAAmB+b,IAcnB,MAEMsB,GAAc,gBACdC,GAAiB,YACjBC,GAAwB,OAAOF,KAAcC,KAE7CE,GAAoB,OACpBC,GAAuB,UACvBC,GAAoB,SAEpBC,GAAgB,kBAChBC,GAAe,OAAOP,KACtBQ,GAAgB,QAAQR,KACxBS,GAAe,OAAOT,KACtBU,GAAuB,gBAAgBV,KACvCW,GAAiB,SAASX,KAC1BY,GAAe,SAASZ,KACxBa,GAAyB,QAAQb,KAAcC,KAC/Ca,GAAwB,kBAAkBd,KAE1Ce,GAAY,CAChB9F,UAAU,EACV5J,UAAU,EACVpgB,QAAQ,GAEJ+vB,GAAgB,CACpB/F,SAAU,mBACV5J,SAAU,UACVpgB,OAAQ,WAOV,MAAMgwB,WAAkB/V,GACtB,WAAAP,CAAY5kB,EAASukB,GACnBa,MAAMplB,EAASukB,GACf9D,KAAKwP,UAAW,EAChBxP,KAAKoY,UAAYpY,KAAKqY,sBACtBrY,KAAKsY,WAAatY,KAAKuY,uBACvBvY,KAAK0L,oBACP,CAGA,kBAAWhI,GACT,OAAO6W,EACT,CACA,sBAAW5W,GACT,OAAO6W,EACT,CACA,eAAWje,GACT,MApDW,WAqDb,CAGA,MAAAmL,CAAO5H,GACL,OAAOE,KAAKwP,SAAWxP,KAAKyP,OAASzP,KAAK0P,KAAK5P,EACjD,CACA,IAAA4P,CAAK5P,GACCE,KAAKwP,UAGSjP,GAAaqB,QAAQ5B,KAAK4E,SAAUmV,GAAc,CAClEja,kBAEYkC,mBAGdhC,KAAKwP,UAAW,EAChBxP,KAAKoY,UAAU1I,OACV1P,KAAK6E,QAAQpa,SAChB,IAAIurB,IAAkBvG,OAExBzP,KAAK4E,SAASxjB,aAAa,cAAc,GACzC4e,KAAK4E,SAASxjB,aAAa,OAAQ,UACnC4e,KAAK4E,SAASvJ,UAAU5E,IAAImjB,IAW5B5Z,KAAKmF,gBAVoB,KAClBnF,KAAK6E,QAAQpa,SAAUuV,KAAK6E,QAAQ4P,UACvCzU,KAAKsY,WAAW/C,WAElBvV,KAAK4E,SAASvJ,UAAU5E,IAAIkjB,IAC5B3Z,KAAK4E,SAASvJ,UAAU1B,OAAOigB,IAC/BrZ,GAAaqB,QAAQ5B,KAAK4E,SAAUoV,GAAe,CACjDla,iBACA,GAEkCE,KAAK4E,UAAU,GACvD,CACA,IAAA6K,GACOzP,KAAKwP,WAGQjP,GAAaqB,QAAQ5B,KAAK4E,SAAUqV,IACxCjY,mBAGdhC,KAAKsY,WAAW5C,aAChB1V,KAAK4E,SAAS8V,OACd1a,KAAKwP,UAAW,EAChBxP,KAAK4E,SAASvJ,UAAU5E,IAAIojB,IAC5B7Z,KAAKoY,UAAU3I,OAUfzP,KAAKmF,gBAToB,KACvBnF,KAAK4E,SAASvJ,UAAU1B,OAAOggB,GAAmBE,IAClD7Z,KAAK4E,SAASzjB,gBAAgB,cAC9B6e,KAAK4E,SAASzjB,gBAAgB,QACzB6e,KAAK6E,QAAQpa,SAChB,IAAIurB,IAAkB3jB,QAExBkO,GAAaqB,QAAQ5B,KAAK4E,SAAUuV,GAAe,GAEfna,KAAK4E,UAAU,IACvD,CACA,OAAAG,GACE/E,KAAKoY,UAAUrT,UACf/E,KAAKsY,WAAW5C,aAChB/Q,MAAMI,SACR,CAGA,mBAAAsT,GACE,MASM1d,EAAYmG,QAAQd,KAAK6E,QAAQ4P,UACvC,OAAO,IAAIL,GAAS,CAClBJ,UA3HsB,qBA4HtBrZ,YACAyK,YAAY,EACZ8O,YAAalU,KAAK4E,SAAS7f,WAC3BkvB,cAAetZ,EAfK,KACU,WAA1BqF,KAAK6E,QAAQ4P,SAIjBzU,KAAKyP,OAHHlP,GAAaqB,QAAQ5B,KAAK4E,SAAUsV,GAG3B,EAUgC,MAE/C,CACA,oBAAA3B,GACE,OAAO,IAAInD,GAAU,CACnBF,YAAalV,KAAK4E,UAEtB,CACA,kBAAA8G,GACEnL,GAAac,GAAGrB,KAAK4E,SAAU0V,IAAuBlb,IA5IvC,WA6ITA,EAAMtiB,MAGNkjB,KAAK6E,QAAQgG,SACf7K,KAAKyP,OAGPlP,GAAaqB,QAAQ5B,KAAK4E,SAAUsV,IAAqB,GAE7D,CAGA,sBAAOzd,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAOowB,GAAUnV,oBAAoBtF,KAAM8D,GACjD,GAAsB,iBAAXA,EAAX,CAGA,QAAqB/K,IAAjB1O,EAAKyZ,IAAyBA,EAAOrC,WAAW,MAAmB,gBAAXqC,EAC1D,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,GAAQ9D,KAJb,CAKF,GACF,EAOFO,GAAac,GAAGhc,SAAUg1B,GA7JK,gCA6J2C,SAAUjb,GAClF,MAAM7S,EAASqZ,GAAec,uBAAuB1G,MAIrD,GAHI,CAAC,IAAK,QAAQoB,SAASpB,KAAKgH,UAC9B5H,EAAMkD,iBAEJpH,GAAW8E,MACb,OAEFO,GAAae,IAAI/U,EAAQ4tB,IAAgB,KAEnCxf,GAAUqF,OACZA,KAAKsS,OACP,IAIF,MAAMiH,EAAc3T,GAAeC,QAAQiU,IACvCP,GAAeA,IAAgBhtB,GACjCkuB,GAAUpV,YAAYkU,GAAa9J,OAExBgL,GAAUnV,oBAAoB/Y,GACtCmb,OAAO1H,KACd,IACAO,GAAac,GAAGzhB,OAAQ85B,IAAuB,KAC7C,IAAK,MAAM3f,KAAY6L,GAAezT,KAAK2nB,IACzCW,GAAUnV,oBAAoBvL,GAAU2V,MAC1C,IAEFnP,GAAac,GAAGzhB,OAAQw6B,IAAc,KACpC,IAAK,MAAM76B,KAAWqmB,GAAezT,KAAK,gDACG,UAAvClN,iBAAiB1F,GAASiC,UAC5Bi5B,GAAUnV,oBAAoB/lB,GAASkwB,MAE3C,IAEF7I,GAAqB6T,IAMrBte,GAAmBse,IAUnB,MACME,GAAmB,CAEvB,IAAK,CAAC,QAAS,MAAO,KAAM,OAAQ,OAHP,kBAI7B9pB,EAAG,CAAC,SAAU,OAAQ,QAAS,OAC/B+pB,KAAM,GACN9pB,EAAG,GACH+pB,GAAI,GACJC,IAAK,GACLC,KAAM,GACNC,IAAK,GACLC,GAAI,GACJC,GAAI,GACJC,GAAI,GACJC,GAAI,GACJC,GAAI,GACJC,GAAI,GACJC,GAAI,GACJC,GAAI,GACJnqB,EAAG,GACHub,IAAK,CAAC,MAAO,SAAU,MAAO,QAAS,QAAS,UAChD6O,GAAI,GACJC,GAAI,GACJC,EAAG,GACHC,IAAK,GACLC,EAAG,GACHC,MAAO,GACPC,KAAM,GACNC,IAAK,GACLC,IAAK,GACLC,OAAQ,GACRC,EAAG,GACHC,GAAI,IAIAC,GAAgB,IAAI/lB,IAAI,CAAC,aAAc,OAAQ,OAAQ,WAAY,WAAY,SAAU,MAAO,eAShGgmB,GAAmB,0DACnBC,GAAmB,CAACx6B,EAAWy6B,KACnC,MAAMC,EAAgB16B,EAAUvC,SAASC,cACzC,OAAI+8B,EAAqBpb,SAASqb,IAC5BJ,GAAc1lB,IAAI8lB,IACb3b,QAAQwb,GAAiBj5B,KAAKtB,EAAU26B,YAM5CF,EAAqBr2B,QAAOw2B,GAAkBA,aAA0BpY,SAAQ9R,MAAKmqB,GAASA,EAAMv5B,KAAKo5B,IAAe,EA0C3HI,GAAY,CAChBC,UAAWnC,GACXoC,QAAS,CAAC,EAEVC,WAAY,GACZnwB,MAAM,EACNowB,UAAU,EACVC,WAAY,KACZC,SAAU,eAENC,GAAgB,CACpBN,UAAW,SACXC,QAAS,SACTC,WAAY,oBACZnwB,KAAM,UACNowB,SAAU,UACVC,WAAY,kBACZC,SAAU,UAENE,GAAqB,CACzBC,MAAO,iCACPvjB,SAAU,oBAOZ,MAAMwjB,WAAwB9Z,GAC5B,WAAAU,CAAYL,GACVa,QACA3E,KAAK6E,QAAU7E,KAAK6D,WAAWC,EACjC,CAGA,kBAAWJ,GACT,OAAOmZ,EACT,CACA,sBAAWlZ,GACT,OAAOyZ,EACT,CACA,eAAW7gB,GACT,MA3CW,iBA4Cb,CAGA,UAAAihB,GACE,OAAOxgC,OAAOmiB,OAAOa,KAAK6E,QAAQkY,SAASj6B,KAAIghB,GAAU9D,KAAKyd,yBAAyB3Z,KAAS3d,OAAO2a,QACzG,CACA,UAAA4c,GACE,OAAO1d,KAAKwd,aAAa9sB,OAAS,CACpC,CACA,aAAAitB,CAAcZ,GAMZ,OALA/c,KAAK4d,cAAcb,GACnB/c,KAAK6E,QAAQkY,QAAU,IAClB/c,KAAK6E,QAAQkY,WACbA,GAEE/c,IACT,CACA,MAAA6d,GACE,MAAMC,EAAkBz4B,SAASqvB,cAAc,OAC/CoJ,EAAgBC,UAAY/d,KAAKge,eAAehe,KAAK6E,QAAQsY,UAC7D,IAAK,MAAOpjB,EAAUkkB,KAASjhC,OAAOmkB,QAAQnB,KAAK6E,QAAQkY,SACzD/c,KAAKke,YAAYJ,EAAiBG,EAAMlkB,GAE1C,MAAMojB,EAAWW,EAAgBhY,SAAS,GACpCkX,EAAahd,KAAKyd,yBAAyBzd,KAAK6E,QAAQmY,YAI9D,OAHIA,GACFG,EAAS9hB,UAAU5E,OAAOumB,EAAW96B,MAAM,MAEtCi7B,CACT,CAGA,gBAAAlZ,CAAiBH,GACfa,MAAMV,iBAAiBH,GACvB9D,KAAK4d,cAAc9Z,EAAOiZ,QAC5B,CACA,aAAAa,CAAcO,GACZ,IAAK,MAAOpkB,EAAUgjB,KAAY//B,OAAOmkB,QAAQgd,GAC/CxZ,MAAMV,iBAAiB,CACrBlK,WACAujB,MAAOP,GACNM,GAEP,CACA,WAAAa,CAAYf,EAAUJ,EAAShjB,GAC7B,MAAMqkB,EAAkBxY,GAAeC,QAAQ9L,EAAUojB,GACpDiB,KAGLrB,EAAU/c,KAAKyd,yBAAyBV,IAKpC,GAAUA,GACZ/c,KAAKqe,sBAAsB3jB,GAAWqiB,GAAUqB,GAG9Cpe,KAAK6E,QAAQhY,KACfuxB,EAAgBL,UAAY/d,KAAKge,eAAejB,GAGlDqB,EAAgBE,YAAcvB,EAX5BqB,EAAgBzkB,SAYpB,CACA,cAAAqkB,CAAeG,GACb,OAAOne,KAAK6E,QAAQoY,SApJxB,SAAsBsB,EAAYzB,EAAW0B,GAC3C,IAAKD,EAAW7tB,OACd,OAAO6tB,EAET,GAAIC,GAAgD,mBAArBA,EAC7B,OAAOA,EAAiBD,GAE1B,MACME,GADY,IAAI7+B,OAAO8+B,WACKC,gBAAgBJ,EAAY,aACxD19B,EAAW,GAAGlC,UAAU8/B,EAAgBvyB,KAAKkU,iBAAiB,MACpE,IAAK,MAAM7gB,KAAWsB,EAAU,CAC9B,MAAM+9B,EAAcr/B,EAAQC,SAASC,cACrC,IAAKzC,OAAO4D,KAAKk8B,GAAW1b,SAASwd,GAAc,CACjDr/B,EAAQoa,SACR,QACF,CACA,MAAMklB,EAAgB,GAAGlgC,UAAUY,EAAQ0B,YACrC69B,EAAoB,GAAGngC,OAAOm+B,EAAU,MAAQ,GAAIA,EAAU8B,IAAgB,IACpF,IAAK,MAAM78B,KAAa88B,EACjBtC,GAAiBx6B,EAAW+8B,IAC/Bv/B,EAAQ4B,gBAAgBY,EAAUvC,SAGxC,CACA,OAAOi/B,EAAgBvyB,KAAK6xB,SAC9B,CA2HmCgB,CAAaZ,EAAKne,KAAK6E,QAAQiY,UAAW9c,KAAK6E,QAAQqY,YAAciB,CACtG,CACA,wBAAAV,CAAyBU,GACvB,OAAOthB,GAAQshB,EAAK,CAACne,MACvB,CACA,qBAAAqe,CAAsB9+B,EAAS6+B,GAC7B,GAAIpe,KAAK6E,QAAQhY,KAGf,OAFAuxB,EAAgBL,UAAY,QAC5BK,EAAgBzJ,OAAOp1B,GAGzB6+B,EAAgBE,YAAc/+B,EAAQ++B,WACxC,EAeF,MACMU,GAAwB,IAAI1oB,IAAI,CAAC,WAAY,YAAa,eAC1D2oB,GAAoB,OAEpBC,GAAoB,OAEpBC,GAAiB,SACjBC,GAAmB,gBACnBC,GAAgB,QAChBC,GAAgB,QAahBC,GAAgB,CACpBC,KAAM,OACNC,IAAK,MACLC,MAAOzjB,KAAU,OAAS,QAC1B0jB,OAAQ,SACRC,KAAM3jB,KAAU,QAAU,QAEtB4jB,GAAY,CAChB/C,UAAWnC,GACXmF,WAAW,EACX7xB,SAAU,kBACV8xB,WAAW,EACXC,YAAa,GACbC,MAAO,EACPjwB,mBAAoB,CAAC,MAAO,QAAS,SAAU,QAC/CnD,MAAM,EACN7E,OAAQ,CAAC,EAAG,GACZtJ,UAAW,MACXmzB,aAAc,KACdoL,UAAU,EACVC,WAAY,KACZnjB,UAAU,EACVojB,SAAU,+GACV+C,MAAO,GACPte,QAAS,eAELue,GAAgB,CACpBrD,UAAW,SACXgD,UAAW,UACX7xB,SAAU,mBACV8xB,UAAW,2BACXC,YAAa,oBACbC,MAAO,kBACPjwB,mBAAoB,QACpBnD,KAAM,UACN7E,OAAQ,0BACRtJ,UAAW,oBACXmzB,aAAc,yBACdoL,SAAU,UACVC,WAAY,kBACZnjB,SAAU,mBACVojB,SAAU,SACV+C,MAAO,4BACPte,QAAS,UAOX,MAAMwe,WAAgB1b,GACpB,WAAAP,CAAY5kB,EAASukB,GACnB,QAAsB,IAAX,EACT,MAAM,IAAIU,UAAU,+DAEtBG,MAAMplB,EAASukB,GAGf9D,KAAKqgB,YAAa,EAClBrgB,KAAKsgB,SAAW,EAChBtgB,KAAKugB,WAAa,KAClBvgB,KAAKwgB,eAAiB,CAAC,EACvBxgB,KAAKgS,QAAU,KACfhS,KAAKygB,iBAAmB,KACxBzgB,KAAK0gB,YAAc,KAGnB1gB,KAAK2gB,IAAM,KACX3gB,KAAK4gB,gBACA5gB,KAAK6E,QAAQ9K,UAChBiG,KAAK6gB,WAET,CAGA,kBAAWnd,GACT,OAAOmc,EACT,CACA,sBAAWlc,GACT,OAAOwc,EACT,CACA,eAAW5jB,GACT,MAxGW,SAyGb,CAGA,MAAAukB,GACE9gB,KAAKqgB,YAAa,CACpB,CACA,OAAAU,GACE/gB,KAAKqgB,YAAa,CACpB,CACA,aAAAW,GACEhhB,KAAKqgB,YAAcrgB,KAAKqgB,UAC1B,CACA,MAAA3Y,GACO1H,KAAKqgB,aAGVrgB,KAAKwgB,eAAeS,OAASjhB,KAAKwgB,eAAeS,MAC7CjhB,KAAKwP,WACPxP,KAAKkhB,SAGPlhB,KAAKmhB,SACP,CACA,OAAApc,GACEgI,aAAa/M,KAAKsgB,UAClB/f,GAAaC,IAAIR,KAAK4E,SAAS5J,QAAQmkB,IAAiBC,GAAkBpf,KAAKohB,mBAC3EphB,KAAK4E,SAASpJ,aAAa,2BAC7BwE,KAAK4E,SAASxjB,aAAa,QAAS4e,KAAK4E,SAASpJ,aAAa,2BAEjEwE,KAAKqhB,iBACL1c,MAAMI,SACR,CACA,IAAA2K,GACE,GAAoC,SAAhC1P,KAAK4E,SAAS7jB,MAAM6wB,QACtB,MAAM,IAAIhO,MAAM,uCAElB,IAAM5D,KAAKshB,mBAAoBthB,KAAKqgB,WAClC,OAEF,MAAM/G,EAAY/Y,GAAaqB,QAAQ5B,KAAK4E,SAAU5E,KAAKmE,YAAYqB,UAlItD,SAoIX+b,GADa9lB,GAAeuE,KAAK4E,WACL5E,KAAK4E,SAAS9kB,cAAcwF,iBAAiBd,SAASwb,KAAK4E,UAC7F,GAAI0U,EAAUtX,mBAAqBuf,EACjC,OAIFvhB,KAAKqhB,iBACL,MAAMV,EAAM3gB,KAAKwhB,iBACjBxhB,KAAK4E,SAASxjB,aAAa,mBAAoBu/B,EAAInlB,aAAa,OAChE,MAAM,UACJukB,GACE/f,KAAK6E,QAYT,GAXK7E,KAAK4E,SAAS9kB,cAAcwF,gBAAgBd,SAASwb,KAAK2gB,OAC7DZ,EAAUpL,OAAOgM,GACjBpgB,GAAaqB,QAAQ5B,KAAK4E,SAAU5E,KAAKmE,YAAYqB,UAhJpC,cAkJnBxF,KAAKgS,QAAUhS,KAAKqS,cAAcsO,GAClCA,EAAItlB,UAAU5E,IAAIyoB,IAMd,iBAAkB75B,SAASC,gBAC7B,IAAK,MAAM/F,IAAW,GAAGZ,UAAU0G,SAAS6G,KAAK4Z,UAC/CvF,GAAac,GAAG9hB,EAAS,YAAaqc,IAU1CoE,KAAKmF,gBAPY,KACf5E,GAAaqB,QAAQ5B,KAAK4E,SAAU5E,KAAKmE,YAAYqB,UAhKrC,WAiKQ,IAApBxF,KAAKugB,YACPvgB,KAAKkhB,SAEPlhB,KAAKugB,YAAa,CAAK,GAEKvgB,KAAK2gB,IAAK3gB,KAAK6N,cAC/C,CACA,IAAA4B,GACE,GAAKzP,KAAKwP,aAGQjP,GAAaqB,QAAQ5B,KAAK4E,SAAU5E,KAAKmE,YAAYqB,UA/KtD,SAgLHxD,iBAAd,CAQA,GALYhC,KAAKwhB,iBACbnmB,UAAU1B,OAAOulB,IAIjB,iBAAkB75B,SAASC,gBAC7B,IAAK,MAAM/F,IAAW,GAAGZ,UAAU0G,SAAS6G,KAAK4Z,UAC/CvF,GAAaC,IAAIjhB,EAAS,YAAaqc,IAG3CoE,KAAKwgB,eAA4B,OAAI,EACrCxgB,KAAKwgB,eAAelB,KAAiB,EACrCtf,KAAKwgB,eAAenB,KAAiB,EACrCrf,KAAKugB,WAAa,KAYlBvgB,KAAKmF,gBAVY,KACXnF,KAAKyhB,yBAGJzhB,KAAKugB,YACRvgB,KAAKqhB,iBAEPrhB,KAAK4E,SAASzjB,gBAAgB,oBAC9Bof,GAAaqB,QAAQ5B,KAAK4E,SAAU5E,KAAKmE,YAAYqB,UAzMpC,WAyM8D,GAEnDxF,KAAK2gB,IAAK3gB,KAAK6N,cA1B7C,CA2BF,CACA,MAAA9iB,GACMiV,KAAKgS,SACPhS,KAAKgS,QAAQjnB,QAEjB,CAGA,cAAAu2B,GACE,OAAOxgB,QAAQd,KAAK0hB,YACtB,CACA,cAAAF,GAIE,OAHKxhB,KAAK2gB,MACR3gB,KAAK2gB,IAAM3gB,KAAK2hB,kBAAkB3hB,KAAK0gB,aAAe1gB,KAAK4hB,2BAEtD5hB,KAAK2gB,GACd,CACA,iBAAAgB,CAAkB5E,GAChB,MAAM4D,EAAM3gB,KAAK6hB,oBAAoB9E,GAASc,SAG9C,IAAK8C,EACH,OAAO,KAETA,EAAItlB,UAAU1B,OAAOslB,GAAmBC,IAExCyB,EAAItlB,UAAU5E,IAAI,MAAMuJ,KAAKmE,YAAY5H,aACzC,MAAMulB,EAvuGKC,KACb,GACEA,GAAU5/B,KAAK6/B,MA/BH,IA+BS7/B,KAAK8/B,gBACnB58B,SAAS68B,eAAeH,IACjC,OAAOA,CAAM,EAmuGGI,CAAOniB,KAAKmE,YAAY5H,MAAM1c,WAK5C,OAJA8gC,EAAIv/B,aAAa,KAAM0gC,GACnB9hB,KAAK6N,eACP8S,EAAItlB,UAAU5E,IAAIwoB,IAEb0B,CACT,CACA,UAAAyB,CAAWrF,GACT/c,KAAK0gB,YAAc3D,EACf/c,KAAKwP,aACPxP,KAAKqhB,iBACLrhB,KAAK0P,OAET,CACA,mBAAAmS,CAAoB9E,GAYlB,OAXI/c,KAAKygB,iBACPzgB,KAAKygB,iBAAiB9C,cAAcZ,GAEpC/c,KAAKygB,iBAAmB,IAAIlD,GAAgB,IACvCvd,KAAK6E,QAGRkY,UACAC,WAAYhd,KAAKyd,yBAAyBzd,KAAK6E,QAAQmb,eAGpDhgB,KAAKygB,gBACd,CACA,sBAAAmB,GACE,MAAO,CACL,iBAA0B5hB,KAAK0hB,YAEnC,CACA,SAAAA,GACE,OAAO1hB,KAAKyd,yBAAyBzd,KAAK6E,QAAQqb,QAAUlgB,KAAK4E,SAASpJ,aAAa,yBACzF,CAGA,4BAAA6mB,CAA6BjjB,GAC3B,OAAOY,KAAKmE,YAAYmB,oBAAoBlG,EAAMW,eAAgBC,KAAKsiB,qBACzE,CACA,WAAAzU,GACE,OAAO7N,KAAK6E,QAAQib,WAAa9f,KAAK2gB,KAAO3gB,KAAK2gB,IAAItlB,UAAU7W,SAASy6B,GAC3E,CACA,QAAAzP,GACE,OAAOxP,KAAK2gB,KAAO3gB,KAAK2gB,IAAItlB,UAAU7W,SAAS06B,GACjD,CACA,aAAA7M,CAAcsO,GACZ,MAAMjiC,EAAYme,GAAQmD,KAAK6E,QAAQnmB,UAAW,CAACshB,KAAM2gB,EAAK3gB,KAAK4E,WAC7D2d,EAAahD,GAAc7gC,EAAU+lB,eAC3C,OAAO,GAAoBzE,KAAK4E,SAAU+b,EAAK3gB,KAAKyS,iBAAiB8P,GACvE,CACA,UAAA1P,GACE,MAAM,OACJ7qB,GACEgY,KAAK6E,QACT,MAAsB,iBAAX7c,EACFA,EAAO9F,MAAM,KAAKY,KAAInF,GAAS4f,OAAO6P,SAASzvB,EAAO,MAEzC,mBAAXqK,EACF8qB,GAAc9qB,EAAO8qB,EAAY9S,KAAK4E,UAExC5c,CACT,CACA,wBAAAy1B,CAAyBU,GACvB,OAAOthB,GAAQshB,EAAK,CAACne,KAAK4E,UAC5B,CACA,gBAAA6N,CAAiB8P,GACf,MAAMxP,EAAwB,CAC5Br0B,UAAW6jC,EACXnsB,UAAW,CAAC,CACV9V,KAAM,OACNmB,QAAS,CACPuO,mBAAoBgQ,KAAK6E,QAAQ7U,qBAElC,CACD1P,KAAM,SACNmB,QAAS,CACPuG,OAAQgY,KAAK6S,eAEd,CACDvyB,KAAM,kBACNmB,QAAS,CACPwM,SAAU+R,KAAK6E,QAAQ5W,WAExB,CACD3N,KAAM,QACNmB,QAAS,CACPlC,QAAS,IAAIygB,KAAKmE,YAAY5H,eAE/B,CACDjc,KAAM,kBACNC,SAAS,EACTC,MAAO,aACPC,GAAI4J,IAGF2V,KAAKwhB,iBAAiBpgC,aAAa,wBAAyBiJ,EAAK1J,MAAMjC,UAAU,KAIvF,MAAO,IACFq0B,KACAlW,GAAQmD,KAAK6E,QAAQgN,aAAc,CAACkB,IAE3C,CACA,aAAA6N,GACE,MAAM4B,EAAWxiB,KAAK6E,QAAQjD,QAAQ1f,MAAM,KAC5C,IAAK,MAAM0f,KAAW4gB,EACpB,GAAgB,UAAZ5gB,EACFrB,GAAac,GAAGrB,KAAK4E,SAAU5E,KAAKmE,YAAYqB,UAjVlC,SAiV4DxF,KAAK6E,QAAQ9K,UAAUqF,IAC/EY,KAAKqiB,6BAA6BjjB,GAC1CsI,QAAQ,SAEb,GA3VU,WA2VN9F,EAA4B,CACrC,MAAM6gB,EAAU7gB,IAAYyd,GAAgBrf,KAAKmE,YAAYqB,UAnV5C,cAmV0ExF,KAAKmE,YAAYqB,UArV5F,WAsVVkd,EAAW9gB,IAAYyd,GAAgBrf,KAAKmE,YAAYqB,UAnV7C,cAmV2ExF,KAAKmE,YAAYqB,UArV5F,YAsVjBjF,GAAac,GAAGrB,KAAK4E,SAAU6d,EAASziB,KAAK6E,QAAQ9K,UAAUqF,IAC7D,MAAM+T,EAAUnT,KAAKqiB,6BAA6BjjB,GAClD+T,EAAQqN,eAA8B,YAAfphB,EAAMqB,KAAqB6e,GAAgBD,KAAiB,EACnFlM,EAAQgO,QAAQ,IAElB5gB,GAAac,GAAGrB,KAAK4E,SAAU8d,EAAU1iB,KAAK6E,QAAQ9K,UAAUqF,IAC9D,MAAM+T,EAAUnT,KAAKqiB,6BAA6BjjB,GAClD+T,EAAQqN,eAA8B,aAAfphB,EAAMqB,KAAsB6e,GAAgBD,IAAiBlM,EAAQvO,SAASpgB,SAAS4a,EAAMU,eACpHqT,EAAQ+N,QAAQ,GAEpB,CAEFlhB,KAAKohB,kBAAoB,KACnBphB,KAAK4E,UACP5E,KAAKyP,MACP,EAEFlP,GAAac,GAAGrB,KAAK4E,SAAS5J,QAAQmkB,IAAiBC,GAAkBpf,KAAKohB,kBAChF,CACA,SAAAP,GACE,MAAMX,EAAQlgB,KAAK4E,SAASpJ,aAAa,SACpC0kB,IAGAlgB,KAAK4E,SAASpJ,aAAa,eAAkBwE,KAAK4E,SAAS0Z,YAAY3Y,QAC1E3F,KAAK4E,SAASxjB,aAAa,aAAc8+B,GAE3ClgB,KAAK4E,SAASxjB,aAAa,yBAA0B8+B,GACrDlgB,KAAK4E,SAASzjB,gBAAgB,SAChC,CACA,MAAAggC,GACMnhB,KAAKwP,YAAcxP,KAAKugB,WAC1BvgB,KAAKugB,YAAa,GAGpBvgB,KAAKugB,YAAa,EAClBvgB,KAAK2iB,aAAY,KACX3iB,KAAKugB,YACPvgB,KAAK0P,MACP,GACC1P,KAAK6E,QAAQob,MAAMvQ,MACxB,CACA,MAAAwR,GACMlhB,KAAKyhB,yBAGTzhB,KAAKugB,YAAa,EAClBvgB,KAAK2iB,aAAY,KACV3iB,KAAKugB,YACRvgB,KAAKyP,MACP,GACCzP,KAAK6E,QAAQob,MAAMxQ,MACxB,CACA,WAAAkT,CAAY/kB,EAASglB,GACnB7V,aAAa/M,KAAKsgB,UAClBtgB,KAAKsgB,SAAWziB,WAAWD,EAASglB,EACtC,CACA,oBAAAnB,GACE,OAAOzkC,OAAOmiB,OAAOa,KAAKwgB,gBAAgBpf,UAAS,EACrD,CACA,UAAAyC,CAAWC,GACT,MAAM+e,EAAiB7f,GAAYG,kBAAkBnD,KAAK4E,UAC1D,IAAK,MAAMke,KAAiB9lC,OAAO4D,KAAKiiC,GAClC7D,GAAsBroB,IAAImsB,WACrBD,EAAeC,GAU1B,OAPAhf,EAAS,IACJ+e,KACmB,iBAAX/e,GAAuBA,EAASA,EAAS,CAAC,GAEvDA,EAAS9D,KAAK+D,gBAAgBD,GAC9BA,EAAS9D,KAAKgE,kBAAkBF,GAChC9D,KAAKiE,iBAAiBH,GACfA,CACT,CACA,iBAAAE,CAAkBF,GAchB,OAbAA,EAAOic,WAAiC,IAArBjc,EAAOic,UAAsB16B,SAAS6G,KAAOwO,GAAWoJ,EAAOic,WACtD,iBAAjBjc,EAAOmc,QAChBnc,EAAOmc,MAAQ,CACbvQ,KAAM5L,EAAOmc,MACbxQ,KAAM3L,EAAOmc,QAGW,iBAAjBnc,EAAOoc,QAChBpc,EAAOoc,MAAQpc,EAAOoc,MAAMrgC,YAEA,iBAAnBikB,EAAOiZ,UAChBjZ,EAAOiZ,QAAUjZ,EAAOiZ,QAAQl9B,YAE3BikB,CACT,CACA,kBAAAwe,GACE,MAAMxe,EAAS,CAAC,EAChB,IAAK,MAAOhnB,EAAKa,KAAUX,OAAOmkB,QAAQnB,KAAK6E,SACzC7E,KAAKmE,YAAYT,QAAQ5mB,KAASa,IACpCmmB,EAAOhnB,GAAOa,GASlB,OANAmmB,EAAO/J,UAAW,EAClB+J,EAAOlC,QAAU,SAKVkC,CACT,CACA,cAAAud,GACMrhB,KAAKgS,UACPhS,KAAKgS,QAAQhZ,UACbgH,KAAKgS,QAAU,MAEbhS,KAAK2gB,MACP3gB,KAAK2gB,IAAIhnB,SACTqG,KAAK2gB,IAAM,KAEf,CAGA,sBAAOlkB,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAO+1B,GAAQ9a,oBAAoBtF,KAAM8D,GAC/C,GAAsB,iBAAXA,EAAX,CAGA,QAA4B,IAAjBzZ,EAAKyZ,GACd,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,IAJL,CAKF,GACF,EAOF3H,GAAmBikB,IAcnB,MAGM2C,GAAY,IACb3C,GAAQ1c,QACXqZ,QAAS,GACT/0B,OAAQ,CAAC,EAAG,GACZtJ,UAAW,QACXy+B,SAAU,8IACVvb,QAAS,SAELohB,GAAgB,IACjB5C,GAAQzc,YACXoZ,QAAS,kCAOX,MAAMkG,WAAgB7C,GAEpB,kBAAW1c,GACT,OAAOqf,EACT,CACA,sBAAWpf,GACT,OAAOqf,EACT,CACA,eAAWzmB,GACT,MA7BW,SA8Bb,CAGA,cAAA+kB,GACE,OAAOthB,KAAK0hB,aAAe1hB,KAAKkjB,aAClC,CAGA,sBAAAtB,GACE,MAAO,CACL,kBAAkB5hB,KAAK0hB,YACvB,gBAAoB1hB,KAAKkjB,cAE7B,CACA,WAAAA,GACE,OAAOljB,KAAKyd,yBAAyBzd,KAAK6E,QAAQkY,QACpD,CAGA,sBAAOtgB,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAO44B,GAAQ3d,oBAAoBtF,KAAM8D,GAC/C,GAAsB,iBAAXA,EAAX,CAGA,QAA4B,IAAjBzZ,EAAKyZ,GACd,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,IAJL,CAKF,GACF,EAOF3H,GAAmB8mB,IAcnB,MAEME,GAAc,gBAEdC,GAAiB,WAAWD,KAC5BE,GAAc,QAAQF,KACtBG,GAAwB,OAAOH,cAE/BI,GAAsB,SAEtBC,GAAwB,SAExBC,GAAqB,YAGrBC,GAAsB,GAAGD,mBAA+CA,uBAGxEE,GAAY,CAChB37B,OAAQ,KAER47B,WAAY,eACZC,cAAc,EACdt3B,OAAQ,KACRu3B,UAAW,CAAC,GAAK,GAAK,IAElBC,GAAgB,CACpB/7B,OAAQ,gBAER47B,WAAY,SACZC,aAAc,UACdt3B,OAAQ,UACRu3B,UAAW,SAOb,MAAME,WAAkBtf,GACtB,WAAAP,CAAY5kB,EAASukB,GACnBa,MAAMplB,EAASukB,GAGf9D,KAAKikB,aAAe,IAAI/yB,IACxB8O,KAAKkkB,oBAAsB,IAAIhzB,IAC/B8O,KAAKmkB,aAA6D,YAA9Cl/B,iBAAiB+a,KAAK4E,UAAU5Y,UAA0B,KAAOgU,KAAK4E,SAC1F5E,KAAKokB,cAAgB,KACrBpkB,KAAKqkB,UAAY,KACjBrkB,KAAKskB,oBAAsB,CACzBC,gBAAiB,EACjBC,gBAAiB,GAEnBxkB,KAAKykB,SACP,CAGA,kBAAW/gB,GACT,OAAOigB,EACT,CACA,sBAAWhgB,GACT,OAAOogB,EACT,CACA,eAAWxnB,GACT,MAhEW,WAiEb,CAGA,OAAAkoB,GACEzkB,KAAK0kB,mCACL1kB,KAAK2kB,2BACD3kB,KAAKqkB,UACPrkB,KAAKqkB,UAAUO,aAEf5kB,KAAKqkB,UAAYrkB,KAAK6kB,kBAExB,IAAK,MAAMC,KAAW9kB,KAAKkkB,oBAAoB/kB,SAC7Ca,KAAKqkB,UAAUU,QAAQD,EAE3B,CACA,OAAA/f,GACE/E,KAAKqkB,UAAUO,aACfjgB,MAAMI,SACR,CAGA,iBAAAf,CAAkBF,GAShB,OAPAA,EAAOvX,OAASmO,GAAWoJ,EAAOvX,SAAWlH,SAAS6G,KAGtD4X,EAAO8f,WAAa9f,EAAO9b,OAAS,GAAG8b,EAAO9b,oBAAsB8b,EAAO8f,WAC3C,iBAArB9f,EAAOggB,YAChBhgB,EAAOggB,UAAYhgB,EAAOggB,UAAU5hC,MAAM,KAAKY,KAAInF,GAAS4f,OAAOC,WAAW7f,MAEzEmmB,CACT,CACA,wBAAA6gB,GACO3kB,KAAK6E,QAAQgf,eAKlBtjB,GAAaC,IAAIR,KAAK6E,QAAQtY,OAAQ82B,IACtC9iB,GAAac,GAAGrB,KAAK6E,QAAQtY,OAAQ82B,GAAaG,IAAuBpkB,IACvE,MAAM4lB,EAAoBhlB,KAAKkkB,oBAAoB/mC,IAAIiiB,EAAM7S,OAAOtB,MACpE,GAAI+5B,EAAmB,CACrB5lB,EAAMkD,iBACN,MAAM3G,EAAOqE,KAAKmkB,cAAgBvkC,OAC5BmE,EAASihC,EAAkB3gC,UAAY2b,KAAK4E,SAASvgB,UAC3D,GAAIsX,EAAKspB,SAKP,YAJAtpB,EAAKspB,SAAS,CACZtjC,IAAKoC,EACLmhC,SAAU,WAMdvpB,EAAKlQ,UAAY1H,CACnB,KAEJ,CACA,eAAA8gC,GACE,MAAMpjC,EAAU,CACdka,KAAMqE,KAAKmkB,aACXL,UAAW9jB,KAAK6E,QAAQif,UACxBF,WAAY5jB,KAAK6E,QAAQ+e,YAE3B,OAAO,IAAIuB,sBAAqBhkB,GAAWnB,KAAKolB,kBAAkBjkB,IAAU1f,EAC9E,CAGA,iBAAA2jC,CAAkBjkB,GAChB,MAAMkkB,EAAgB/H,GAAStd,KAAKikB,aAAa9mC,IAAI,IAAImgC,EAAM/wB,OAAO4N,MAChEob,EAAW+H,IACftd,KAAKskB,oBAAoBC,gBAAkBjH,EAAM/wB,OAAOlI,UACxD2b,KAAKslB,SAASD,EAAc/H,GAAO,EAE/BkH,GAAmBxkB,KAAKmkB,cAAgB9+B,SAASC,iBAAiBmG,UAClE85B,EAAkBf,GAAmBxkB,KAAKskB,oBAAoBE,gBACpExkB,KAAKskB,oBAAoBE,gBAAkBA,EAC3C,IAAK,MAAMlH,KAASnc,EAAS,CAC3B,IAAKmc,EAAMkI,eAAgB,CACzBxlB,KAAKokB,cAAgB,KACrBpkB,KAAKylB,kBAAkBJ,EAAc/H,IACrC,QACF,CACA,MAAMoI,EAA2BpI,EAAM/wB,OAAOlI,WAAa2b,KAAKskB,oBAAoBC,gBAEpF,GAAIgB,GAAmBG,GAGrB,GAFAnQ,EAAS+H,IAEJkH,EACH,YAMCe,GAAoBG,GACvBnQ,EAAS+H,EAEb,CACF,CACA,gCAAAoH,GACE1kB,KAAKikB,aAAe,IAAI/yB,IACxB8O,KAAKkkB,oBAAsB,IAAIhzB,IAC/B,MAAMy0B,EAAc/f,GAAezT,KAAKqxB,GAAuBxjB,KAAK6E,QAAQtY,QAC5E,IAAK,MAAMq5B,KAAUD,EAAa,CAEhC,IAAKC,EAAO36B,MAAQiQ,GAAW0qB,GAC7B,SAEF,MAAMZ,EAAoBpf,GAAeC,QAAQggB,UAAUD,EAAO36B,MAAO+U,KAAK4E,UAG1EjK,GAAUqqB,KACZhlB,KAAKikB,aAAalyB,IAAI8zB,UAAUD,EAAO36B,MAAO26B,GAC9C5lB,KAAKkkB,oBAAoBnyB,IAAI6zB,EAAO36B,KAAM+5B,GAE9C,CACF,CACA,QAAAM,CAAS/4B,GACHyT,KAAKokB,gBAAkB73B,IAG3ByT,KAAKylB,kBAAkBzlB,KAAK6E,QAAQtY,QACpCyT,KAAKokB,cAAgB73B,EACrBA,EAAO8O,UAAU5E,IAAI8sB,IACrBvjB,KAAK8lB,iBAAiBv5B,GACtBgU,GAAaqB,QAAQ5B,KAAK4E,SAAUwe,GAAgB,CAClDtjB,cAAevT,IAEnB,CACA,gBAAAu5B,CAAiBv5B,GAEf,GAAIA,EAAO8O,UAAU7W,SA9LQ,iBA+L3BohB,GAAeC,QArLc,mBAqLsBtZ,EAAOyO,QAtLtC,cAsLkEK,UAAU5E,IAAI8sB,SAGtG,IAAK,MAAMwC,KAAangB,GAAeI,QAAQzZ,EA9LnB,qBAiM1B,IAAK,MAAMxJ,KAAQ6iB,GAAeM,KAAK6f,EAAWrC,IAChD3gC,EAAKsY,UAAU5E,IAAI8sB,GAGzB,CACA,iBAAAkC,CAAkBhhC,GAChBA,EAAO4W,UAAU1B,OAAO4pB,IACxB,MAAMyC,EAAcpgB,GAAezT,KAAK,GAAGqxB,MAAyBD,KAAuB9+B,GAC3F,IAAK,MAAM9E,KAAQqmC,EACjBrmC,EAAK0b,UAAU1B,OAAO4pB,GAE1B,CAGA,sBAAO9mB,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAO25B,GAAU1e,oBAAoBtF,KAAM8D,GACjD,GAAsB,iBAAXA,EAAX,CAGA,QAAqB/K,IAAjB1O,EAAKyZ,IAAyBA,EAAOrC,WAAW,MAAmB,gBAAXqC,EAC1D,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,IAJL,CAKF,GACF,EAOFvD,GAAac,GAAGzhB,OAAQ0jC,IAAuB,KAC7C,IAAK,MAAM2C,KAAOrgB,GAAezT,KApOT,0BAqOtB6xB,GAAU1e,oBAAoB2gB,EAChC,IAOF9pB,GAAmB6nB,IAcnB,MAEMkC,GAAc,UACdC,GAAe,OAAOD,KACtBE,GAAiB,SAASF,KAC1BG,GAAe,OAAOH,KACtBI,GAAgB,QAAQJ,KACxBK,GAAuB,QAAQL,KAC/BM,GAAgB,UAAUN,KAC1BO,GAAsB,OAAOP,KAC7BQ,GAAiB,YACjBC,GAAkB,aAClBC,GAAe,UACfC,GAAiB,YACjBC,GAAW,OACXC,GAAU,MACVC,GAAoB,SACpBC,GAAoB,OACpBC,GAAoB,OAEpBC,GAA2B,mBAE3BC,GAA+B,QAAQD,MAIvCE,GAAuB,2EACvBC,GAAsB,YAFOF,uBAAiDA,mBAA6CA,OAE/EC,KAC5CE,GAA8B,IAAIP,8BAA6CA,+BAA8CA,4BAMnI,MAAMQ,WAAY9iB,GAChB,WAAAP,CAAY5kB,GACVolB,MAAMplB,GACNygB,KAAKiS,QAAUjS,KAAK4E,SAAS5J,QAdN,uCAelBgF,KAAKiS,UAOVjS,KAAKynB,sBAAsBznB,KAAKiS,QAASjS,KAAK0nB,gBAC9CnnB,GAAac,GAAGrB,KAAK4E,SAAU4hB,IAAepnB,GAASY,KAAK0M,SAAStN,KACvE,CAGA,eAAW7C,GACT,MAnDW,KAoDb,CAGA,IAAAmT,GAEE,MAAMiY,EAAY3nB,KAAK4E,SACvB,GAAI5E,KAAK4nB,cAAcD,GACrB,OAIF,MAAME,EAAS7nB,KAAK8nB,iBACdC,EAAYF,EAAStnB,GAAaqB,QAAQimB,EAAQ1B,GAAc,CACpErmB,cAAe6nB,IACZ,KACapnB,GAAaqB,QAAQ+lB,EAAWtB,GAAc,CAC9DvmB,cAAe+nB,IAEH7lB,kBAAoB+lB,GAAaA,EAAU/lB,mBAGzDhC,KAAKgoB,YAAYH,EAAQF,GACzB3nB,KAAKioB,UAAUN,EAAWE,GAC5B,CAGA,SAAAI,CAAU1oC,EAAS2oC,GACZ3oC,IAGLA,EAAQ8b,UAAU5E,IAAIuwB,IACtBhnB,KAAKioB,UAAUriB,GAAec,uBAAuBnnB,IAcrDygB,KAAKmF,gBAZY,KACsB,QAAjC5lB,EAAQic,aAAa,SAIzBjc,EAAQ4B,gBAAgB,YACxB5B,EAAQ6B,aAAa,iBAAiB,GACtC4e,KAAKmoB,gBAAgB5oC,GAAS,GAC9BghB,GAAaqB,QAAQriB,EAAS+mC,GAAe,CAC3CxmB,cAAeooB,KAPf3oC,EAAQ8b,UAAU5E,IAAIywB,GAQtB,GAE0B3nC,EAASA,EAAQ8b,UAAU7W,SAASyiC,KACpE,CACA,WAAAe,CAAYzoC,EAAS2oC,GACd3oC,IAGLA,EAAQ8b,UAAU1B,OAAOqtB,IACzBznC,EAAQm7B,OACR1a,KAAKgoB,YAAYpiB,GAAec,uBAAuBnnB,IAcvDygB,KAAKmF,gBAZY,KACsB,QAAjC5lB,EAAQic,aAAa,SAIzBjc,EAAQ6B,aAAa,iBAAiB,GACtC7B,EAAQ6B,aAAa,WAAY,MACjC4e,KAAKmoB,gBAAgB5oC,GAAS,GAC9BghB,GAAaqB,QAAQriB,EAAS6mC,GAAgB,CAC5CtmB,cAAeooB,KAPf3oC,EAAQ8b,UAAU1B,OAAOutB,GAQzB,GAE0B3nC,EAASA,EAAQ8b,UAAU7W,SAASyiC,KACpE,CACA,QAAAva,CAAStN,GACP,IAAK,CAACsnB,GAAgBC,GAAiBC,GAAcC,GAAgBC,GAAUC,IAAS3lB,SAAShC,EAAMtiB,KACrG,OAEFsiB,EAAMuU,kBACNvU,EAAMkD,iBACN,MAAMwD,EAAW9F,KAAK0nB,eAAevhC,QAAO5G,IAAY2b,GAAW3b,KACnE,IAAI6oC,EACJ,GAAI,CAACtB,GAAUC,IAAS3lB,SAAShC,EAAMtiB,KACrCsrC,EAAoBtiB,EAAS1G,EAAMtiB,MAAQgqC,GAAW,EAAIhhB,EAASpV,OAAS,OACvE,CACL,MAAM2c,EAAS,CAACsZ,GAAiBE,IAAgBzlB,SAAShC,EAAMtiB,KAChEsrC,EAAoBtqB,GAAqBgI,EAAU1G,EAAM7S,OAAQ8gB,GAAQ,EAC3E,CACI+a,IACFA,EAAkB9V,MAAM,CACtB+V,eAAe,IAEjBb,GAAIliB,oBAAoB8iB,GAAmB1Y,OAE/C,CACA,YAAAgY,GAEE,OAAO9hB,GAAezT,KAAKm1B,GAAqBtnB,KAAKiS,QACvD,CACA,cAAA6V,GACE,OAAO9nB,KAAK0nB,eAAev1B,MAAKzN,GAASsb,KAAK4nB,cAAcljC,MAAW,IACzE,CACA,qBAAA+iC,CAAsBhjC,EAAQqhB,GAC5B9F,KAAKsoB,yBAAyB7jC,EAAQ,OAAQ,WAC9C,IAAK,MAAMC,KAASohB,EAClB9F,KAAKuoB,6BAA6B7jC,EAEtC,CACA,4BAAA6jC,CAA6B7jC,GAC3BA,EAAQsb,KAAKwoB,iBAAiB9jC,GAC9B,MAAM+jC,EAAWzoB,KAAK4nB,cAAcljC,GAC9BgkC,EAAY1oB,KAAK2oB,iBAAiBjkC,GACxCA,EAAMtD,aAAa,gBAAiBqnC,GAChCC,IAAchkC,GAChBsb,KAAKsoB,yBAAyBI,EAAW,OAAQ,gBAE9CD,GACH/jC,EAAMtD,aAAa,WAAY,MAEjC4e,KAAKsoB,yBAAyB5jC,EAAO,OAAQ,OAG7Csb,KAAK4oB,mCAAmClkC,EAC1C,CACA,kCAAAkkC,CAAmClkC,GACjC,MAAM6H,EAASqZ,GAAec,uBAAuBhiB,GAChD6H,IAGLyT,KAAKsoB,yBAAyB/7B,EAAQ,OAAQ,YAC1C7H,EAAMyV,IACR6F,KAAKsoB,yBAAyB/7B,EAAQ,kBAAmB,GAAG7H,EAAMyV,MAEtE,CACA,eAAAguB,CAAgB5oC,EAASspC,GACvB,MAAMH,EAAY1oB,KAAK2oB,iBAAiBppC,GACxC,IAAKmpC,EAAUrtB,UAAU7W,SApKN,YAqKjB,OAEF,MAAMkjB,EAAS,CAAC3N,EAAUia,KACxB,MAAMz0B,EAAUqmB,GAAeC,QAAQ9L,EAAU2uB,GAC7CnpC,GACFA,EAAQ8b,UAAUqM,OAAOsM,EAAW6U,EACtC,EAEFnhB,EAAOyf,GAA0BH,IACjCtf,EA5K2B,iBA4KIwf,IAC/BwB,EAAUtnC,aAAa,gBAAiBynC,EAC1C,CACA,wBAAAP,CAAyB/oC,EAASwC,EAAWpE,GACtC4B,EAAQgc,aAAaxZ,IACxBxC,EAAQ6B,aAAaW,EAAWpE,EAEpC,CACA,aAAAiqC,CAAczY,GACZ,OAAOA,EAAK9T,UAAU7W,SAASwiC,GACjC,CAGA,gBAAAwB,CAAiBrZ,GACf,OAAOA,EAAKpJ,QAAQuhB,IAAuBnY,EAAOvJ,GAAeC,QAAQyhB,GAAqBnY,EAChG,CAGA,gBAAAwZ,CAAiBxZ,GACf,OAAOA,EAAKnU,QA5LO,gCA4LoBmU,CACzC,CAGA,sBAAO1S,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAOm9B,GAAIliB,oBAAoBtF,MACrC,GAAsB,iBAAX8D,EAAX,CAGA,QAAqB/K,IAAjB1O,EAAKyZ,IAAyBA,EAAOrC,WAAW,MAAmB,gBAAXqC,EAC1D,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,IAJL,CAKF,GACF,EAOFvD,GAAac,GAAGhc,SAAUkhC,GAAsBc,IAAsB,SAAUjoB,GAC1E,CAAC,IAAK,QAAQgC,SAASpB,KAAKgH,UAC9B5H,EAAMkD,iBAEJpH,GAAW8E,OAGfwnB,GAAIliB,oBAAoBtF,MAAM0P,MAChC,IAKAnP,GAAac,GAAGzhB,OAAQ6mC,IAAqB,KAC3C,IAAK,MAAMlnC,KAAWqmB,GAAezT,KAAKo1B,IACxCC,GAAIliB,oBAAoB/lB,EAC1B,IAMF4c,GAAmBqrB,IAcnB,MAEMxiB,GAAY,YACZ8jB,GAAkB,YAAY9jB,KAC9B+jB,GAAiB,WAAW/jB,KAC5BgkB,GAAgB,UAAUhkB,KAC1BikB,GAAiB,WAAWjkB,KAC5BkkB,GAAa,OAAOlkB,KACpBmkB,GAAe,SAASnkB,KACxBokB,GAAa,OAAOpkB,KACpBqkB,GAAc,QAAQrkB,KAEtBskB,GAAkB,OAClBC,GAAkB,OAClBC,GAAqB,UACrB7lB,GAAc,CAClBmc,UAAW,UACX2J,SAAU,UACVxJ,MAAO,UAEHvc,GAAU,CACdoc,WAAW,EACX2J,UAAU,EACVxJ,MAAO,KAOT,MAAMyJ,WAAchlB,GAClB,WAAAP,CAAY5kB,EAASukB,GACnBa,MAAMplB,EAASukB,GACf9D,KAAKsgB,SAAW,KAChBtgB,KAAK2pB,sBAAuB,EAC5B3pB,KAAK4pB,yBAA0B,EAC/B5pB,KAAK4gB,eACP,CAGA,kBAAWld,GACT,OAAOA,EACT,CACA,sBAAWC,GACT,OAAOA,EACT,CACA,eAAWpH,GACT,MA/CS,OAgDX,CAGA,IAAAmT,GACoBnP,GAAaqB,QAAQ5B,KAAK4E,SAAUwkB,IACxCpnB,mBAGdhC,KAAK6pB,gBACD7pB,KAAK6E,QAAQib,WACf9f,KAAK4E,SAASvJ,UAAU5E,IA/CN,QAsDpBuJ,KAAK4E,SAASvJ,UAAU1B,OAAO2vB,IAC/BztB,GAAOmE,KAAK4E,UACZ5E,KAAK4E,SAASvJ,UAAU5E,IAAI8yB,GAAiBC,IAC7CxpB,KAAKmF,gBARY,KACfnF,KAAK4E,SAASvJ,UAAU1B,OAAO6vB,IAC/BjpB,GAAaqB,QAAQ5B,KAAK4E,SAAUykB,IACpCrpB,KAAK8pB,oBAAoB,GAKG9pB,KAAK4E,SAAU5E,KAAK6E,QAAQib,WAC5D,CACA,IAAArQ,GACOzP,KAAK+pB,YAGQxpB,GAAaqB,QAAQ5B,KAAK4E,SAAUskB,IACxClnB,mBAQdhC,KAAK4E,SAASvJ,UAAU5E,IAAI+yB,IAC5BxpB,KAAKmF,gBANY,KACfnF,KAAK4E,SAASvJ,UAAU5E,IAAI6yB,IAC5BtpB,KAAK4E,SAASvJ,UAAU1B,OAAO6vB,GAAoBD,IACnDhpB,GAAaqB,QAAQ5B,KAAK4E,SAAUukB,GAAa,GAGrBnpB,KAAK4E,SAAU5E,KAAK6E,QAAQib,YAC5D,CACA,OAAA/a,GACE/E,KAAK6pB,gBACD7pB,KAAK+pB,WACP/pB,KAAK4E,SAASvJ,UAAU1B,OAAO4vB,IAEjC5kB,MAAMI,SACR,CACA,OAAAglB,GACE,OAAO/pB,KAAK4E,SAASvJ,UAAU7W,SAAS+kC,GAC1C,CAIA,kBAAAO,GACO9pB,KAAK6E,QAAQ4kB,WAGdzpB,KAAK2pB,sBAAwB3pB,KAAK4pB,0BAGtC5pB,KAAKsgB,SAAWziB,YAAW,KACzBmC,KAAKyP,MAAM,GACVzP,KAAK6E,QAAQob,QAClB,CACA,cAAA+J,CAAe5qB,EAAO6qB,GACpB,OAAQ7qB,EAAMqB,MACZ,IAAK,YACL,IAAK,WAEDT,KAAK2pB,qBAAuBM,EAC5B,MAEJ,IAAK,UACL,IAAK,WAEDjqB,KAAK4pB,wBAA0BK,EAIrC,GAAIA,EAEF,YADAjqB,KAAK6pB,gBAGP,MAAMvc,EAAclO,EAAMU,cACtBE,KAAK4E,WAAa0I,GAAetN,KAAK4E,SAASpgB,SAAS8oB,IAG5DtN,KAAK8pB,oBACP,CACA,aAAAlJ,GACErgB,GAAac,GAAGrB,KAAK4E,SAAUkkB,IAAiB1pB,GAASY,KAAKgqB,eAAe5qB,GAAO,KACpFmB,GAAac,GAAGrB,KAAK4E,SAAUmkB,IAAgB3pB,GAASY,KAAKgqB,eAAe5qB,GAAO,KACnFmB,GAAac,GAAGrB,KAAK4E,SAAUokB,IAAe5pB,GAASY,KAAKgqB,eAAe5qB,GAAO,KAClFmB,GAAac,GAAGrB,KAAK4E,SAAUqkB,IAAgB7pB,GAASY,KAAKgqB,eAAe5qB,GAAO,IACrF,CACA,aAAAyqB,GACE9c,aAAa/M,KAAKsgB,UAClBtgB,KAAKsgB,SAAW,IAClB,CAGA,sBAAO7jB,CAAgBqH,GACrB,OAAO9D,KAAKuH,MAAK,WACf,MAAMld,EAAOq/B,GAAMpkB,oBAAoBtF,KAAM8D,GAC7C,GAAsB,iBAAXA,EAAqB,CAC9B,QAA4B,IAAjBzZ,EAAKyZ,GACd,MAAM,IAAIU,UAAU,oBAAoBV,MAE1CzZ,EAAKyZ,GAAQ9D,KACf,CACF,GACF,ECr0IK,SAASkqB,GAAc7tB,GACD,WAAvBhX,SAASuX,WAAyBP,IACjChX,SAASyF,iBAAiB,mBAAoBuR,EACrD,CDy0IAuK,GAAqB8iB,IAMrBvtB,GAAmButB,IEtyInBQ,IAvCA,WAC2B,GAAG93B,MAAM5U,KAChC6H,SAAS+a,iBAAiB,+BAETtd,KAAI,SAAUqnC,GAC/B,OAAO,IAAI/J,GAAQ+J,EAAkB,CAAElK,MAAO,CAAEvQ,KAAM,IAAKD,KAAM,MACnE,GACF,IAiCAya,IA5BA,WACY7kC,SAAS68B,eAAe,mBAC9Bp3B,iBAAiB,SAAS,WAC5BzF,SAAS6G,KAAKT,UAAY,EAC1BpG,SAASC,gBAAgBmG,UAAY,CACvC,GACF,IAuBAy+B,IArBA,WACE,IAAIE,EAAM/kC,SAAS68B,eAAe,mBAC9BmI,EAAShlC,SACVilC,uBAAuB,aAAa,GACpChnC,wBACH1D,OAAOkL,iBAAiB,UAAU,WAC5BkV,KAAKuqB,UAAYvqB,KAAKwqB,SAAWxqB,KAAKwqB,QAAUH,EAAOzsC,OACzDwsC,EAAIrpC,MAAM6wB,QAAU,QAEpBwY,EAAIrpC,MAAM6wB,QAAU,OAEtB5R,KAAKuqB,UAAYvqB,KAAKwqB,OACxB,GACF","sources":["webpack://pydata_sphinx_theme/webpack/bootstrap","webpack://pydata_sphinx_theme/webpack/runtime/define property getters","webpack://pydata_sphinx_theme/webpack/runtime/hasOwnProperty shorthand","webpack://pydata_sphinx_theme/webpack/runtime/make namespace object","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/enums.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getNodeName.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getWindow.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/instanceOf.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/applyStyles.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/getBasePlacement.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/math.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/userAgent.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/contains.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/isTableElement.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getParentNode.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/within.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/mergePaddingObject.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/getFreshSideObject.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/expandToHashMap.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/arrow.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/getVariation.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/computeStyles.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/eventListeners.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/getOppositePlacement.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/rectToClientRect.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/computeOffsets.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/detectOverflow.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/flip.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/hide.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/offset.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/popperOffsets.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/modifiers/preventOverflow.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/getAltAxis.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/orderModifiers.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/createPopper.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/debounce.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/utils/mergeByName.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/popper.js","webpack://pydata_sphinx_theme/./node_modules/@popperjs/core/lib/popper-lite.js","webpack://pydata_sphinx_theme/./node_modules/bootstrap/dist/js/bootstrap.esm.js","webpack://pydata_sphinx_theme/./src/pydata_sphinx_theme/assets/scripts/mixin.js","webpack://pydata_sphinx_theme/./src/pydata_sphinx_theme/assets/scripts/bootstrap.js"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export var top = 'top';\nexport var bottom = 'bottom';\nexport var right = 'right';\nexport var left = 'left';\nexport var auto = 'auto';\nexport var basePlacements = [top, bottom, right, left];\nexport var start = 'start';\nexport var end = 'end';\nexport var clippingParents = 'clippingParents';\nexport var viewport = 'viewport';\nexport var popper = 'popper';\nexport var reference = 'reference';\nexport var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) {\n return acc.concat([placement + \"-\" + start, placement + \"-\" + end]);\n}, []);\nexport var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) {\n return acc.concat([placement, placement + \"-\" + start, placement + \"-\" + end]);\n}, []); // modifiers that need to read the DOM\n\nexport var beforeRead = 'beforeRead';\nexport var read = 'read';\nexport var afterRead = 'afterRead'; // pure-logic modifiers\n\nexport var beforeMain = 'beforeMain';\nexport var main = 'main';\nexport var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state)\n\nexport var beforeWrite = 'beforeWrite';\nexport var write = 'write';\nexport var afterWrite = 'afterWrite';\nexport var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];","export default function getNodeName(element) {\n return element ? (element.nodeName || '').toLowerCase() : null;\n}","export default function getWindow(node) {\n if (node == null) {\n return window;\n }\n\n if (node.toString() !== '[object Window]') {\n var ownerDocument = node.ownerDocument;\n return ownerDocument ? ownerDocument.defaultView || window : window;\n }\n\n return node;\n}","import getWindow from \"./getWindow.js\";\n\nfunction isElement(node) {\n var OwnElement = getWindow(node).Element;\n return node instanceof OwnElement || node instanceof Element;\n}\n\nfunction isHTMLElement(node) {\n var OwnElement = getWindow(node).HTMLElement;\n return node instanceof OwnElement || node instanceof HTMLElement;\n}\n\nfunction isShadowRoot(node) {\n // IE 11 has no ShadowRoot\n if (typeof ShadowRoot === 'undefined') {\n return false;\n }\n\n var OwnElement = getWindow(node).ShadowRoot;\n return node instanceof OwnElement || node instanceof ShadowRoot;\n}\n\nexport { isElement, isHTMLElement, isShadowRoot };","import getNodeName from \"../dom-utils/getNodeName.js\";\nimport { isHTMLElement } from \"../dom-utils/instanceOf.js\"; // This modifier takes the styles prepared by the `computeStyles` modifier\n// and applies them to the HTMLElements such as popper and arrow\n\nfunction applyStyles(_ref) {\n var state = _ref.state;\n Object.keys(state.elements).forEach(function (name) {\n var style = state.styles[name] || {};\n var attributes = state.attributes[name] || {};\n var element = state.elements[name]; // arrow is optional + virtual elements\n\n if (!isHTMLElement(element) || !getNodeName(element)) {\n return;\n } // Flow doesn't support to extend this property, but it's the most\n // effective way to apply styles to an HTMLElement\n // $FlowFixMe[cannot-write]\n\n\n Object.assign(element.style, style);\n Object.keys(attributes).forEach(function (name) {\n var value = attributes[name];\n\n if (value === false) {\n element.removeAttribute(name);\n } else {\n element.setAttribute(name, value === true ? '' : value);\n }\n });\n });\n}\n\nfunction effect(_ref2) {\n var state = _ref2.state;\n var initialStyles = {\n popper: {\n position: state.options.strategy,\n left: '0',\n top: '0',\n margin: '0'\n },\n arrow: {\n position: 'absolute'\n },\n reference: {}\n };\n Object.assign(state.elements.popper.style, initialStyles.popper);\n state.styles = initialStyles;\n\n if (state.elements.arrow) {\n Object.assign(state.elements.arrow.style, initialStyles.arrow);\n }\n\n return function () {\n Object.keys(state.elements).forEach(function (name) {\n var element = state.elements[name];\n var attributes = state.attributes[name] || {};\n var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them\n\n var style = styleProperties.reduce(function (style, property) {\n style[property] = '';\n return style;\n }, {}); // arrow is optional + virtual elements\n\n if (!isHTMLElement(element) || !getNodeName(element)) {\n return;\n }\n\n Object.assign(element.style, style);\n Object.keys(attributes).forEach(function (attribute) {\n element.removeAttribute(attribute);\n });\n });\n };\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'applyStyles',\n enabled: true,\n phase: 'write',\n fn: applyStyles,\n effect: effect,\n requires: ['computeStyles']\n};","import { auto } from \"../enums.js\";\nexport default function getBasePlacement(placement) {\n return placement.split('-')[0];\n}","export var max = Math.max;\nexport var min = Math.min;\nexport var round = Math.round;","export default function getUAString() {\n var uaData = navigator.userAgentData;\n\n if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) {\n return uaData.brands.map(function (item) {\n return item.brand + \"/\" + item.version;\n }).join(' ');\n }\n\n return navigator.userAgent;\n}","import getUAString from \"../utils/userAgent.js\";\nexport default function isLayoutViewport() {\n return !/^((?!chrome|android).)*safari/i.test(getUAString());\n}","import { isElement, isHTMLElement } from \"./instanceOf.js\";\nimport { round } from \"../utils/math.js\";\nimport getWindow from \"./getWindow.js\";\nimport isLayoutViewport from \"./isLayoutViewport.js\";\nexport default function getBoundingClientRect(element, includeScale, isFixedStrategy) {\n if (includeScale === void 0) {\n includeScale = false;\n }\n\n if (isFixedStrategy === void 0) {\n isFixedStrategy = false;\n }\n\n var clientRect = element.getBoundingClientRect();\n var scaleX = 1;\n var scaleY = 1;\n\n if (includeScale && isHTMLElement(element)) {\n scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;\n scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;\n }\n\n var _ref = isElement(element) ? getWindow(element) : window,\n visualViewport = _ref.visualViewport;\n\n var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;\n var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;\n var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;\n var width = clientRect.width / scaleX;\n var height = clientRect.height / scaleY;\n return {\n width: width,\n height: height,\n top: y,\n right: x + width,\n bottom: y + height,\n left: x,\n x: x,\n y: y\n };\n}","import getBoundingClientRect from \"./getBoundingClientRect.js\"; // Returns the layout rect of an element relative to its offsetParent. Layout\n// means it doesn't take into account transforms.\n\nexport default function getLayoutRect(element) {\n var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed.\n // Fixes https://github.com/popperjs/popper-core/issues/1223\n\n var width = element.offsetWidth;\n var height = element.offsetHeight;\n\n if (Math.abs(clientRect.width - width) <= 1) {\n width = clientRect.width;\n }\n\n if (Math.abs(clientRect.height - height) <= 1) {\n height = clientRect.height;\n }\n\n return {\n x: element.offsetLeft,\n y: element.offsetTop,\n width: width,\n height: height\n };\n}","import { isShadowRoot } from \"./instanceOf.js\";\nexport default function contains(parent, child) {\n var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method\n\n if (parent.contains(child)) {\n return true;\n } // then fallback to custom implementation with Shadow DOM support\n else if (rootNode && isShadowRoot(rootNode)) {\n var next = child;\n\n do {\n if (next && parent.isSameNode(next)) {\n return true;\n } // $FlowFixMe[prop-missing]: need a better way to handle this...\n\n\n next = next.parentNode || next.host;\n } while (next);\n } // Give up, the result is false\n\n\n return false;\n}","import getWindow from \"./getWindow.js\";\nexport default function getComputedStyle(element) {\n return getWindow(element).getComputedStyle(element);\n}","import getNodeName from \"./getNodeName.js\";\nexport default function isTableElement(element) {\n return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;\n}","import { isElement } from \"./instanceOf.js\";\nexport default function getDocumentElement(element) {\n // $FlowFixMe[incompatible-return]: assume body is always available\n return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing]\n element.document) || window.document).documentElement;\n}","import getNodeName from \"./getNodeName.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport { isShadowRoot } from \"./instanceOf.js\";\nexport default function getParentNode(element) {\n if (getNodeName(element) === 'html') {\n return element;\n }\n\n return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle\n // $FlowFixMe[incompatible-return]\n // $FlowFixMe[prop-missing]\n element.assignedSlot || // step into the shadow DOM of the parent of a slotted node\n element.parentNode || ( // DOM Element detected\n isShadowRoot(element) ? element.host : null) || // ShadowRoot detected\n // $FlowFixMe[incompatible-call]: HTMLElement is a Node\n getDocumentElement(element) // fallback\n\n );\n}","import getWindow from \"./getWindow.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport getComputedStyle from \"./getComputedStyle.js\";\nimport { isHTMLElement, isShadowRoot } from \"./instanceOf.js\";\nimport isTableElement from \"./isTableElement.js\";\nimport getParentNode from \"./getParentNode.js\";\nimport getUAString from \"../utils/userAgent.js\";\n\nfunction getTrueOffsetParent(element) {\n if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837\n getComputedStyle(element).position === 'fixed') {\n return null;\n }\n\n return element.offsetParent;\n} // `.offsetParent` reports `null` for fixed elements, while absolute elements\n// return the containing block\n\n\nfunction getContainingBlock(element) {\n var isFirefox = /firefox/i.test(getUAString());\n var isIE = /Trident/i.test(getUAString());\n\n if (isIE && isHTMLElement(element)) {\n // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport\n var elementCss = getComputedStyle(element);\n\n if (elementCss.position === 'fixed') {\n return null;\n }\n }\n\n var currentNode = getParentNode(element);\n\n if (isShadowRoot(currentNode)) {\n currentNode = currentNode.host;\n }\n\n while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {\n var css = getComputedStyle(currentNode); // This is non-exhaustive but covers the most common CSS properties that\n // create a containing block.\n // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n\n if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') {\n return currentNode;\n } else {\n currentNode = currentNode.parentNode;\n }\n }\n\n return null;\n} // Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\n\n\nexport default function getOffsetParent(element) {\n var window = getWindow(element);\n var offsetParent = getTrueOffsetParent(element);\n\n while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {\n offsetParent = getTrueOffsetParent(offsetParent);\n }\n\n if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static')) {\n return window;\n }\n\n return offsetParent || getContainingBlock(element) || window;\n}","export default function getMainAxisFromPlacement(placement) {\n return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';\n}","import { max as mathMax, min as mathMin } from \"./math.js\";\nexport function within(min, value, max) {\n return mathMax(min, mathMin(value, max));\n}\nexport function withinMaxClamp(min, value, max) {\n var v = within(min, value, max);\n return v > max ? max : v;\n}","import getFreshSideObject from \"./getFreshSideObject.js\";\nexport default function mergePaddingObject(paddingObject) {\n return Object.assign({}, getFreshSideObject(), paddingObject);\n}","export default function getFreshSideObject() {\n return {\n top: 0,\n right: 0,\n bottom: 0,\n left: 0\n };\n}","export default function expandToHashMap(value, keys) {\n return keys.reduce(function (hashMap, key) {\n hashMap[key] = value;\n return hashMap;\n }, {});\n}","import getBasePlacement from \"../utils/getBasePlacement.js\";\nimport getLayoutRect from \"../dom-utils/getLayoutRect.js\";\nimport contains from \"../dom-utils/contains.js\";\nimport getOffsetParent from \"../dom-utils/getOffsetParent.js\";\nimport getMainAxisFromPlacement from \"../utils/getMainAxisFromPlacement.js\";\nimport { within } from \"../utils/within.js\";\nimport mergePaddingObject from \"../utils/mergePaddingObject.js\";\nimport expandToHashMap from \"../utils/expandToHashMap.js\";\nimport { left, right, basePlacements, top, bottom } from \"../enums.js\"; // eslint-disable-next-line import/no-unused-modules\n\nvar toPaddingObject = function toPaddingObject(padding, state) {\n padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, {\n placement: state.placement\n })) : padding;\n return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));\n};\n\nfunction arrow(_ref) {\n var _state$modifiersData$;\n\n var state = _ref.state,\n name = _ref.name,\n options = _ref.options;\n var arrowElement = state.elements.arrow;\n var popperOffsets = state.modifiersData.popperOffsets;\n var basePlacement = getBasePlacement(state.placement);\n var axis = getMainAxisFromPlacement(basePlacement);\n var isVertical = [left, right].indexOf(basePlacement) >= 0;\n var len = isVertical ? 'height' : 'width';\n\n if (!arrowElement || !popperOffsets) {\n return;\n }\n\n var paddingObject = toPaddingObject(options.padding, state);\n var arrowRect = getLayoutRect(arrowElement);\n var minProp = axis === 'y' ? top : left;\n var maxProp = axis === 'y' ? bottom : right;\n var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];\n var startDiff = popperOffsets[axis] - state.rects.reference[axis];\n var arrowOffsetParent = getOffsetParent(arrowElement);\n var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;\n var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is\n // outside of the popper bounds\n\n var min = paddingObject[minProp];\n var max = clientSize - arrowRect[len] - paddingObject[maxProp];\n var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;\n var offset = within(min, center, max); // Prevents breaking syntax highlighting...\n\n var axisProp = axis;\n state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$);\n}\n\nfunction effect(_ref2) {\n var state = _ref2.state,\n options = _ref2.options;\n var _options$element = options.element,\n arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element;\n\n if (arrowElement == null) {\n return;\n } // CSS selector\n\n\n if (typeof arrowElement === 'string') {\n arrowElement = state.elements.popper.querySelector(arrowElement);\n\n if (!arrowElement) {\n return;\n }\n }\n\n if (!contains(state.elements.popper, arrowElement)) {\n return;\n }\n\n state.elements.arrow = arrowElement;\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'arrow',\n enabled: true,\n phase: 'main',\n fn: arrow,\n effect: effect,\n requires: ['popperOffsets'],\n requiresIfExists: ['preventOverflow']\n};","export default function getVariation(placement) {\n return placement.split('-')[1];\n}","import { top, left, right, bottom, end } from \"../enums.js\";\nimport getOffsetParent from \"../dom-utils/getOffsetParent.js\";\nimport getWindow from \"../dom-utils/getWindow.js\";\nimport getDocumentElement from \"../dom-utils/getDocumentElement.js\";\nimport getComputedStyle from \"../dom-utils/getComputedStyle.js\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\";\nimport getVariation from \"../utils/getVariation.js\";\nimport { round } from \"../utils/math.js\"; // eslint-disable-next-line import/no-unused-modules\n\nvar unsetSides = {\n top: 'auto',\n right: 'auto',\n bottom: 'auto',\n left: 'auto'\n}; // Round the offsets to the nearest suitable subpixel based on the DPR.\n// Zooming can change the DPR, but it seems to report a value that will\n// cleanly divide the values into the appropriate subpixels.\n\nfunction roundOffsetsByDPR(_ref, win) {\n var x = _ref.x,\n y = _ref.y;\n var dpr = win.devicePixelRatio || 1;\n return {\n x: round(x * dpr) / dpr || 0,\n y: round(y * dpr) / dpr || 0\n };\n}\n\nexport function mapToStyles(_ref2) {\n var _Object$assign2;\n\n var popper = _ref2.popper,\n popperRect = _ref2.popperRect,\n placement = _ref2.placement,\n variation = _ref2.variation,\n offsets = _ref2.offsets,\n position = _ref2.position,\n gpuAcceleration = _ref2.gpuAcceleration,\n adaptive = _ref2.adaptive,\n roundOffsets = _ref2.roundOffsets,\n isFixed = _ref2.isFixed;\n var _offsets$x = offsets.x,\n x = _offsets$x === void 0 ? 0 : _offsets$x,\n _offsets$y = offsets.y,\n y = _offsets$y === void 0 ? 0 : _offsets$y;\n\n var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({\n x: x,\n y: y\n }) : {\n x: x,\n y: y\n };\n\n x = _ref3.x;\n y = _ref3.y;\n var hasX = offsets.hasOwnProperty('x');\n var hasY = offsets.hasOwnProperty('y');\n var sideX = left;\n var sideY = top;\n var win = window;\n\n if (adaptive) {\n var offsetParent = getOffsetParent(popper);\n var heightProp = 'clientHeight';\n var widthProp = 'clientWidth';\n\n if (offsetParent === getWindow(popper)) {\n offsetParent = getDocumentElement(popper);\n\n if (getComputedStyle(offsetParent).position !== 'static' && position === 'absolute') {\n heightProp = 'scrollHeight';\n widthProp = 'scrollWidth';\n }\n } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it\n\n\n offsetParent = offsetParent;\n\n if (placement === top || (placement === left || placement === right) && variation === end) {\n sideY = bottom;\n var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing]\n offsetParent[heightProp];\n y -= offsetY - popperRect.height;\n y *= gpuAcceleration ? 1 : -1;\n }\n\n if (placement === left || (placement === top || placement === bottom) && variation === end) {\n sideX = right;\n var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing]\n offsetParent[widthProp];\n x -= offsetX - popperRect.width;\n x *= gpuAcceleration ? 1 : -1;\n }\n }\n\n var commonStyles = Object.assign({\n position: position\n }, adaptive && unsetSides);\n\n var _ref4 = roundOffsets === true ? roundOffsetsByDPR({\n x: x,\n y: y\n }, getWindow(popper)) : {\n x: x,\n y: y\n };\n\n x = _ref4.x;\n y = _ref4.y;\n\n if (gpuAcceleration) {\n var _Object$assign;\n\n return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? \"translate(\" + x + \"px, \" + y + \"px)\" : \"translate3d(\" + x + \"px, \" + y + \"px, 0)\", _Object$assign));\n }\n\n return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + \"px\" : '', _Object$assign2[sideX] = hasX ? x + \"px\" : '', _Object$assign2.transform = '', _Object$assign2));\n}\n\nfunction computeStyles(_ref5) {\n var state = _ref5.state,\n options = _ref5.options;\n var _options$gpuAccelerat = options.gpuAcceleration,\n gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat,\n _options$adaptive = options.adaptive,\n adaptive = _options$adaptive === void 0 ? true : _options$adaptive,\n _options$roundOffsets = options.roundOffsets,\n roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;\n var commonStyles = {\n placement: getBasePlacement(state.placement),\n variation: getVariation(state.placement),\n popper: state.elements.popper,\n popperRect: state.rects.popper,\n gpuAcceleration: gpuAcceleration,\n isFixed: state.options.strategy === 'fixed'\n };\n\n if (state.modifiersData.popperOffsets != null) {\n state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {\n offsets: state.modifiersData.popperOffsets,\n position: state.options.strategy,\n adaptive: adaptive,\n roundOffsets: roundOffsets\n })));\n }\n\n if (state.modifiersData.arrow != null) {\n state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {\n offsets: state.modifiersData.arrow,\n position: 'absolute',\n adaptive: false,\n roundOffsets: roundOffsets\n })));\n }\n\n state.attributes.popper = Object.assign({}, state.attributes.popper, {\n 'data-popper-placement': state.placement\n });\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'computeStyles',\n enabled: true,\n phase: 'beforeWrite',\n fn: computeStyles,\n data: {}\n};","import getWindow from \"../dom-utils/getWindow.js\"; // eslint-disable-next-line import/no-unused-modules\n\nvar passive = {\n passive: true\n};\n\nfunction effect(_ref) {\n var state = _ref.state,\n instance = _ref.instance,\n options = _ref.options;\n var _options$scroll = options.scroll,\n scroll = _options$scroll === void 0 ? true : _options$scroll,\n _options$resize = options.resize,\n resize = _options$resize === void 0 ? true : _options$resize;\n var window = getWindow(state.elements.popper);\n var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);\n\n if (scroll) {\n scrollParents.forEach(function (scrollParent) {\n scrollParent.addEventListener('scroll', instance.update, passive);\n });\n }\n\n if (resize) {\n window.addEventListener('resize', instance.update, passive);\n }\n\n return function () {\n if (scroll) {\n scrollParents.forEach(function (scrollParent) {\n scrollParent.removeEventListener('scroll', instance.update, passive);\n });\n }\n\n if (resize) {\n window.removeEventListener('resize', instance.update, passive);\n }\n };\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'eventListeners',\n enabled: true,\n phase: 'write',\n fn: function fn() {},\n effect: effect,\n data: {}\n};","var hash = {\n left: 'right',\n right: 'left',\n bottom: 'top',\n top: 'bottom'\n};\nexport default function getOppositePlacement(placement) {\n return placement.replace(/left|right|bottom|top/g, function (matched) {\n return hash[matched];\n });\n}","var hash = {\n start: 'end',\n end: 'start'\n};\nexport default function getOppositeVariationPlacement(placement) {\n return placement.replace(/start|end/g, function (matched) {\n return hash[matched];\n });\n}","import getWindow from \"./getWindow.js\";\nexport default function getWindowScroll(node) {\n var win = getWindow(node);\n var scrollLeft = win.pageXOffset;\n var scrollTop = win.pageYOffset;\n return {\n scrollLeft: scrollLeft,\n scrollTop: scrollTop\n };\n}","import getBoundingClientRect from \"./getBoundingClientRect.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport getWindowScroll from \"./getWindowScroll.js\";\nexport default function getWindowScrollBarX(element) {\n // If has a CSS width greater than the viewport, then this will be\n // incorrect for RTL.\n // Popper 1 is broken in this case and never had a bug report so let's assume\n // it's not an issue. I don't think anyone ever specifies width on \n // anyway.\n // Browsers where the left scrollbar doesn't cause an issue report `0` for\n // this (e.g. Edge 2019, IE11, Safari)\n return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;\n}","import getComputedStyle from \"./getComputedStyle.js\";\nexport default function isScrollParent(element) {\n // Firefox wants us to check `-x` and `-y` variations as well\n var _getComputedStyle = getComputedStyle(element),\n overflow = _getComputedStyle.overflow,\n overflowX = _getComputedStyle.overflowX,\n overflowY = _getComputedStyle.overflowY;\n\n return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);\n}","import getParentNode from \"./getParentNode.js\";\nimport isScrollParent from \"./isScrollParent.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\nexport default function getScrollParent(node) {\n if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {\n // $FlowFixMe[incompatible-return]: assume body is always available\n return node.ownerDocument.body;\n }\n\n if (isHTMLElement(node) && isScrollParent(node)) {\n return node;\n }\n\n return getScrollParent(getParentNode(node));\n}","import getScrollParent from \"./getScrollParent.js\";\nimport getParentNode from \"./getParentNode.js\";\nimport getWindow from \"./getWindow.js\";\nimport isScrollParent from \"./isScrollParent.js\";\n/*\ngiven a DOM element, return the list of all scroll parents, up the list of ancesors\nuntil we get to the top window object. This list is what we attach scroll listeners\nto, because if any of these parent elements scroll, we'll need to re-calculate the\nreference element's position.\n*/\n\nexport default function listScrollParents(element, list) {\n var _element$ownerDocumen;\n\n if (list === void 0) {\n list = [];\n }\n\n var scrollParent = getScrollParent(element);\n var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);\n var win = getWindow(scrollParent);\n var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;\n var updatedList = list.concat(target);\n return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here\n updatedList.concat(listScrollParents(getParentNode(target)));\n}","export default function rectToClientRect(rect) {\n return Object.assign({}, rect, {\n left: rect.x,\n top: rect.y,\n right: rect.x + rect.width,\n bottom: rect.y + rect.height\n });\n}","import { viewport } from \"../enums.js\";\nimport getViewportRect from \"./getViewportRect.js\";\nimport getDocumentRect from \"./getDocumentRect.js\";\nimport listScrollParents from \"./listScrollParents.js\";\nimport getOffsetParent from \"./getOffsetParent.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport getComputedStyle from \"./getComputedStyle.js\";\nimport { isElement, isHTMLElement } from \"./instanceOf.js\";\nimport getBoundingClientRect from \"./getBoundingClientRect.js\";\nimport getParentNode from \"./getParentNode.js\";\nimport contains from \"./contains.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport rectToClientRect from \"../utils/rectToClientRect.js\";\nimport { max, min } from \"../utils/math.js\";\n\nfunction getInnerBoundingClientRect(element, strategy) {\n var rect = getBoundingClientRect(element, false, strategy === 'fixed');\n rect.top = rect.top + element.clientTop;\n rect.left = rect.left + element.clientLeft;\n rect.bottom = rect.top + element.clientHeight;\n rect.right = rect.left + element.clientWidth;\n rect.width = element.clientWidth;\n rect.height = element.clientHeight;\n rect.x = rect.left;\n rect.y = rect.top;\n return rect;\n}\n\nfunction getClientRectFromMixedType(element, clippingParent, strategy) {\n return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element)));\n} // A \"clipping parent\" is an overflowable container with the characteristic of\n// clipping (or hiding) overflowing elements with a position different from\n// `initial`\n\n\nfunction getClippingParents(element) {\n var clippingParents = listScrollParents(getParentNode(element));\n var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0;\n var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;\n\n if (!isElement(clipperElement)) {\n return [];\n } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414\n\n\n return clippingParents.filter(function (clippingParent) {\n return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body';\n });\n} // Gets the maximum area that the element is visible in due to any number of\n// clipping parents\n\n\nexport default function getClippingRect(element, boundary, rootBoundary, strategy) {\n var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);\n var clippingParents = [].concat(mainClippingParents, [rootBoundary]);\n var firstClippingParent = clippingParents[0];\n var clippingRect = clippingParents.reduce(function (accRect, clippingParent) {\n var rect = getClientRectFromMixedType(element, clippingParent, strategy);\n accRect.top = max(rect.top, accRect.top);\n accRect.right = min(rect.right, accRect.right);\n accRect.bottom = min(rect.bottom, accRect.bottom);\n accRect.left = max(rect.left, accRect.left);\n return accRect;\n }, getClientRectFromMixedType(element, firstClippingParent, strategy));\n clippingRect.width = clippingRect.right - clippingRect.left;\n clippingRect.height = clippingRect.bottom - clippingRect.top;\n clippingRect.x = clippingRect.left;\n clippingRect.y = clippingRect.top;\n return clippingRect;\n}","import getWindow from \"./getWindow.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport getWindowScrollBarX from \"./getWindowScrollBarX.js\";\nimport isLayoutViewport from \"./isLayoutViewport.js\";\nexport default function getViewportRect(element, strategy) {\n var win = getWindow(element);\n var html = getDocumentElement(element);\n var visualViewport = win.visualViewport;\n var width = html.clientWidth;\n var height = html.clientHeight;\n var x = 0;\n var y = 0;\n\n if (visualViewport) {\n width = visualViewport.width;\n height = visualViewport.height;\n var layoutViewport = isLayoutViewport();\n\n if (layoutViewport || !layoutViewport && strategy === 'fixed') {\n x = visualViewport.offsetLeft;\n y = visualViewport.offsetTop;\n }\n }\n\n return {\n width: width,\n height: height,\n x: x + getWindowScrollBarX(element),\n y: y\n };\n}","import getDocumentElement from \"./getDocumentElement.js\";\nimport getComputedStyle from \"./getComputedStyle.js\";\nimport getWindowScrollBarX from \"./getWindowScrollBarX.js\";\nimport getWindowScroll from \"./getWindowScroll.js\";\nimport { max } from \"../utils/math.js\"; // Gets the entire size of the scrollable document area, even extending outside\n// of the `` and `` rect bounds if horizontally scrollable\n\nexport default function getDocumentRect(element) {\n var _element$ownerDocumen;\n\n var html = getDocumentElement(element);\n var winScroll = getWindowScroll(element);\n var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;\n var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);\n var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);\n var x = -winScroll.scrollLeft + getWindowScrollBarX(element);\n var y = -winScroll.scrollTop;\n\n if (getComputedStyle(body || html).direction === 'rtl') {\n x += max(html.clientWidth, body ? body.clientWidth : 0) - width;\n }\n\n return {\n width: width,\n height: height,\n x: x,\n y: y\n };\n}","import getBasePlacement from \"./getBasePlacement.js\";\nimport getVariation from \"./getVariation.js\";\nimport getMainAxisFromPlacement from \"./getMainAxisFromPlacement.js\";\nimport { top, right, bottom, left, start, end } from \"../enums.js\";\nexport default function computeOffsets(_ref) {\n var reference = _ref.reference,\n element = _ref.element,\n placement = _ref.placement;\n var basePlacement = placement ? getBasePlacement(placement) : null;\n var variation = placement ? getVariation(placement) : null;\n var commonX = reference.x + reference.width / 2 - element.width / 2;\n var commonY = reference.y + reference.height / 2 - element.height / 2;\n var offsets;\n\n switch (basePlacement) {\n case top:\n offsets = {\n x: commonX,\n y: reference.y - element.height\n };\n break;\n\n case bottom:\n offsets = {\n x: commonX,\n y: reference.y + reference.height\n };\n break;\n\n case right:\n offsets = {\n x: reference.x + reference.width,\n y: commonY\n };\n break;\n\n case left:\n offsets = {\n x: reference.x - element.width,\n y: commonY\n };\n break;\n\n default:\n offsets = {\n x: reference.x,\n y: reference.y\n };\n }\n\n var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;\n\n if (mainAxis != null) {\n var len = mainAxis === 'y' ? 'height' : 'width';\n\n switch (variation) {\n case start:\n offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2);\n break;\n\n case end:\n offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2);\n break;\n\n default:\n }\n }\n\n return offsets;\n}","import getClippingRect from \"../dom-utils/getClippingRect.js\";\nimport getDocumentElement from \"../dom-utils/getDocumentElement.js\";\nimport getBoundingClientRect from \"../dom-utils/getBoundingClientRect.js\";\nimport computeOffsets from \"./computeOffsets.js\";\nimport rectToClientRect from \"./rectToClientRect.js\";\nimport { clippingParents, reference, popper, bottom, top, right, basePlacements, viewport } from \"../enums.js\";\nimport { isElement } from \"../dom-utils/instanceOf.js\";\nimport mergePaddingObject from \"./mergePaddingObject.js\";\nimport expandToHashMap from \"./expandToHashMap.js\"; // eslint-disable-next-line import/no-unused-modules\n\nexport default function detectOverflow(state, options) {\n if (options === void 0) {\n options = {};\n }\n\n var _options = options,\n _options$placement = _options.placement,\n placement = _options$placement === void 0 ? state.placement : _options$placement,\n _options$strategy = _options.strategy,\n strategy = _options$strategy === void 0 ? state.strategy : _options$strategy,\n _options$boundary = _options.boundary,\n boundary = _options$boundary === void 0 ? clippingParents : _options$boundary,\n _options$rootBoundary = _options.rootBoundary,\n rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary,\n _options$elementConte = _options.elementContext,\n elementContext = _options$elementConte === void 0 ? popper : _options$elementConte,\n _options$altBoundary = _options.altBoundary,\n altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary,\n _options$padding = _options.padding,\n padding = _options$padding === void 0 ? 0 : _options$padding;\n var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));\n var altContext = elementContext === popper ? reference : popper;\n var popperRect = state.rects.popper;\n var element = state.elements[altBoundary ? altContext : elementContext];\n var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);\n var referenceClientRect = getBoundingClientRect(state.elements.reference);\n var popperOffsets = computeOffsets({\n reference: referenceClientRect,\n element: popperRect,\n strategy: 'absolute',\n placement: placement\n });\n var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets));\n var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect\n // 0 or negative = within the clipping rect\n\n var overflowOffsets = {\n top: clippingClientRect.top - elementClientRect.top + paddingObject.top,\n bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,\n left: clippingClientRect.left - elementClientRect.left + paddingObject.left,\n right: elementClientRect.right - clippingClientRect.right + paddingObject.right\n };\n var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element\n\n if (elementContext === popper && offsetData) {\n var offset = offsetData[placement];\n Object.keys(overflowOffsets).forEach(function (key) {\n var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;\n var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';\n overflowOffsets[key] += offset[axis] * multiply;\n });\n }\n\n return overflowOffsets;\n}","import getOppositePlacement from \"../utils/getOppositePlacement.js\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\";\nimport getOppositeVariationPlacement from \"../utils/getOppositeVariationPlacement.js\";\nimport detectOverflow from \"../utils/detectOverflow.js\";\nimport computeAutoPlacement from \"../utils/computeAutoPlacement.js\";\nimport { bottom, top, start, right, left, auto } from \"../enums.js\";\nimport getVariation from \"../utils/getVariation.js\"; // eslint-disable-next-line import/no-unused-modules\n\nfunction getExpandedFallbackPlacements(placement) {\n if (getBasePlacement(placement) === auto) {\n return [];\n }\n\n var oppositePlacement = getOppositePlacement(placement);\n return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];\n}\n\nfunction flip(_ref) {\n var state = _ref.state,\n options = _ref.options,\n name = _ref.name;\n\n if (state.modifiersData[name]._skip) {\n return;\n }\n\n var _options$mainAxis = options.mainAxis,\n checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,\n _options$altAxis = options.altAxis,\n checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis,\n specifiedFallbackPlacements = options.fallbackPlacements,\n padding = options.padding,\n boundary = options.boundary,\n rootBoundary = options.rootBoundary,\n altBoundary = options.altBoundary,\n _options$flipVariatio = options.flipVariations,\n flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio,\n allowedAutoPlacements = options.allowedAutoPlacements;\n var preferredPlacement = state.options.placement;\n var basePlacement = getBasePlacement(preferredPlacement);\n var isBasePlacement = basePlacement === preferredPlacement;\n var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));\n var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) {\n return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, {\n placement: placement,\n boundary: boundary,\n rootBoundary: rootBoundary,\n padding: padding,\n flipVariations: flipVariations,\n allowedAutoPlacements: allowedAutoPlacements\n }) : placement);\n }, []);\n var referenceRect = state.rects.reference;\n var popperRect = state.rects.popper;\n var checksMap = new Map();\n var makeFallbackChecks = true;\n var firstFittingPlacement = placements[0];\n\n for (var i = 0; i < placements.length; i++) {\n var placement = placements[i];\n\n var _basePlacement = getBasePlacement(placement);\n\n var isStartVariation = getVariation(placement) === start;\n var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;\n var len = isVertical ? 'width' : 'height';\n var overflow = detectOverflow(state, {\n placement: placement,\n boundary: boundary,\n rootBoundary: rootBoundary,\n altBoundary: altBoundary,\n padding: padding\n });\n var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;\n\n if (referenceRect[len] > popperRect[len]) {\n mainVariationSide = getOppositePlacement(mainVariationSide);\n }\n\n var altVariationSide = getOppositePlacement(mainVariationSide);\n var checks = [];\n\n if (checkMainAxis) {\n checks.push(overflow[_basePlacement] <= 0);\n }\n\n if (checkAltAxis) {\n checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);\n }\n\n if (checks.every(function (check) {\n return check;\n })) {\n firstFittingPlacement = placement;\n makeFallbackChecks = false;\n break;\n }\n\n checksMap.set(placement, checks);\n }\n\n if (makeFallbackChecks) {\n // `2` may be desired in some cases – research later\n var numberOfChecks = flipVariations ? 3 : 1;\n\n var _loop = function _loop(_i) {\n var fittingPlacement = placements.find(function (placement) {\n var checks = checksMap.get(placement);\n\n if (checks) {\n return checks.slice(0, _i).every(function (check) {\n return check;\n });\n }\n });\n\n if (fittingPlacement) {\n firstFittingPlacement = fittingPlacement;\n return \"break\";\n }\n };\n\n for (var _i = numberOfChecks; _i > 0; _i--) {\n var _ret = _loop(_i);\n\n if (_ret === \"break\") break;\n }\n }\n\n if (state.placement !== firstFittingPlacement) {\n state.modifiersData[name]._skip = true;\n state.placement = firstFittingPlacement;\n state.reset = true;\n }\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'flip',\n enabled: true,\n phase: 'main',\n fn: flip,\n requiresIfExists: ['offset'],\n data: {\n _skip: false\n }\n};","import getVariation from \"./getVariation.js\";\nimport { variationPlacements, basePlacements, placements as allPlacements } from \"../enums.js\";\nimport detectOverflow from \"./detectOverflow.js\";\nimport getBasePlacement from \"./getBasePlacement.js\";\nexport default function computeAutoPlacement(state, options) {\n if (options === void 0) {\n options = {};\n }\n\n var _options = options,\n placement = _options.placement,\n boundary = _options.boundary,\n rootBoundary = _options.rootBoundary,\n padding = _options.padding,\n flipVariations = _options.flipVariations,\n _options$allowedAutoP = _options.allowedAutoPlacements,\n allowedAutoPlacements = _options$allowedAutoP === void 0 ? allPlacements : _options$allowedAutoP;\n var variation = getVariation(placement);\n var placements = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) {\n return getVariation(placement) === variation;\n }) : basePlacements;\n var allowedPlacements = placements.filter(function (placement) {\n return allowedAutoPlacements.indexOf(placement) >= 0;\n });\n\n if (allowedPlacements.length === 0) {\n allowedPlacements = placements;\n } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions...\n\n\n var overflows = allowedPlacements.reduce(function (acc, placement) {\n acc[placement] = detectOverflow(state, {\n placement: placement,\n boundary: boundary,\n rootBoundary: rootBoundary,\n padding: padding\n })[getBasePlacement(placement)];\n return acc;\n }, {});\n return Object.keys(overflows).sort(function (a, b) {\n return overflows[a] - overflows[b];\n });\n}","import { top, bottom, left, right } from \"../enums.js\";\nimport detectOverflow from \"../utils/detectOverflow.js\";\n\nfunction getSideOffsets(overflow, rect, preventedOffsets) {\n if (preventedOffsets === void 0) {\n preventedOffsets = {\n x: 0,\n y: 0\n };\n }\n\n return {\n top: overflow.top - rect.height - preventedOffsets.y,\n right: overflow.right - rect.width + preventedOffsets.x,\n bottom: overflow.bottom - rect.height + preventedOffsets.y,\n left: overflow.left - rect.width - preventedOffsets.x\n };\n}\n\nfunction isAnySideFullyClipped(overflow) {\n return [top, right, bottom, left].some(function (side) {\n return overflow[side] >= 0;\n });\n}\n\nfunction hide(_ref) {\n var state = _ref.state,\n name = _ref.name;\n var referenceRect = state.rects.reference;\n var popperRect = state.rects.popper;\n var preventedOffsets = state.modifiersData.preventOverflow;\n var referenceOverflow = detectOverflow(state, {\n elementContext: 'reference'\n });\n var popperAltOverflow = detectOverflow(state, {\n altBoundary: true\n });\n var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);\n var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);\n var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);\n var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);\n state.modifiersData[name] = {\n referenceClippingOffsets: referenceClippingOffsets,\n popperEscapeOffsets: popperEscapeOffsets,\n isReferenceHidden: isReferenceHidden,\n hasPopperEscaped: hasPopperEscaped\n };\n state.attributes.popper = Object.assign({}, state.attributes.popper, {\n 'data-popper-reference-hidden': isReferenceHidden,\n 'data-popper-escaped': hasPopperEscaped\n });\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'hide',\n enabled: true,\n phase: 'main',\n requiresIfExists: ['preventOverflow'],\n fn: hide\n};","import getBasePlacement from \"../utils/getBasePlacement.js\";\nimport { top, left, right, placements } from \"../enums.js\"; // eslint-disable-next-line import/no-unused-modules\n\nexport function distanceAndSkiddingToXY(placement, rects, offset) {\n var basePlacement = getBasePlacement(placement);\n var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;\n\n var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, {\n placement: placement\n })) : offset,\n skidding = _ref[0],\n distance = _ref[1];\n\n skidding = skidding || 0;\n distance = (distance || 0) * invertDistance;\n return [left, right].indexOf(basePlacement) >= 0 ? {\n x: distance,\n y: skidding\n } : {\n x: skidding,\n y: distance\n };\n}\n\nfunction offset(_ref2) {\n var state = _ref2.state,\n options = _ref2.options,\n name = _ref2.name;\n var _options$offset = options.offset,\n offset = _options$offset === void 0 ? [0, 0] : _options$offset;\n var data = placements.reduce(function (acc, placement) {\n acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);\n return acc;\n }, {});\n var _data$state$placement = data[state.placement],\n x = _data$state$placement.x,\n y = _data$state$placement.y;\n\n if (state.modifiersData.popperOffsets != null) {\n state.modifiersData.popperOffsets.x += x;\n state.modifiersData.popperOffsets.y += y;\n }\n\n state.modifiersData[name] = data;\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'offset',\n enabled: true,\n phase: 'main',\n requires: ['popperOffsets'],\n fn: offset\n};","import computeOffsets from \"../utils/computeOffsets.js\";\n\nfunction popperOffsets(_ref) {\n var state = _ref.state,\n name = _ref.name;\n // Offsets are the actual position the popper needs to have to be\n // properly positioned near its reference element\n // This is the most basic placement, and will be adjusted by\n // the modifiers in the next step\n state.modifiersData[name] = computeOffsets({\n reference: state.rects.reference,\n element: state.rects.popper,\n strategy: 'absolute',\n placement: state.placement\n });\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'popperOffsets',\n enabled: true,\n phase: 'read',\n fn: popperOffsets,\n data: {}\n};","import { top, left, right, bottom, start } from \"../enums.js\";\nimport getBasePlacement from \"../utils/getBasePlacement.js\";\nimport getMainAxisFromPlacement from \"../utils/getMainAxisFromPlacement.js\";\nimport getAltAxis from \"../utils/getAltAxis.js\";\nimport { within, withinMaxClamp } from \"../utils/within.js\";\nimport getLayoutRect from \"../dom-utils/getLayoutRect.js\";\nimport getOffsetParent from \"../dom-utils/getOffsetParent.js\";\nimport detectOverflow from \"../utils/detectOverflow.js\";\nimport getVariation from \"../utils/getVariation.js\";\nimport getFreshSideObject from \"../utils/getFreshSideObject.js\";\nimport { min as mathMin, max as mathMax } from \"../utils/math.js\";\n\nfunction preventOverflow(_ref) {\n var state = _ref.state,\n options = _ref.options,\n name = _ref.name;\n var _options$mainAxis = options.mainAxis,\n checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis,\n _options$altAxis = options.altAxis,\n checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis,\n boundary = options.boundary,\n rootBoundary = options.rootBoundary,\n altBoundary = options.altBoundary,\n padding = options.padding,\n _options$tether = options.tether,\n tether = _options$tether === void 0 ? true : _options$tether,\n _options$tetherOffset = options.tetherOffset,\n tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;\n var overflow = detectOverflow(state, {\n boundary: boundary,\n rootBoundary: rootBoundary,\n padding: padding,\n altBoundary: altBoundary\n });\n var basePlacement = getBasePlacement(state.placement);\n var variation = getVariation(state.placement);\n var isBasePlacement = !variation;\n var mainAxis = getMainAxisFromPlacement(basePlacement);\n var altAxis = getAltAxis(mainAxis);\n var popperOffsets = state.modifiersData.popperOffsets;\n var referenceRect = state.rects.reference;\n var popperRect = state.rects.popper;\n var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, {\n placement: state.placement\n })) : tetherOffset;\n var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? {\n mainAxis: tetherOffsetValue,\n altAxis: tetherOffsetValue\n } : Object.assign({\n mainAxis: 0,\n altAxis: 0\n }, tetherOffsetValue);\n var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;\n var data = {\n x: 0,\n y: 0\n };\n\n if (!popperOffsets) {\n return;\n }\n\n if (checkMainAxis) {\n var _offsetModifierState$;\n\n var mainSide = mainAxis === 'y' ? top : left;\n var altSide = mainAxis === 'y' ? bottom : right;\n var len = mainAxis === 'y' ? 'height' : 'width';\n var offset = popperOffsets[mainAxis];\n var min = offset + overflow[mainSide];\n var max = offset - overflow[altSide];\n var additive = tether ? -popperRect[len] / 2 : 0;\n var minLen = variation === start ? referenceRect[len] : popperRect[len];\n var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go\n // outside the reference bounds\n\n var arrowElement = state.elements.arrow;\n var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {\n width: 0,\n height: 0\n };\n var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject();\n var arrowPaddingMin = arrowPaddingObject[mainSide];\n var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want\n // to include its full size in the calculation. If the reference is small\n // and near the edge of a boundary, the popper can overflow even if the\n // reference is not overflowing as well (e.g. virtual elements with no\n // width or height)\n\n var arrowLen = within(0, referenceRect[len], arrowRect[len]);\n var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;\n var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;\n var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);\n var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;\n var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;\n var tetherMin = offset + minOffset - offsetModifierValue - clientOffset;\n var tetherMax = offset + maxOffset - offsetModifierValue;\n var preventedOffset = within(tether ? mathMin(min, tetherMin) : min, offset, tether ? mathMax(max, tetherMax) : max);\n popperOffsets[mainAxis] = preventedOffset;\n data[mainAxis] = preventedOffset - offset;\n }\n\n if (checkAltAxis) {\n var _offsetModifierState$2;\n\n var _mainSide = mainAxis === 'x' ? top : left;\n\n var _altSide = mainAxis === 'x' ? bottom : right;\n\n var _offset = popperOffsets[altAxis];\n\n var _len = altAxis === 'y' ? 'height' : 'width';\n\n var _min = _offset + overflow[_mainSide];\n\n var _max = _offset - overflow[_altSide];\n\n var isOriginSide = [top, left].indexOf(basePlacement) !== -1;\n\n var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;\n\n var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;\n\n var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;\n\n var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);\n\n popperOffsets[altAxis] = _preventedOffset;\n data[altAxis] = _preventedOffset - _offset;\n }\n\n state.modifiersData[name] = data;\n} // eslint-disable-next-line import/no-unused-modules\n\n\nexport default {\n name: 'preventOverflow',\n enabled: true,\n phase: 'main',\n fn: preventOverflow,\n requiresIfExists: ['offset']\n};","export default function getAltAxis(axis) {\n return axis === 'x' ? 'y' : 'x';\n}","import getBoundingClientRect from \"./getBoundingClientRect.js\";\nimport getNodeScroll from \"./getNodeScroll.js\";\nimport getNodeName from \"./getNodeName.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\nimport getWindowScrollBarX from \"./getWindowScrollBarX.js\";\nimport getDocumentElement from \"./getDocumentElement.js\";\nimport isScrollParent from \"./isScrollParent.js\";\nimport { round } from \"../utils/math.js\";\n\nfunction isElementScaled(element) {\n var rect = element.getBoundingClientRect();\n var scaleX = round(rect.width) / element.offsetWidth || 1;\n var scaleY = round(rect.height) / element.offsetHeight || 1;\n return scaleX !== 1 || scaleY !== 1;\n} // Returns the composite rect of an element relative to its offsetParent.\n// Composite means it takes into account transforms as well as layout.\n\n\nexport default function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {\n if (isFixed === void 0) {\n isFixed = false;\n }\n\n var isOffsetParentAnElement = isHTMLElement(offsetParent);\n var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);\n var documentElement = getDocumentElement(offsetParent);\n var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);\n var scroll = {\n scrollLeft: 0,\n scrollTop: 0\n };\n var offsets = {\n x: 0,\n y: 0\n };\n\n if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078\n isScrollParent(documentElement)) {\n scroll = getNodeScroll(offsetParent);\n }\n\n if (isHTMLElement(offsetParent)) {\n offsets = getBoundingClientRect(offsetParent, true);\n offsets.x += offsetParent.clientLeft;\n offsets.y += offsetParent.clientTop;\n } else if (documentElement) {\n offsets.x = getWindowScrollBarX(documentElement);\n }\n }\n\n return {\n x: rect.left + scroll.scrollLeft - offsets.x,\n y: rect.top + scroll.scrollTop - offsets.y,\n width: rect.width,\n height: rect.height\n };\n}","import getWindowScroll from \"./getWindowScroll.js\";\nimport getWindow from \"./getWindow.js\";\nimport { isHTMLElement } from \"./instanceOf.js\";\nimport getHTMLElementScroll from \"./getHTMLElementScroll.js\";\nexport default function getNodeScroll(node) {\n if (node === getWindow(node) || !isHTMLElement(node)) {\n return getWindowScroll(node);\n } else {\n return getHTMLElementScroll(node);\n }\n}","export default function getHTMLElementScroll(element) {\n return {\n scrollLeft: element.scrollLeft,\n scrollTop: element.scrollTop\n };\n}","import { modifierPhases } from \"../enums.js\"; // source: https://stackoverflow.com/questions/49875255\n\nfunction order(modifiers) {\n var map = new Map();\n var visited = new Set();\n var result = [];\n modifiers.forEach(function (modifier) {\n map.set(modifier.name, modifier);\n }); // On visiting object, check for its dependencies and visit them recursively\n\n function sort(modifier) {\n visited.add(modifier.name);\n var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);\n requires.forEach(function (dep) {\n if (!visited.has(dep)) {\n var depModifier = map.get(dep);\n\n if (depModifier) {\n sort(depModifier);\n }\n }\n });\n result.push(modifier);\n }\n\n modifiers.forEach(function (modifier) {\n if (!visited.has(modifier.name)) {\n // check for visited object\n sort(modifier);\n }\n });\n return result;\n}\n\nexport default function orderModifiers(modifiers) {\n // order based on dependencies\n var orderedModifiers = order(modifiers); // order based on phase\n\n return modifierPhases.reduce(function (acc, phase) {\n return acc.concat(orderedModifiers.filter(function (modifier) {\n return modifier.phase === phase;\n }));\n }, []);\n}","import getCompositeRect from \"./dom-utils/getCompositeRect.js\";\nimport getLayoutRect from \"./dom-utils/getLayoutRect.js\";\nimport listScrollParents from \"./dom-utils/listScrollParents.js\";\nimport getOffsetParent from \"./dom-utils/getOffsetParent.js\";\nimport orderModifiers from \"./utils/orderModifiers.js\";\nimport debounce from \"./utils/debounce.js\";\nimport mergeByName from \"./utils/mergeByName.js\";\nimport detectOverflow from \"./utils/detectOverflow.js\";\nimport { isElement } from \"./dom-utils/instanceOf.js\";\nvar DEFAULT_OPTIONS = {\n placement: 'bottom',\n modifiers: [],\n strategy: 'absolute'\n};\n\nfunction areValidElements() {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return !args.some(function (element) {\n return !(element && typeof element.getBoundingClientRect === 'function');\n });\n}\n\nexport function popperGenerator(generatorOptions) {\n if (generatorOptions === void 0) {\n generatorOptions = {};\n }\n\n var _generatorOptions = generatorOptions,\n _generatorOptions$def = _generatorOptions.defaultModifiers,\n defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def,\n _generatorOptions$def2 = _generatorOptions.defaultOptions,\n defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;\n return function createPopper(reference, popper, options) {\n if (options === void 0) {\n options = defaultOptions;\n }\n\n var state = {\n placement: 'bottom',\n orderedModifiers: [],\n options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),\n modifiersData: {},\n elements: {\n reference: reference,\n popper: popper\n },\n attributes: {},\n styles: {}\n };\n var effectCleanupFns = [];\n var isDestroyed = false;\n var instance = {\n state: state,\n setOptions: function setOptions(setOptionsAction) {\n var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction;\n cleanupModifierEffects();\n state.options = Object.assign({}, defaultOptions, state.options, options);\n state.scrollParents = {\n reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [],\n popper: listScrollParents(popper)\n }; // Orders the modifiers based on their dependencies and `phase`\n // properties\n\n var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers\n\n state.orderedModifiers = orderedModifiers.filter(function (m) {\n return m.enabled;\n });\n runModifierEffects();\n return instance.update();\n },\n // Sync update – it will always be executed, even if not necessary. This\n // is useful for low frequency updates where sync behavior simplifies the\n // logic.\n // For high frequency updates (e.g. `resize` and `scroll` events), always\n // prefer the async Popper#update method\n forceUpdate: function forceUpdate() {\n if (isDestroyed) {\n return;\n }\n\n var _state$elements = state.elements,\n reference = _state$elements.reference,\n popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements\n // anymore\n\n if (!areValidElements(reference, popper)) {\n return;\n } // Store the reference and popper rects to be read by modifiers\n\n\n state.rects = {\n reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),\n popper: getLayoutRect(popper)\n }; // Modifiers have the ability to reset the current update cycle. The\n // most common use case for this is the `flip` modifier changing the\n // placement, which then needs to re-run all the modifiers, because the\n // logic was previously ran for the previous placement and is therefore\n // stale/incorrect\n\n state.reset = false;\n state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier\n // is filled with the initial data specified by the modifier. This means\n // it doesn't persist and is fresh on each update.\n // To ensure persistent data, use `${name}#persistent`\n\n state.orderedModifiers.forEach(function (modifier) {\n return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);\n });\n\n for (var index = 0; index < state.orderedModifiers.length; index++) {\n if (state.reset === true) {\n state.reset = false;\n index = -1;\n continue;\n }\n\n var _state$orderedModifie = state.orderedModifiers[index],\n fn = _state$orderedModifie.fn,\n _state$orderedModifie2 = _state$orderedModifie.options,\n _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2,\n name = _state$orderedModifie.name;\n\n if (typeof fn === 'function') {\n state = fn({\n state: state,\n options: _options,\n name: name,\n instance: instance\n }) || state;\n }\n }\n },\n // Async and optimistically optimized update – it will not be executed if\n // not necessary (debounced to run at most once-per-tick)\n update: debounce(function () {\n return new Promise(function (resolve) {\n instance.forceUpdate();\n resolve(state);\n });\n }),\n destroy: function destroy() {\n cleanupModifierEffects();\n isDestroyed = true;\n }\n };\n\n if (!areValidElements(reference, popper)) {\n return instance;\n }\n\n instance.setOptions(options).then(function (state) {\n if (!isDestroyed && options.onFirstUpdate) {\n options.onFirstUpdate(state);\n }\n }); // Modifiers have the ability to execute arbitrary code before the first\n // update cycle runs. They will be executed in the same order as the update\n // cycle. This is useful when a modifier adds some persistent data that\n // other modifiers need to use, but the modifier is run after the dependent\n // one.\n\n function runModifierEffects() {\n state.orderedModifiers.forEach(function (_ref) {\n var name = _ref.name,\n _ref$options = _ref.options,\n options = _ref$options === void 0 ? {} : _ref$options,\n effect = _ref.effect;\n\n if (typeof effect === 'function') {\n var cleanupFn = effect({\n state: state,\n name: name,\n instance: instance,\n options: options\n });\n\n var noopFn = function noopFn() {};\n\n effectCleanupFns.push(cleanupFn || noopFn);\n }\n });\n }\n\n function cleanupModifierEffects() {\n effectCleanupFns.forEach(function (fn) {\n return fn();\n });\n effectCleanupFns = [];\n }\n\n return instance;\n };\n}\nexport var createPopper = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules\n\nexport { detectOverflow };","export default function debounce(fn) {\n var pending;\n return function () {\n if (!pending) {\n pending = new Promise(function (resolve) {\n Promise.resolve().then(function () {\n pending = undefined;\n resolve(fn());\n });\n });\n }\n\n return pending;\n };\n}","export default function mergeByName(modifiers) {\n var merged = modifiers.reduce(function (merged, current) {\n var existing = merged[current.name];\n merged[current.name] = existing ? Object.assign({}, existing, current, {\n options: Object.assign({}, existing.options, current.options),\n data: Object.assign({}, existing.data, current.data)\n }) : current;\n return merged;\n }, {}); // IE11 does not support Object.values\n\n return Object.keys(merged).map(function (key) {\n return merged[key];\n });\n}","import { popperGenerator, detectOverflow } from \"./createPopper.js\";\nimport eventListeners from \"./modifiers/eventListeners.js\";\nimport popperOffsets from \"./modifiers/popperOffsets.js\";\nimport computeStyles from \"./modifiers/computeStyles.js\";\nimport applyStyles from \"./modifiers/applyStyles.js\";\nimport offset from \"./modifiers/offset.js\";\nimport flip from \"./modifiers/flip.js\";\nimport preventOverflow from \"./modifiers/preventOverflow.js\";\nimport arrow from \"./modifiers/arrow.js\";\nimport hide from \"./modifiers/hide.js\";\nvar defaultModifiers = [eventListeners, popperOffsets, computeStyles, applyStyles, offset, flip, preventOverflow, arrow, hide];\nvar createPopper = /*#__PURE__*/popperGenerator({\n defaultModifiers: defaultModifiers\n}); // eslint-disable-next-line import/no-unused-modules\n\nexport { createPopper, popperGenerator, defaultModifiers, detectOverflow }; // eslint-disable-next-line import/no-unused-modules\n\nexport { createPopper as createPopperLite } from \"./popper-lite.js\"; // eslint-disable-next-line import/no-unused-modules\n\nexport * from \"./modifiers/index.js\";","import { popperGenerator, detectOverflow } from \"./createPopper.js\";\nimport eventListeners from \"./modifiers/eventListeners.js\";\nimport popperOffsets from \"./modifiers/popperOffsets.js\";\nimport computeStyles from \"./modifiers/computeStyles.js\";\nimport applyStyles from \"./modifiers/applyStyles.js\";\nvar defaultModifiers = [eventListeners, popperOffsets, computeStyles, applyStyles];\nvar createPopper = /*#__PURE__*/popperGenerator({\n defaultModifiers: defaultModifiers\n}); // eslint-disable-next-line import/no-unused-modules\n\nexport { createPopper, popperGenerator, defaultModifiers, detectOverflow };","/*!\n * Bootstrap v5.3.2 (https://getbootstrap.com/)\n * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n */\nimport * as Popper from '@popperjs/core';\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap dom/data.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n/**\n * Constants\n */\n\nconst elementMap = new Map();\nconst Data = {\n set(element, key, instance) {\n if (!elementMap.has(element)) {\n elementMap.set(element, new Map());\n }\n const instanceMap = elementMap.get(element);\n\n // make it clear we only want one instance per element\n // can be removed later when multiple key/instances are fine to be used\n if (!instanceMap.has(key) && instanceMap.size !== 0) {\n // eslint-disable-next-line no-console\n console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);\n return;\n }\n instanceMap.set(key, instance);\n },\n get(element, key) {\n if (elementMap.has(element)) {\n return elementMap.get(element).get(key) || null;\n }\n return null;\n },\n remove(element, key) {\n if (!elementMap.has(element)) {\n return;\n }\n const instanceMap = elementMap.get(element);\n instanceMap.delete(key);\n\n // free up element references if there are no instances left for an element\n if (instanceMap.size === 0) {\n elementMap.delete(element);\n }\n }\n};\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/index.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nconst MAX_UID = 1000000;\nconst MILLISECONDS_MULTIPLIER = 1000;\nconst TRANSITION_END = 'transitionend';\n\n/**\n * Properly escape IDs selectors to handle weird IDs\n * @param {string} selector\n * @returns {string}\n */\nconst parseSelector = selector => {\n if (selector && window.CSS && window.CSS.escape) {\n // document.querySelector needs escaping to handle IDs (html5+) containing for instance /\n selector = selector.replace(/#([^\\s\"#']+)/g, (match, id) => `#${CSS.escape(id)}`);\n }\n return selector;\n};\n\n// Shout-out Angus Croll (https://goo.gl/pxwQGp)\nconst toType = object => {\n if (object === null || object === undefined) {\n return `${object}`;\n }\n return Object.prototype.toString.call(object).match(/\\s([a-z]+)/i)[1].toLowerCase();\n};\n\n/**\n * Public Util API\n */\n\nconst getUID = prefix => {\n do {\n prefix += Math.floor(Math.random() * MAX_UID);\n } while (document.getElementById(prefix));\n return prefix;\n};\nconst getTransitionDurationFromElement = element => {\n if (!element) {\n return 0;\n }\n\n // Get transition-duration of the element\n let {\n transitionDuration,\n transitionDelay\n } = window.getComputedStyle(element);\n const floatTransitionDuration = Number.parseFloat(transitionDuration);\n const floatTransitionDelay = Number.parseFloat(transitionDelay);\n\n // Return 0 if element or transition duration is not found\n if (!floatTransitionDuration && !floatTransitionDelay) {\n return 0;\n }\n\n // If multiple durations are defined, take the first\n transitionDuration = transitionDuration.split(',')[0];\n transitionDelay = transitionDelay.split(',')[0];\n return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;\n};\nconst triggerTransitionEnd = element => {\n element.dispatchEvent(new Event(TRANSITION_END));\n};\nconst isElement = object => {\n if (!object || typeof object !== 'object') {\n return false;\n }\n if (typeof object.jquery !== 'undefined') {\n object = object[0];\n }\n return typeof object.nodeType !== 'undefined';\n};\nconst getElement = object => {\n // it's a jQuery object or a node element\n if (isElement(object)) {\n return object.jquery ? object[0] : object;\n }\n if (typeof object === 'string' && object.length > 0) {\n return document.querySelector(parseSelector(object));\n }\n return null;\n};\nconst isVisible = element => {\n if (!isElement(element) || element.getClientRects().length === 0) {\n return false;\n }\n const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible';\n // Handle `details` element as its content may falsie appear visible when it is closed\n const closedDetails = element.closest('details:not([open])');\n if (!closedDetails) {\n return elementIsVisible;\n }\n if (closedDetails !== element) {\n const summary = element.closest('summary');\n if (summary && summary.parentNode !== closedDetails) {\n return false;\n }\n if (summary === null) {\n return false;\n }\n }\n return elementIsVisible;\n};\nconst isDisabled = element => {\n if (!element || element.nodeType !== Node.ELEMENT_NODE) {\n return true;\n }\n if (element.classList.contains('disabled')) {\n return true;\n }\n if (typeof element.disabled !== 'undefined') {\n return element.disabled;\n }\n return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';\n};\nconst findShadowRoot = element => {\n if (!document.documentElement.attachShadow) {\n return null;\n }\n\n // Can find the shadow root otherwise it'll return the document\n if (typeof element.getRootNode === 'function') {\n const root = element.getRootNode();\n return root instanceof ShadowRoot ? root : null;\n }\n if (element instanceof ShadowRoot) {\n return element;\n }\n\n // when we don't find a shadow root\n if (!element.parentNode) {\n return null;\n }\n return findShadowRoot(element.parentNode);\n};\nconst noop = () => {};\n\n/**\n * Trick to restart an element's animation\n *\n * @param {HTMLElement} element\n * @return void\n *\n * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation\n */\nconst reflow = element => {\n element.offsetHeight; // eslint-disable-line no-unused-expressions\n};\n\nconst getjQuery = () => {\n if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {\n return window.jQuery;\n }\n return null;\n};\nconst DOMContentLoadedCallbacks = [];\nconst onDOMContentLoaded = callback => {\n if (document.readyState === 'loading') {\n // add listener on the first call when the document is in loading state\n if (!DOMContentLoadedCallbacks.length) {\n document.addEventListener('DOMContentLoaded', () => {\n for (const callback of DOMContentLoadedCallbacks) {\n callback();\n }\n });\n }\n DOMContentLoadedCallbacks.push(callback);\n } else {\n callback();\n }\n};\nconst isRTL = () => document.documentElement.dir === 'rtl';\nconst defineJQueryPlugin = plugin => {\n onDOMContentLoaded(() => {\n const $ = getjQuery();\n /* istanbul ignore if */\n if ($) {\n const name = plugin.NAME;\n const JQUERY_NO_CONFLICT = $.fn[name];\n $.fn[name] = plugin.jQueryInterface;\n $.fn[name].Constructor = plugin;\n $.fn[name].noConflict = () => {\n $.fn[name] = JQUERY_NO_CONFLICT;\n return plugin.jQueryInterface;\n };\n }\n });\n};\nconst execute = (possibleCallback, args = [], defaultValue = possibleCallback) => {\n return typeof possibleCallback === 'function' ? possibleCallback(...args) : defaultValue;\n};\nconst executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {\n if (!waitForTransition) {\n execute(callback);\n return;\n }\n const durationPadding = 5;\n const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;\n let called = false;\n const handler = ({\n target\n }) => {\n if (target !== transitionElement) {\n return;\n }\n called = true;\n transitionElement.removeEventListener(TRANSITION_END, handler);\n execute(callback);\n };\n transitionElement.addEventListener(TRANSITION_END, handler);\n setTimeout(() => {\n if (!called) {\n triggerTransitionEnd(transitionElement);\n }\n }, emulatedDuration);\n};\n\n/**\n * Return the previous/next element of a list.\n *\n * @param {array} list The list of elements\n * @param activeElement The active element\n * @param shouldGetNext Choose to get next or previous element\n * @param isCycleAllowed\n * @return {Element|elem} The proper element\n */\nconst getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {\n const listLength = list.length;\n let index = list.indexOf(activeElement);\n\n // if the element does not exist in the list return an element\n // depending on the direction and if cycle is allowed\n if (index === -1) {\n return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];\n }\n index += shouldGetNext ? 1 : -1;\n if (isCycleAllowed) {\n index = (index + listLength) % listLength;\n }\n return list[Math.max(0, Math.min(index, listLength - 1))];\n};\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap dom/event-handler.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst namespaceRegex = /[^.]*(?=\\..*)\\.|.*/;\nconst stripNameRegex = /\\..*/;\nconst stripUidRegex = /::\\d+$/;\nconst eventRegistry = {}; // Events storage\nlet uidEvent = 1;\nconst customEvents = {\n mouseenter: 'mouseover',\n mouseleave: 'mouseout'\n};\nconst nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);\n\n/**\n * Private methods\n */\n\nfunction makeEventUid(element, uid) {\n return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;\n}\nfunction getElementEvents(element) {\n const uid = makeEventUid(element);\n element.uidEvent = uid;\n eventRegistry[uid] = eventRegistry[uid] || {};\n return eventRegistry[uid];\n}\nfunction bootstrapHandler(element, fn) {\n return function handler(event) {\n hydrateObj(event, {\n delegateTarget: element\n });\n if (handler.oneOff) {\n EventHandler.off(element, event.type, fn);\n }\n return fn.apply(element, [event]);\n };\n}\nfunction bootstrapDelegationHandler(element, selector, fn) {\n return function handler(event) {\n const domElements = element.querySelectorAll(selector);\n for (let {\n target\n } = event; target && target !== this; target = target.parentNode) {\n for (const domElement of domElements) {\n if (domElement !== target) {\n continue;\n }\n hydrateObj(event, {\n delegateTarget: target\n });\n if (handler.oneOff) {\n EventHandler.off(element, event.type, selector, fn);\n }\n return fn.apply(target, [event]);\n }\n }\n };\n}\nfunction findHandler(events, callable, delegationSelector = null) {\n return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector);\n}\nfunction normalizeParameters(originalTypeEvent, handler, delegationFunction) {\n const isDelegated = typeof handler === 'string';\n // TODO: tooltip passes `false` instead of selector, so we need to check\n const callable = isDelegated ? delegationFunction : handler || delegationFunction;\n let typeEvent = getTypeEvent(originalTypeEvent);\n if (!nativeEvents.has(typeEvent)) {\n typeEvent = originalTypeEvent;\n }\n return [isDelegated, callable, typeEvent];\n}\nfunction addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {\n if (typeof originalTypeEvent !== 'string' || !element) {\n return;\n }\n let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);\n\n // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position\n // this prevents the handler from being dispatched the same way as mouseover or mouseout does\n if (originalTypeEvent in customEvents) {\n const wrapFunction = fn => {\n return function (event) {\n if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {\n return fn.call(this, event);\n }\n };\n };\n callable = wrapFunction(callable);\n }\n const events = getElementEvents(element);\n const handlers = events[typeEvent] || (events[typeEvent] = {});\n const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);\n if (previousFunction) {\n previousFunction.oneOff = previousFunction.oneOff && oneOff;\n return;\n }\n const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));\n const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);\n fn.delegationSelector = isDelegated ? handler : null;\n fn.callable = callable;\n fn.oneOff = oneOff;\n fn.uidEvent = uid;\n handlers[uid] = fn;\n element.addEventListener(typeEvent, fn, isDelegated);\n}\nfunction removeHandler(element, events, typeEvent, handler, delegationSelector) {\n const fn = findHandler(events[typeEvent], handler, delegationSelector);\n if (!fn) {\n return;\n }\n element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));\n delete events[typeEvent][fn.uidEvent];\n}\nfunction removeNamespacedHandlers(element, events, typeEvent, namespace) {\n const storeElementEvent = events[typeEvent] || {};\n for (const [handlerKey, event] of Object.entries(storeElementEvent)) {\n if (handlerKey.includes(namespace)) {\n removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);\n }\n }\n}\nfunction getTypeEvent(event) {\n // allow to get the native events from namespaced events ('click.bs.button' --> 'click')\n event = event.replace(stripNameRegex, '');\n return customEvents[event] || event;\n}\nconst EventHandler = {\n on(element, event, handler, delegationFunction) {\n addHandler(element, event, handler, delegationFunction, false);\n },\n one(element, event, handler, delegationFunction) {\n addHandler(element, event, handler, delegationFunction, true);\n },\n off(element, originalTypeEvent, handler, delegationFunction) {\n if (typeof originalTypeEvent !== 'string' || !element) {\n return;\n }\n const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);\n const inNamespace = typeEvent !== originalTypeEvent;\n const events = getElementEvents(element);\n const storeElementEvent = events[typeEvent] || {};\n const isNamespace = originalTypeEvent.startsWith('.');\n if (typeof callable !== 'undefined') {\n // Simplest case: handler is passed, remove that listener ONLY.\n if (!Object.keys(storeElementEvent).length) {\n return;\n }\n removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);\n return;\n }\n if (isNamespace) {\n for (const elementEvent of Object.keys(events)) {\n removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));\n }\n }\n for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {\n const handlerKey = keyHandlers.replace(stripUidRegex, '');\n if (!inNamespace || originalTypeEvent.includes(handlerKey)) {\n removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);\n }\n }\n },\n trigger(element, event, args) {\n if (typeof event !== 'string' || !element) {\n return null;\n }\n const $ = getjQuery();\n const typeEvent = getTypeEvent(event);\n const inNamespace = event !== typeEvent;\n let jQueryEvent = null;\n let bubbles = true;\n let nativeDispatch = true;\n let defaultPrevented = false;\n if (inNamespace && $) {\n jQueryEvent = $.Event(event, args);\n $(element).trigger(jQueryEvent);\n bubbles = !jQueryEvent.isPropagationStopped();\n nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();\n defaultPrevented = jQueryEvent.isDefaultPrevented();\n }\n const evt = hydrateObj(new Event(event, {\n bubbles,\n cancelable: true\n }), args);\n if (defaultPrevented) {\n evt.preventDefault();\n }\n if (nativeDispatch) {\n element.dispatchEvent(evt);\n }\n if (evt.defaultPrevented && jQueryEvent) {\n jQueryEvent.preventDefault();\n }\n return evt;\n }\n};\nfunction hydrateObj(obj, meta = {}) {\n for (const [key, value] of Object.entries(meta)) {\n try {\n obj[key] = value;\n } catch (_unused) {\n Object.defineProperty(obj, key, {\n configurable: true,\n get() {\n return value;\n }\n });\n }\n }\n return obj;\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap dom/manipulator.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nfunction normalizeData(value) {\n if (value === 'true') {\n return true;\n }\n if (value === 'false') {\n return false;\n }\n if (value === Number(value).toString()) {\n return Number(value);\n }\n if (value === '' || value === 'null') {\n return null;\n }\n if (typeof value !== 'string') {\n return value;\n }\n try {\n return JSON.parse(decodeURIComponent(value));\n } catch (_unused) {\n return value;\n }\n}\nfunction normalizeDataKey(key) {\n return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);\n}\nconst Manipulator = {\n setDataAttribute(element, key, value) {\n element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);\n },\n removeDataAttribute(element, key) {\n element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);\n },\n getDataAttributes(element) {\n if (!element) {\n return {};\n }\n const attributes = {};\n const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'));\n for (const key of bsKeys) {\n let pureKey = key.replace(/^bs/, '');\n pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);\n attributes[pureKey] = normalizeData(element.dataset[key]);\n }\n return attributes;\n },\n getDataAttribute(element, key) {\n return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));\n }\n};\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/config.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Class definition\n */\n\nclass Config {\n // Getters\n static get Default() {\n return {};\n }\n static get DefaultType() {\n return {};\n }\n static get NAME() {\n throw new Error('You have to implement the static method \"NAME\", for each component!');\n }\n _getConfig(config) {\n config = this._mergeConfigObj(config);\n config = this._configAfterMerge(config);\n this._typeCheckConfig(config);\n return config;\n }\n _configAfterMerge(config) {\n return config;\n }\n _mergeConfigObj(config, element) {\n const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse\n\n return {\n ...this.constructor.Default,\n ...(typeof jsonConfig === 'object' ? jsonConfig : {}),\n ...(isElement(element) ? Manipulator.getDataAttributes(element) : {}),\n ...(typeof config === 'object' ? config : {})\n };\n }\n _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {\n for (const [property, expectedTypes] of Object.entries(configTypes)) {\n const value = config[property];\n const valueType = isElement(value) ? 'element' : toType(value);\n if (!new RegExp(expectedTypes).test(valueType)) {\n throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option \"${property}\" provided type \"${valueType}\" but expected type \"${expectedTypes}\".`);\n }\n }\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap base-component.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst VERSION = '5.3.2';\n\n/**\n * Class definition\n */\n\nclass BaseComponent extends Config {\n constructor(element, config) {\n super();\n element = getElement(element);\n if (!element) {\n return;\n }\n this._element = element;\n this._config = this._getConfig(config);\n Data.set(this._element, this.constructor.DATA_KEY, this);\n }\n\n // Public\n dispose() {\n Data.remove(this._element, this.constructor.DATA_KEY);\n EventHandler.off(this._element, this.constructor.EVENT_KEY);\n for (const propertyName of Object.getOwnPropertyNames(this)) {\n this[propertyName] = null;\n }\n }\n _queueCallback(callback, element, isAnimated = true) {\n executeAfterTransition(callback, element, isAnimated);\n }\n _getConfig(config) {\n config = this._mergeConfigObj(config, this._element);\n config = this._configAfterMerge(config);\n this._typeCheckConfig(config);\n return config;\n }\n\n // Static\n static getInstance(element) {\n return Data.get(getElement(element), this.DATA_KEY);\n }\n static getOrCreateInstance(element, config = {}) {\n return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);\n }\n static get VERSION() {\n return VERSION;\n }\n static get DATA_KEY() {\n return `bs.${this.NAME}`;\n }\n static get EVENT_KEY() {\n return `.${this.DATA_KEY}`;\n }\n static eventName(name) {\n return `${name}${this.EVENT_KEY}`;\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap dom/selector-engine.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nconst getSelector = element => {\n let selector = element.getAttribute('data-bs-target');\n if (!selector || selector === '#') {\n let hrefAttribute = element.getAttribute('href');\n\n // The only valid content that could double as a selector are IDs or classes,\n // so everything starting with `#` or `.`. If a \"real\" URL is used as the selector,\n // `document.querySelector` will rightfully complain it is invalid.\n // See https://github.com/twbs/bootstrap/issues/32273\n if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) {\n return null;\n }\n\n // Just in case some CMS puts out a full URL with the anchor appended\n if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {\n hrefAttribute = `#${hrefAttribute.split('#')[1]}`;\n }\n selector = hrefAttribute && hrefAttribute !== '#' ? parseSelector(hrefAttribute.trim()) : null;\n }\n return selector;\n};\nconst SelectorEngine = {\n find(selector, element = document.documentElement) {\n return [].concat(...Element.prototype.querySelectorAll.call(element, selector));\n },\n findOne(selector, element = document.documentElement) {\n return Element.prototype.querySelector.call(element, selector);\n },\n children(element, selector) {\n return [].concat(...element.children).filter(child => child.matches(selector));\n },\n parents(element, selector) {\n const parents = [];\n let ancestor = element.parentNode.closest(selector);\n while (ancestor) {\n parents.push(ancestor);\n ancestor = ancestor.parentNode.closest(selector);\n }\n return parents;\n },\n prev(element, selector) {\n let previous = element.previousElementSibling;\n while (previous) {\n if (previous.matches(selector)) {\n return [previous];\n }\n previous = previous.previousElementSibling;\n }\n return [];\n },\n // TODO: this is now unused; remove later along with prev()\n next(element, selector) {\n let next = element.nextElementSibling;\n while (next) {\n if (next.matches(selector)) {\n return [next];\n }\n next = next.nextElementSibling;\n }\n return [];\n },\n focusableChildren(element) {\n const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable=\"true\"]'].map(selector => `${selector}:not([tabindex^=\"-\"])`).join(',');\n return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));\n },\n getSelectorFromElement(element) {\n const selector = getSelector(element);\n if (selector) {\n return SelectorEngine.findOne(selector) ? selector : null;\n }\n return null;\n },\n getElementFromSelector(element) {\n const selector = getSelector(element);\n return selector ? SelectorEngine.findOne(selector) : null;\n },\n getMultipleElementsFromSelector(element) {\n const selector = getSelector(element);\n return selector ? SelectorEngine.find(selector) : [];\n }\n};\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/component-functions.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\nconst enableDismissTrigger = (component, method = 'hide') => {\n const clickEvent = `click.dismiss${component.EVENT_KEY}`;\n const name = component.NAME;\n EventHandler.on(document, clickEvent, `[data-bs-dismiss=\"${name}\"]`, function (event) {\n if (['A', 'AREA'].includes(this.tagName)) {\n event.preventDefault();\n }\n if (isDisabled(this)) {\n return;\n }\n const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);\n const instance = component.getOrCreateInstance(target);\n\n // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method\n instance[method]();\n });\n};\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap alert.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$f = 'alert';\nconst DATA_KEY$a = 'bs.alert';\nconst EVENT_KEY$b = `.${DATA_KEY$a}`;\nconst EVENT_CLOSE = `close${EVENT_KEY$b}`;\nconst EVENT_CLOSED = `closed${EVENT_KEY$b}`;\nconst CLASS_NAME_FADE$5 = 'fade';\nconst CLASS_NAME_SHOW$8 = 'show';\n\n/**\n * Class definition\n */\n\nclass Alert extends BaseComponent {\n // Getters\n static get NAME() {\n return NAME$f;\n }\n\n // Public\n close() {\n const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);\n if (closeEvent.defaultPrevented) {\n return;\n }\n this._element.classList.remove(CLASS_NAME_SHOW$8);\n const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);\n this._queueCallback(() => this._destroyElement(), this._element, isAnimated);\n }\n\n // Private\n _destroyElement() {\n this._element.remove();\n EventHandler.trigger(this._element, EVENT_CLOSED);\n this.dispose();\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Alert.getOrCreateInstance(this);\n if (typeof config !== 'string') {\n return;\n }\n if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config](this);\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nenableDismissTrigger(Alert, 'close');\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Alert);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap button.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$e = 'button';\nconst DATA_KEY$9 = 'bs.button';\nconst EVENT_KEY$a = `.${DATA_KEY$9}`;\nconst DATA_API_KEY$6 = '.data-api';\nconst CLASS_NAME_ACTIVE$3 = 'active';\nconst SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle=\"button\"]';\nconst EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;\n\n/**\n * Class definition\n */\n\nclass Button extends BaseComponent {\n // Getters\n static get NAME() {\n return NAME$e;\n }\n\n // Public\n toggle() {\n // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method\n this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Button.getOrCreateInstance(this);\n if (config === 'toggle') {\n data[config]();\n }\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {\n event.preventDefault();\n const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);\n const data = Button.getOrCreateInstance(button);\n data.toggle();\n});\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Button);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/swipe.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$d = 'swipe';\nconst EVENT_KEY$9 = '.bs.swipe';\nconst EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;\nconst EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;\nconst EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;\nconst EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;\nconst EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;\nconst POINTER_TYPE_TOUCH = 'touch';\nconst POINTER_TYPE_PEN = 'pen';\nconst CLASS_NAME_POINTER_EVENT = 'pointer-event';\nconst SWIPE_THRESHOLD = 40;\nconst Default$c = {\n endCallback: null,\n leftCallback: null,\n rightCallback: null\n};\nconst DefaultType$c = {\n endCallback: '(function|null)',\n leftCallback: '(function|null)',\n rightCallback: '(function|null)'\n};\n\n/**\n * Class definition\n */\n\nclass Swipe extends Config {\n constructor(element, config) {\n super();\n this._element = element;\n if (!element || !Swipe.isSupported()) {\n return;\n }\n this._config = this._getConfig(config);\n this._deltaX = 0;\n this._supportPointerEvents = Boolean(window.PointerEvent);\n this._initEvents();\n }\n\n // Getters\n static get Default() {\n return Default$c;\n }\n static get DefaultType() {\n return DefaultType$c;\n }\n static get NAME() {\n return NAME$d;\n }\n\n // Public\n dispose() {\n EventHandler.off(this._element, EVENT_KEY$9);\n }\n\n // Private\n _start(event) {\n if (!this._supportPointerEvents) {\n this._deltaX = event.touches[0].clientX;\n return;\n }\n if (this._eventIsPointerPenTouch(event)) {\n this._deltaX = event.clientX;\n }\n }\n _end(event) {\n if (this._eventIsPointerPenTouch(event)) {\n this._deltaX = event.clientX - this._deltaX;\n }\n this._handleSwipe();\n execute(this._config.endCallback);\n }\n _move(event) {\n this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;\n }\n _handleSwipe() {\n const absDeltaX = Math.abs(this._deltaX);\n if (absDeltaX <= SWIPE_THRESHOLD) {\n return;\n }\n const direction = absDeltaX / this._deltaX;\n this._deltaX = 0;\n if (!direction) {\n return;\n }\n execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);\n }\n _initEvents() {\n if (this._supportPointerEvents) {\n EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event));\n EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event));\n this._element.classList.add(CLASS_NAME_POINTER_EVENT);\n } else {\n EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event));\n EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event));\n EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event));\n }\n }\n _eventIsPointerPenTouch(event) {\n return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);\n }\n\n // Static\n static isSupported() {\n return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap carousel.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$c = 'carousel';\nconst DATA_KEY$8 = 'bs.carousel';\nconst EVENT_KEY$8 = `.${DATA_KEY$8}`;\nconst DATA_API_KEY$5 = '.data-api';\nconst ARROW_LEFT_KEY$1 = 'ArrowLeft';\nconst ARROW_RIGHT_KEY$1 = 'ArrowRight';\nconst TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch\n\nconst ORDER_NEXT = 'next';\nconst ORDER_PREV = 'prev';\nconst DIRECTION_LEFT = 'left';\nconst DIRECTION_RIGHT = 'right';\nconst EVENT_SLIDE = `slide${EVENT_KEY$8}`;\nconst EVENT_SLID = `slid${EVENT_KEY$8}`;\nconst EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;\nconst EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;\nconst EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;\nconst EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;\nconst EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;\nconst EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;\nconst CLASS_NAME_CAROUSEL = 'carousel';\nconst CLASS_NAME_ACTIVE$2 = 'active';\nconst CLASS_NAME_SLIDE = 'slide';\nconst CLASS_NAME_END = 'carousel-item-end';\nconst CLASS_NAME_START = 'carousel-item-start';\nconst CLASS_NAME_NEXT = 'carousel-item-next';\nconst CLASS_NAME_PREV = 'carousel-item-prev';\nconst SELECTOR_ACTIVE = '.active';\nconst SELECTOR_ITEM = '.carousel-item';\nconst SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;\nconst SELECTOR_ITEM_IMG = '.carousel-item img';\nconst SELECTOR_INDICATORS = '.carousel-indicators';\nconst SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';\nconst SELECTOR_DATA_RIDE = '[data-bs-ride=\"carousel\"]';\nconst KEY_TO_DIRECTION = {\n [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,\n [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT\n};\nconst Default$b = {\n interval: 5000,\n keyboard: true,\n pause: 'hover',\n ride: false,\n touch: true,\n wrap: true\n};\nconst DefaultType$b = {\n interval: '(number|boolean)',\n // TODO:v6 remove boolean support\n keyboard: 'boolean',\n pause: '(string|boolean)',\n ride: '(boolean|string)',\n touch: 'boolean',\n wrap: 'boolean'\n};\n\n/**\n * Class definition\n */\n\nclass Carousel extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._interval = null;\n this._activeElement = null;\n this._isSliding = false;\n this.touchTimeout = null;\n this._swipeHelper = null;\n this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);\n this._addEventListeners();\n if (this._config.ride === CLASS_NAME_CAROUSEL) {\n this.cycle();\n }\n }\n\n // Getters\n static get Default() {\n return Default$b;\n }\n static get DefaultType() {\n return DefaultType$b;\n }\n static get NAME() {\n return NAME$c;\n }\n\n // Public\n next() {\n this._slide(ORDER_NEXT);\n }\n nextWhenVisible() {\n // FIXME TODO use `document.visibilityState`\n // Don't call next when the page isn't visible\n // or the carousel or its parent isn't visible\n if (!document.hidden && isVisible(this._element)) {\n this.next();\n }\n }\n prev() {\n this._slide(ORDER_PREV);\n }\n pause() {\n if (this._isSliding) {\n triggerTransitionEnd(this._element);\n }\n this._clearInterval();\n }\n cycle() {\n this._clearInterval();\n this._updateInterval();\n this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);\n }\n _maybeEnableCycle() {\n if (!this._config.ride) {\n return;\n }\n if (this._isSliding) {\n EventHandler.one(this._element, EVENT_SLID, () => this.cycle());\n return;\n }\n this.cycle();\n }\n to(index) {\n const items = this._getItems();\n if (index > items.length - 1 || index < 0) {\n return;\n }\n if (this._isSliding) {\n EventHandler.one(this._element, EVENT_SLID, () => this.to(index));\n return;\n }\n const activeIndex = this._getItemIndex(this._getActive());\n if (activeIndex === index) {\n return;\n }\n const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;\n this._slide(order, items[index]);\n }\n dispose() {\n if (this._swipeHelper) {\n this._swipeHelper.dispose();\n }\n super.dispose();\n }\n\n // Private\n _configAfterMerge(config) {\n config.defaultInterval = config.interval;\n return config;\n }\n _addEventListeners() {\n if (this._config.keyboard) {\n EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event));\n }\n if (this._config.pause === 'hover') {\n EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());\n EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());\n }\n if (this._config.touch && Swipe.isSupported()) {\n this._addTouchEventListeners();\n }\n }\n _addTouchEventListeners() {\n for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {\n EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault());\n }\n const endCallBack = () => {\n if (this._config.pause !== 'hover') {\n return;\n }\n\n // If it's a touch-enabled device, mouseenter/leave are fired as\n // part of the mouse compatibility events on first tap - the carousel\n // would stop cycling until user tapped out of it;\n // here, we listen for touchend, explicitly pause the carousel\n // (as if it's the second time we tap on it, mouseenter compat event\n // is NOT fired) and after a timeout (to allow for mouse compatibility\n // events to fire) we explicitly restart cycling\n\n this.pause();\n if (this.touchTimeout) {\n clearTimeout(this.touchTimeout);\n }\n this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);\n };\n const swipeConfig = {\n leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),\n rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),\n endCallback: endCallBack\n };\n this._swipeHelper = new Swipe(this._element, swipeConfig);\n }\n _keydown(event) {\n if (/input|textarea/i.test(event.target.tagName)) {\n return;\n }\n const direction = KEY_TO_DIRECTION[event.key];\n if (direction) {\n event.preventDefault();\n this._slide(this._directionToOrder(direction));\n }\n }\n _getItemIndex(element) {\n return this._getItems().indexOf(element);\n }\n _setActiveIndicatorElement(index) {\n if (!this._indicatorsElement) {\n return;\n }\n const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);\n activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);\n activeIndicator.removeAttribute('aria-current');\n const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to=\"${index}\"]`, this._indicatorsElement);\n if (newActiveIndicator) {\n newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);\n newActiveIndicator.setAttribute('aria-current', 'true');\n }\n }\n _updateInterval() {\n const element = this._activeElement || this._getActive();\n if (!element) {\n return;\n }\n const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);\n this._config.interval = elementInterval || this._config.defaultInterval;\n }\n _slide(order, element = null) {\n if (this._isSliding) {\n return;\n }\n const activeElement = this._getActive();\n const isNext = order === ORDER_NEXT;\n const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);\n if (nextElement === activeElement) {\n return;\n }\n const nextElementIndex = this._getItemIndex(nextElement);\n const triggerEvent = eventName => {\n return EventHandler.trigger(this._element, eventName, {\n relatedTarget: nextElement,\n direction: this._orderToDirection(order),\n from: this._getItemIndex(activeElement),\n to: nextElementIndex\n });\n };\n const slideEvent = triggerEvent(EVENT_SLIDE);\n if (slideEvent.defaultPrevented) {\n return;\n }\n if (!activeElement || !nextElement) {\n // Some weirdness is happening, so we bail\n // TODO: change tests that use empty divs to avoid this check\n return;\n }\n const isCycling = Boolean(this._interval);\n this.pause();\n this._isSliding = true;\n this._setActiveIndicatorElement(nextElementIndex);\n this._activeElement = nextElement;\n const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;\n const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;\n nextElement.classList.add(orderClassName);\n reflow(nextElement);\n activeElement.classList.add(directionalClassName);\n nextElement.classList.add(directionalClassName);\n const completeCallBack = () => {\n nextElement.classList.remove(directionalClassName, orderClassName);\n nextElement.classList.add(CLASS_NAME_ACTIVE$2);\n activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);\n this._isSliding = false;\n triggerEvent(EVENT_SLID);\n };\n this._queueCallback(completeCallBack, activeElement, this._isAnimated());\n if (isCycling) {\n this.cycle();\n }\n }\n _isAnimated() {\n return this._element.classList.contains(CLASS_NAME_SLIDE);\n }\n _getActive() {\n return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);\n }\n _getItems() {\n return SelectorEngine.find(SELECTOR_ITEM, this._element);\n }\n _clearInterval() {\n if (this._interval) {\n clearInterval(this._interval);\n this._interval = null;\n }\n }\n _directionToOrder(direction) {\n if (isRTL()) {\n return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;\n }\n return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;\n }\n _orderToDirection(order) {\n if (isRTL()) {\n return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;\n }\n return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Carousel.getOrCreateInstance(this, config);\n if (typeof config === 'number') {\n data.to(config);\n return;\n }\n if (typeof config === 'string') {\n if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n }\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) {\n const target = SelectorEngine.getElementFromSelector(this);\n if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {\n return;\n }\n event.preventDefault();\n const carousel = Carousel.getOrCreateInstance(target);\n const slideIndex = this.getAttribute('data-bs-slide-to');\n if (slideIndex) {\n carousel.to(slideIndex);\n carousel._maybeEnableCycle();\n return;\n }\n if (Manipulator.getDataAttribute(this, 'slide') === 'next') {\n carousel.next();\n carousel._maybeEnableCycle();\n return;\n }\n carousel.prev();\n carousel._maybeEnableCycle();\n});\nEventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {\n const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);\n for (const carousel of carousels) {\n Carousel.getOrCreateInstance(carousel);\n }\n});\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Carousel);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap collapse.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$b = 'collapse';\nconst DATA_KEY$7 = 'bs.collapse';\nconst EVENT_KEY$7 = `.${DATA_KEY$7}`;\nconst DATA_API_KEY$4 = '.data-api';\nconst EVENT_SHOW$6 = `show${EVENT_KEY$7}`;\nconst EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;\nconst EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;\nconst EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;\nconst EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;\nconst CLASS_NAME_SHOW$7 = 'show';\nconst CLASS_NAME_COLLAPSE = 'collapse';\nconst CLASS_NAME_COLLAPSING = 'collapsing';\nconst CLASS_NAME_COLLAPSED = 'collapsed';\nconst CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;\nconst CLASS_NAME_HORIZONTAL = 'collapse-horizontal';\nconst WIDTH = 'width';\nconst HEIGHT = 'height';\nconst SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';\nconst SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle=\"collapse\"]';\nconst Default$a = {\n parent: null,\n toggle: true\n};\nconst DefaultType$a = {\n parent: '(null|element)',\n toggle: 'boolean'\n};\n\n/**\n * Class definition\n */\n\nclass Collapse extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._isTransitioning = false;\n this._triggerArray = [];\n const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);\n for (const elem of toggleList) {\n const selector = SelectorEngine.getSelectorFromElement(elem);\n const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element);\n if (selector !== null && filterElement.length) {\n this._triggerArray.push(elem);\n }\n }\n this._initializeChildren();\n if (!this._config.parent) {\n this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());\n }\n if (this._config.toggle) {\n this.toggle();\n }\n }\n\n // Getters\n static get Default() {\n return Default$a;\n }\n static get DefaultType() {\n return DefaultType$a;\n }\n static get NAME() {\n return NAME$b;\n }\n\n // Public\n toggle() {\n if (this._isShown()) {\n this.hide();\n } else {\n this.show();\n }\n }\n show() {\n if (this._isTransitioning || this._isShown()) {\n return;\n }\n let activeChildren = [];\n\n // find active children\n if (this._config.parent) {\n activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, {\n toggle: false\n }));\n }\n if (activeChildren.length && activeChildren[0]._isTransitioning) {\n return;\n }\n const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);\n if (startEvent.defaultPrevented) {\n return;\n }\n for (const activeInstance of activeChildren) {\n activeInstance.hide();\n }\n const dimension = this._getDimension();\n this._element.classList.remove(CLASS_NAME_COLLAPSE);\n this._element.classList.add(CLASS_NAME_COLLAPSING);\n this._element.style[dimension] = 0;\n this._addAriaAndCollapsedClass(this._triggerArray, true);\n this._isTransitioning = true;\n const complete = () => {\n this._isTransitioning = false;\n this._element.classList.remove(CLASS_NAME_COLLAPSING);\n this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);\n this._element.style[dimension] = '';\n EventHandler.trigger(this._element, EVENT_SHOWN$6);\n };\n const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);\n const scrollSize = `scroll${capitalizedDimension}`;\n this._queueCallback(complete, this._element, true);\n this._element.style[dimension] = `${this._element[scrollSize]}px`;\n }\n hide() {\n if (this._isTransitioning || !this._isShown()) {\n return;\n }\n const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);\n if (startEvent.defaultPrevented) {\n return;\n }\n const dimension = this._getDimension();\n this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;\n reflow(this._element);\n this._element.classList.add(CLASS_NAME_COLLAPSING);\n this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);\n for (const trigger of this._triggerArray) {\n const element = SelectorEngine.getElementFromSelector(trigger);\n if (element && !this._isShown(element)) {\n this._addAriaAndCollapsedClass([trigger], false);\n }\n }\n this._isTransitioning = true;\n const complete = () => {\n this._isTransitioning = false;\n this._element.classList.remove(CLASS_NAME_COLLAPSING);\n this._element.classList.add(CLASS_NAME_COLLAPSE);\n EventHandler.trigger(this._element, EVENT_HIDDEN$6);\n };\n this._element.style[dimension] = '';\n this._queueCallback(complete, this._element, true);\n }\n _isShown(element = this._element) {\n return element.classList.contains(CLASS_NAME_SHOW$7);\n }\n\n // Private\n _configAfterMerge(config) {\n config.toggle = Boolean(config.toggle); // Coerce string values\n config.parent = getElement(config.parent);\n return config;\n }\n _getDimension() {\n return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;\n }\n _initializeChildren() {\n if (!this._config.parent) {\n return;\n }\n const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);\n for (const element of children) {\n const selected = SelectorEngine.getElementFromSelector(element);\n if (selected) {\n this._addAriaAndCollapsedClass([element], this._isShown(selected));\n }\n }\n }\n _getFirstLevelChildren(selector) {\n const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);\n // remove children if greater depth\n return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element));\n }\n _addAriaAndCollapsedClass(triggerArray, isOpen) {\n if (!triggerArray.length) {\n return;\n }\n for (const element of triggerArray) {\n element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);\n element.setAttribute('aria-expanded', isOpen);\n }\n }\n\n // Static\n static jQueryInterface(config) {\n const _config = {};\n if (typeof config === 'string' && /show|hide/.test(config)) {\n _config.toggle = false;\n }\n return this.each(function () {\n const data = Collapse.getOrCreateInstance(this, _config);\n if (typeof config === 'string') {\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n }\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {\n // preventDefault only for elements (which change the URL) not inside the collapsible element\n if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {\n event.preventDefault();\n }\n for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {\n Collapse.getOrCreateInstance(element, {\n toggle: false\n }).toggle();\n }\n});\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Collapse);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap dropdown.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$a = 'dropdown';\nconst DATA_KEY$6 = 'bs.dropdown';\nconst EVENT_KEY$6 = `.${DATA_KEY$6}`;\nconst DATA_API_KEY$3 = '.data-api';\nconst ESCAPE_KEY$2 = 'Escape';\nconst TAB_KEY$1 = 'Tab';\nconst ARROW_UP_KEY$1 = 'ArrowUp';\nconst ARROW_DOWN_KEY$1 = 'ArrowDown';\nconst RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button\n\nconst EVENT_HIDE$5 = `hide${EVENT_KEY$6}`;\nconst EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`;\nconst EVENT_SHOW$5 = `show${EVENT_KEY$6}`;\nconst EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`;\nconst EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;\nconst EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`;\nconst EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`;\nconst CLASS_NAME_SHOW$6 = 'show';\nconst CLASS_NAME_DROPUP = 'dropup';\nconst CLASS_NAME_DROPEND = 'dropend';\nconst CLASS_NAME_DROPSTART = 'dropstart';\nconst CLASS_NAME_DROPUP_CENTER = 'dropup-center';\nconst CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';\nconst SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle=\"dropdown\"]:not(.disabled):not(:disabled)';\nconst SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`;\nconst SELECTOR_MENU = '.dropdown-menu';\nconst SELECTOR_NAVBAR = '.navbar';\nconst SELECTOR_NAVBAR_NAV = '.navbar-nav';\nconst SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';\nconst PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';\nconst PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';\nconst PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';\nconst PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';\nconst PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';\nconst PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';\nconst PLACEMENT_TOPCENTER = 'top';\nconst PLACEMENT_BOTTOMCENTER = 'bottom';\nconst Default$9 = {\n autoClose: true,\n boundary: 'clippingParents',\n display: 'dynamic',\n offset: [0, 2],\n popperConfig: null,\n reference: 'toggle'\n};\nconst DefaultType$9 = {\n autoClose: '(boolean|string)',\n boundary: '(string|element)',\n display: 'string',\n offset: '(array|string|function)',\n popperConfig: '(null|object|function)',\n reference: '(string|element|object)'\n};\n\n/**\n * Class definition\n */\n\nclass Dropdown extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._popper = null;\n this._parent = this._element.parentNode; // dropdown wrapper\n // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/\n this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent);\n this._inNavbar = this._detectNavbar();\n }\n\n // Getters\n static get Default() {\n return Default$9;\n }\n static get DefaultType() {\n return DefaultType$9;\n }\n static get NAME() {\n return NAME$a;\n }\n\n // Public\n toggle() {\n return this._isShown() ? this.hide() : this.show();\n }\n show() {\n if (isDisabled(this._element) || this._isShown()) {\n return;\n }\n const relatedTarget = {\n relatedTarget: this._element\n };\n const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget);\n if (showEvent.defaultPrevented) {\n return;\n }\n this._createPopper();\n\n // If this is a touch-enabled device we add extra\n // empty mouseover listeners to the body's immediate children;\n // only needed because of broken event delegation on iOS\n // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html\n if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.on(element, 'mouseover', noop);\n }\n }\n this._element.focus();\n this._element.setAttribute('aria-expanded', true);\n this._menu.classList.add(CLASS_NAME_SHOW$6);\n this._element.classList.add(CLASS_NAME_SHOW$6);\n EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget);\n }\n hide() {\n if (isDisabled(this._element) || !this._isShown()) {\n return;\n }\n const relatedTarget = {\n relatedTarget: this._element\n };\n this._completeHide(relatedTarget);\n }\n dispose() {\n if (this._popper) {\n this._popper.destroy();\n }\n super.dispose();\n }\n update() {\n this._inNavbar = this._detectNavbar();\n if (this._popper) {\n this._popper.update();\n }\n }\n\n // Private\n _completeHide(relatedTarget) {\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget);\n if (hideEvent.defaultPrevented) {\n return;\n }\n\n // If this is a touch-enabled device we remove the extra\n // empty mouseover listeners we added for iOS support\n if ('ontouchstart' in document.documentElement) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.off(element, 'mouseover', noop);\n }\n }\n if (this._popper) {\n this._popper.destroy();\n }\n this._menu.classList.remove(CLASS_NAME_SHOW$6);\n this._element.classList.remove(CLASS_NAME_SHOW$6);\n this._element.setAttribute('aria-expanded', 'false');\n Manipulator.removeDataAttribute(this._menu, 'popper');\n EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget);\n }\n _getConfig(config) {\n config = super._getConfig(config);\n if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {\n // Popper virtual elements require a getBoundingClientRect method\n throw new TypeError(`${NAME$a.toUpperCase()}: Option \"reference\" provided type \"object\" without a required \"getBoundingClientRect\" method.`);\n }\n return config;\n }\n _createPopper() {\n if (typeof Popper === 'undefined') {\n throw new TypeError('Bootstrap\\'s dropdowns require Popper (https://popper.js.org)');\n }\n let referenceElement = this._element;\n if (this._config.reference === 'parent') {\n referenceElement = this._parent;\n } else if (isElement(this._config.reference)) {\n referenceElement = getElement(this._config.reference);\n } else if (typeof this._config.reference === 'object') {\n referenceElement = this._config.reference;\n }\n const popperConfig = this._getPopperConfig();\n this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig);\n }\n _isShown() {\n return this._menu.classList.contains(CLASS_NAME_SHOW$6);\n }\n _getPlacement() {\n const parentDropdown = this._parent;\n if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {\n return PLACEMENT_RIGHT;\n }\n if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {\n return PLACEMENT_LEFT;\n }\n if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {\n return PLACEMENT_TOPCENTER;\n }\n if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {\n return PLACEMENT_BOTTOMCENTER;\n }\n\n // We need to trim the value because custom properties can also include spaces\n const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';\n if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {\n return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;\n }\n return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;\n }\n _detectNavbar() {\n return this._element.closest(SELECTOR_NAVBAR) !== null;\n }\n _getOffset() {\n const {\n offset\n } = this._config;\n if (typeof offset === 'string') {\n return offset.split(',').map(value => Number.parseInt(value, 10));\n }\n if (typeof offset === 'function') {\n return popperData => offset(popperData, this._element);\n }\n return offset;\n }\n _getPopperConfig() {\n const defaultBsPopperConfig = {\n placement: this._getPlacement(),\n modifiers: [{\n name: 'preventOverflow',\n options: {\n boundary: this._config.boundary\n }\n }, {\n name: 'offset',\n options: {\n offset: this._getOffset()\n }\n }]\n };\n\n // Disable Popper if we have a static display or Dropdown is in Navbar\n if (this._inNavbar || this._config.display === 'static') {\n Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove\n defaultBsPopperConfig.modifiers = [{\n name: 'applyStyles',\n enabled: false\n }];\n }\n return {\n ...defaultBsPopperConfig,\n ...execute(this._config.popperConfig, [defaultBsPopperConfig])\n };\n }\n _selectMenuItem({\n key,\n target\n }) {\n const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element));\n if (!items.length) {\n return;\n }\n\n // if target isn't included in items (e.g. when expanding the dropdown)\n // allow cycling to get the last item in case key equals ARROW_UP_KEY\n getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus();\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Dropdown.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n });\n }\n static clearMenus(event) {\n if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) {\n return;\n }\n const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);\n for (const toggle of openToggles) {\n const context = Dropdown.getInstance(toggle);\n if (!context || context._config.autoClose === false) {\n continue;\n }\n const composedPath = event.composedPath();\n const isMenuTarget = composedPath.includes(context._menu);\n if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {\n continue;\n }\n\n // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu\n if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {\n continue;\n }\n const relatedTarget = {\n relatedTarget: context._element\n };\n if (event.type === 'click') {\n relatedTarget.clickEvent = event;\n }\n context._completeHide(relatedTarget);\n }\n }\n static dataApiKeydownHandler(event) {\n // If not an UP | DOWN | ESCAPE key => not a dropdown command\n // If input/textarea && if key is other than ESCAPE => not a dropdown command\n\n const isInput = /input|textarea/i.test(event.target.tagName);\n const isEscapeEvent = event.key === ESCAPE_KEY$2;\n const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key);\n if (!isUpOrDownEvent && !isEscapeEvent) {\n return;\n }\n if (isInput && !isEscapeEvent) {\n return;\n }\n event.preventDefault();\n\n // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/\n const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode);\n const instance = Dropdown.getOrCreateInstance(getToggleButton);\n if (isUpOrDownEvent) {\n event.stopPropagation();\n instance.show();\n instance._selectMenuItem(event);\n return;\n }\n if (instance._isShown()) {\n // else is escape and we check if it is shown\n event.stopPropagation();\n instance.hide();\n getToggleButton.focus();\n }\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);\nEventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);\nEventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);\nEventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);\nEventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {\n event.preventDefault();\n Dropdown.getOrCreateInstance(this).toggle();\n});\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Dropdown);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/backdrop.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$9 = 'backdrop';\nconst CLASS_NAME_FADE$4 = 'fade';\nconst CLASS_NAME_SHOW$5 = 'show';\nconst EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`;\nconst Default$8 = {\n className: 'modal-backdrop',\n clickCallback: null,\n isAnimated: false,\n isVisible: true,\n // if false, we use the backdrop helper without adding any element to the dom\n rootElement: 'body' // give the choice to place backdrop under different elements\n};\n\nconst DefaultType$8 = {\n className: 'string',\n clickCallback: '(function|null)',\n isAnimated: 'boolean',\n isVisible: 'boolean',\n rootElement: '(element|string)'\n};\n\n/**\n * Class definition\n */\n\nclass Backdrop extends Config {\n constructor(config) {\n super();\n this._config = this._getConfig(config);\n this._isAppended = false;\n this._element = null;\n }\n\n // Getters\n static get Default() {\n return Default$8;\n }\n static get DefaultType() {\n return DefaultType$8;\n }\n static get NAME() {\n return NAME$9;\n }\n\n // Public\n show(callback) {\n if (!this._config.isVisible) {\n execute(callback);\n return;\n }\n this._append();\n const element = this._getElement();\n if (this._config.isAnimated) {\n reflow(element);\n }\n element.classList.add(CLASS_NAME_SHOW$5);\n this._emulateAnimation(() => {\n execute(callback);\n });\n }\n hide(callback) {\n if (!this._config.isVisible) {\n execute(callback);\n return;\n }\n this._getElement().classList.remove(CLASS_NAME_SHOW$5);\n this._emulateAnimation(() => {\n this.dispose();\n execute(callback);\n });\n }\n dispose() {\n if (!this._isAppended) {\n return;\n }\n EventHandler.off(this._element, EVENT_MOUSEDOWN);\n this._element.remove();\n this._isAppended = false;\n }\n\n // Private\n _getElement() {\n if (!this._element) {\n const backdrop = document.createElement('div');\n backdrop.className = this._config.className;\n if (this._config.isAnimated) {\n backdrop.classList.add(CLASS_NAME_FADE$4);\n }\n this._element = backdrop;\n }\n return this._element;\n }\n _configAfterMerge(config) {\n // use getElement() with the default \"body\" to get a fresh Element on each instantiation\n config.rootElement = getElement(config.rootElement);\n return config;\n }\n _append() {\n if (this._isAppended) {\n return;\n }\n const element = this._getElement();\n this._config.rootElement.append(element);\n EventHandler.on(element, EVENT_MOUSEDOWN, () => {\n execute(this._config.clickCallback);\n });\n this._isAppended = true;\n }\n _emulateAnimation(callback) {\n executeAfterTransition(callback, this._getElement(), this._config.isAnimated);\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/focustrap.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$8 = 'focustrap';\nconst DATA_KEY$5 = 'bs.focustrap';\nconst EVENT_KEY$5 = `.${DATA_KEY$5}`;\nconst EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`;\nconst EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`;\nconst TAB_KEY = 'Tab';\nconst TAB_NAV_FORWARD = 'forward';\nconst TAB_NAV_BACKWARD = 'backward';\nconst Default$7 = {\n autofocus: true,\n trapElement: null // The element to trap focus inside of\n};\n\nconst DefaultType$7 = {\n autofocus: 'boolean',\n trapElement: 'element'\n};\n\n/**\n * Class definition\n */\n\nclass FocusTrap extends Config {\n constructor(config) {\n super();\n this._config = this._getConfig(config);\n this._isActive = false;\n this._lastTabNavDirection = null;\n }\n\n // Getters\n static get Default() {\n return Default$7;\n }\n static get DefaultType() {\n return DefaultType$7;\n }\n static get NAME() {\n return NAME$8;\n }\n\n // Public\n activate() {\n if (this._isActive) {\n return;\n }\n if (this._config.autofocus) {\n this._config.trapElement.focus();\n }\n EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop\n EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event));\n EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));\n this._isActive = true;\n }\n deactivate() {\n if (!this._isActive) {\n return;\n }\n this._isActive = false;\n EventHandler.off(document, EVENT_KEY$5);\n }\n\n // Private\n _handleFocusin(event) {\n const {\n trapElement\n } = this._config;\n if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {\n return;\n }\n const elements = SelectorEngine.focusableChildren(trapElement);\n if (elements.length === 0) {\n trapElement.focus();\n } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {\n elements[elements.length - 1].focus();\n } else {\n elements[0].focus();\n }\n }\n _handleKeydown(event) {\n if (event.key !== TAB_KEY) {\n return;\n }\n this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/scrollBar.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';\nconst SELECTOR_STICKY_CONTENT = '.sticky-top';\nconst PROPERTY_PADDING = 'padding-right';\nconst PROPERTY_MARGIN = 'margin-right';\n\n/**\n * Class definition\n */\n\nclass ScrollBarHelper {\n constructor() {\n this._element = document.body;\n }\n\n // Public\n getWidth() {\n // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes\n const documentWidth = document.documentElement.clientWidth;\n return Math.abs(window.innerWidth - documentWidth);\n }\n hide() {\n const width = this.getWidth();\n this._disableOverFlow();\n // give padding to element to balance the hidden scrollbar width\n this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width);\n // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth\n this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width);\n this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width);\n }\n reset() {\n this._resetElementAttributes(this._element, 'overflow');\n this._resetElementAttributes(this._element, PROPERTY_PADDING);\n this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);\n this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);\n }\n isOverflowing() {\n return this.getWidth() > 0;\n }\n\n // Private\n _disableOverFlow() {\n this._saveInitialAttribute(this._element, 'overflow');\n this._element.style.overflow = 'hidden';\n }\n _setElementAttributes(selector, styleProperty, callback) {\n const scrollbarWidth = this.getWidth();\n const manipulationCallBack = element => {\n if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {\n return;\n }\n this._saveInitialAttribute(element, styleProperty);\n const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);\n element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`);\n };\n this._applyManipulationCallback(selector, manipulationCallBack);\n }\n _saveInitialAttribute(element, styleProperty) {\n const actualValue = element.style.getPropertyValue(styleProperty);\n if (actualValue) {\n Manipulator.setDataAttribute(element, styleProperty, actualValue);\n }\n }\n _resetElementAttributes(selector, styleProperty) {\n const manipulationCallBack = element => {\n const value = Manipulator.getDataAttribute(element, styleProperty);\n // We only want to remove the property if the value is `null`; the value can also be zero\n if (value === null) {\n element.style.removeProperty(styleProperty);\n return;\n }\n Manipulator.removeDataAttribute(element, styleProperty);\n element.style.setProperty(styleProperty, value);\n };\n this._applyManipulationCallback(selector, manipulationCallBack);\n }\n _applyManipulationCallback(selector, callBack) {\n if (isElement(selector)) {\n callBack(selector);\n return;\n }\n for (const sel of SelectorEngine.find(selector, this._element)) {\n callBack(sel);\n }\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap modal.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$7 = 'modal';\nconst DATA_KEY$4 = 'bs.modal';\nconst EVENT_KEY$4 = `.${DATA_KEY$4}`;\nconst DATA_API_KEY$2 = '.data-api';\nconst ESCAPE_KEY$1 = 'Escape';\nconst EVENT_HIDE$4 = `hide${EVENT_KEY$4}`;\nconst EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`;\nconst EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`;\nconst EVENT_SHOW$4 = `show${EVENT_KEY$4}`;\nconst EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`;\nconst EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`;\nconst EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`;\nconst EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`;\nconst EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`;\nconst EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`;\nconst CLASS_NAME_OPEN = 'modal-open';\nconst CLASS_NAME_FADE$3 = 'fade';\nconst CLASS_NAME_SHOW$4 = 'show';\nconst CLASS_NAME_STATIC = 'modal-static';\nconst OPEN_SELECTOR$1 = '.modal.show';\nconst SELECTOR_DIALOG = '.modal-dialog';\nconst SELECTOR_MODAL_BODY = '.modal-body';\nconst SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle=\"modal\"]';\nconst Default$6 = {\n backdrop: true,\n focus: true,\n keyboard: true\n};\nconst DefaultType$6 = {\n backdrop: '(boolean|string)',\n focus: 'boolean',\n keyboard: 'boolean'\n};\n\n/**\n * Class definition\n */\n\nclass Modal extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);\n this._backdrop = this._initializeBackDrop();\n this._focustrap = this._initializeFocusTrap();\n this._isShown = false;\n this._isTransitioning = false;\n this._scrollBar = new ScrollBarHelper();\n this._addEventListeners();\n }\n\n // Getters\n static get Default() {\n return Default$6;\n }\n static get DefaultType() {\n return DefaultType$6;\n }\n static get NAME() {\n return NAME$7;\n }\n\n // Public\n toggle(relatedTarget) {\n return this._isShown ? this.hide() : this.show(relatedTarget);\n }\n show(relatedTarget) {\n if (this._isShown || this._isTransitioning) {\n return;\n }\n const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, {\n relatedTarget\n });\n if (showEvent.defaultPrevented) {\n return;\n }\n this._isShown = true;\n this._isTransitioning = true;\n this._scrollBar.hide();\n document.body.classList.add(CLASS_NAME_OPEN);\n this._adjustDialog();\n this._backdrop.show(() => this._showElement(relatedTarget));\n }\n hide() {\n if (!this._isShown || this._isTransitioning) {\n return;\n }\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);\n if (hideEvent.defaultPrevented) {\n return;\n }\n this._isShown = false;\n this._isTransitioning = true;\n this._focustrap.deactivate();\n this._element.classList.remove(CLASS_NAME_SHOW$4);\n this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());\n }\n dispose() {\n EventHandler.off(window, EVENT_KEY$4);\n EventHandler.off(this._dialog, EVENT_KEY$4);\n this._backdrop.dispose();\n this._focustrap.deactivate();\n super.dispose();\n }\n handleUpdate() {\n this._adjustDialog();\n }\n\n // Private\n _initializeBackDrop() {\n return new Backdrop({\n isVisible: Boolean(this._config.backdrop),\n // 'static' option will be translated to true, and booleans will keep their value,\n isAnimated: this._isAnimated()\n });\n }\n _initializeFocusTrap() {\n return new FocusTrap({\n trapElement: this._element\n });\n }\n _showElement(relatedTarget) {\n // try to append dynamic modal\n if (!document.body.contains(this._element)) {\n document.body.append(this._element);\n }\n this._element.style.display = 'block';\n this._element.removeAttribute('aria-hidden');\n this._element.setAttribute('aria-modal', true);\n this._element.setAttribute('role', 'dialog');\n this._element.scrollTop = 0;\n const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);\n if (modalBody) {\n modalBody.scrollTop = 0;\n }\n reflow(this._element);\n this._element.classList.add(CLASS_NAME_SHOW$4);\n const transitionComplete = () => {\n if (this._config.focus) {\n this._focustrap.activate();\n }\n this._isTransitioning = false;\n EventHandler.trigger(this._element, EVENT_SHOWN$4, {\n relatedTarget\n });\n };\n this._queueCallback(transitionComplete, this._dialog, this._isAnimated());\n }\n _addEventListeners() {\n EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {\n if (event.key !== ESCAPE_KEY$1) {\n return;\n }\n if (this._config.keyboard) {\n this.hide();\n return;\n }\n this._triggerBackdropTransition();\n });\n EventHandler.on(window, EVENT_RESIZE$1, () => {\n if (this._isShown && !this._isTransitioning) {\n this._adjustDialog();\n }\n });\n EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => {\n // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks\n EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => {\n if (this._element !== event.target || this._element !== event2.target) {\n return;\n }\n if (this._config.backdrop === 'static') {\n this._triggerBackdropTransition();\n return;\n }\n if (this._config.backdrop) {\n this.hide();\n }\n });\n });\n }\n _hideModal() {\n this._element.style.display = 'none';\n this._element.setAttribute('aria-hidden', true);\n this._element.removeAttribute('aria-modal');\n this._element.removeAttribute('role');\n this._isTransitioning = false;\n this._backdrop.hide(() => {\n document.body.classList.remove(CLASS_NAME_OPEN);\n this._resetAdjustments();\n this._scrollBar.reset();\n EventHandler.trigger(this._element, EVENT_HIDDEN$4);\n });\n }\n _isAnimated() {\n return this._element.classList.contains(CLASS_NAME_FADE$3);\n }\n _triggerBackdropTransition() {\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1);\n if (hideEvent.defaultPrevented) {\n return;\n }\n const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;\n const initialOverflowY = this._element.style.overflowY;\n // return if the following background transition hasn't yet completed\n if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {\n return;\n }\n if (!isModalOverflowing) {\n this._element.style.overflowY = 'hidden';\n }\n this._element.classList.add(CLASS_NAME_STATIC);\n this._queueCallback(() => {\n this._element.classList.remove(CLASS_NAME_STATIC);\n this._queueCallback(() => {\n this._element.style.overflowY = initialOverflowY;\n }, this._dialog);\n }, this._dialog);\n this._element.focus();\n }\n\n /**\n * The following methods are used to handle overflowing modals\n */\n\n _adjustDialog() {\n const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;\n const scrollbarWidth = this._scrollBar.getWidth();\n const isBodyOverflowing = scrollbarWidth > 0;\n if (isBodyOverflowing && !isModalOverflowing) {\n const property = isRTL() ? 'paddingLeft' : 'paddingRight';\n this._element.style[property] = `${scrollbarWidth}px`;\n }\n if (!isBodyOverflowing && isModalOverflowing) {\n const property = isRTL() ? 'paddingRight' : 'paddingLeft';\n this._element.style[property] = `${scrollbarWidth}px`;\n }\n }\n _resetAdjustments() {\n this._element.style.paddingLeft = '';\n this._element.style.paddingRight = '';\n }\n\n // Static\n static jQueryInterface(config, relatedTarget) {\n return this.each(function () {\n const data = Modal.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config](relatedTarget);\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {\n const target = SelectorEngine.getElementFromSelector(this);\n if (['A', 'AREA'].includes(this.tagName)) {\n event.preventDefault();\n }\n EventHandler.one(target, EVENT_SHOW$4, showEvent => {\n if (showEvent.defaultPrevented) {\n // only register focus restorer if modal will actually get shown\n return;\n }\n EventHandler.one(target, EVENT_HIDDEN$4, () => {\n if (isVisible(this)) {\n this.focus();\n }\n });\n });\n\n // avoid conflict when clicking modal toggler while another one is open\n const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);\n if (alreadyOpen) {\n Modal.getInstance(alreadyOpen).hide();\n }\n const data = Modal.getOrCreateInstance(target);\n data.toggle(this);\n});\nenableDismissTrigger(Modal);\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Modal);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap offcanvas.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$6 = 'offcanvas';\nconst DATA_KEY$3 = 'bs.offcanvas';\nconst EVENT_KEY$3 = `.${DATA_KEY$3}`;\nconst DATA_API_KEY$1 = '.data-api';\nconst EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`;\nconst ESCAPE_KEY = 'Escape';\nconst CLASS_NAME_SHOW$3 = 'show';\nconst CLASS_NAME_SHOWING$1 = 'showing';\nconst CLASS_NAME_HIDING = 'hiding';\nconst CLASS_NAME_BACKDROP = 'offcanvas-backdrop';\nconst OPEN_SELECTOR = '.offcanvas.show';\nconst EVENT_SHOW$3 = `show${EVENT_KEY$3}`;\nconst EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`;\nconst EVENT_HIDE$3 = `hide${EVENT_KEY$3}`;\nconst EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`;\nconst EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`;\nconst EVENT_RESIZE = `resize${EVENT_KEY$3}`;\nconst EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`;\nconst EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`;\nconst SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle=\"offcanvas\"]';\nconst Default$5 = {\n backdrop: true,\n keyboard: true,\n scroll: false\n};\nconst DefaultType$5 = {\n backdrop: '(boolean|string)',\n keyboard: 'boolean',\n scroll: 'boolean'\n};\n\n/**\n * Class definition\n */\n\nclass Offcanvas extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n this._isShown = false;\n this._backdrop = this._initializeBackDrop();\n this._focustrap = this._initializeFocusTrap();\n this._addEventListeners();\n }\n\n // Getters\n static get Default() {\n return Default$5;\n }\n static get DefaultType() {\n return DefaultType$5;\n }\n static get NAME() {\n return NAME$6;\n }\n\n // Public\n toggle(relatedTarget) {\n return this._isShown ? this.hide() : this.show(relatedTarget);\n }\n show(relatedTarget) {\n if (this._isShown) {\n return;\n }\n const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {\n relatedTarget\n });\n if (showEvent.defaultPrevented) {\n return;\n }\n this._isShown = true;\n this._backdrop.show();\n if (!this._config.scroll) {\n new ScrollBarHelper().hide();\n }\n this._element.setAttribute('aria-modal', true);\n this._element.setAttribute('role', 'dialog');\n this._element.classList.add(CLASS_NAME_SHOWING$1);\n const completeCallBack = () => {\n if (!this._config.scroll || this._config.backdrop) {\n this._focustrap.activate();\n }\n this._element.classList.add(CLASS_NAME_SHOW$3);\n this._element.classList.remove(CLASS_NAME_SHOWING$1);\n EventHandler.trigger(this._element, EVENT_SHOWN$3, {\n relatedTarget\n });\n };\n this._queueCallback(completeCallBack, this._element, true);\n }\n hide() {\n if (!this._isShown) {\n return;\n }\n const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);\n if (hideEvent.defaultPrevented) {\n return;\n }\n this._focustrap.deactivate();\n this._element.blur();\n this._isShown = false;\n this._element.classList.add(CLASS_NAME_HIDING);\n this._backdrop.hide();\n const completeCallback = () => {\n this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING);\n this._element.removeAttribute('aria-modal');\n this._element.removeAttribute('role');\n if (!this._config.scroll) {\n new ScrollBarHelper().reset();\n }\n EventHandler.trigger(this._element, EVENT_HIDDEN$3);\n };\n this._queueCallback(completeCallback, this._element, true);\n }\n dispose() {\n this._backdrop.dispose();\n this._focustrap.deactivate();\n super.dispose();\n }\n\n // Private\n _initializeBackDrop() {\n const clickCallback = () => {\n if (this._config.backdrop === 'static') {\n EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);\n return;\n }\n this.hide();\n };\n\n // 'static' option will be translated to true, and booleans will keep their value\n const isVisible = Boolean(this._config.backdrop);\n return new Backdrop({\n className: CLASS_NAME_BACKDROP,\n isVisible,\n isAnimated: true,\n rootElement: this._element.parentNode,\n clickCallback: isVisible ? clickCallback : null\n });\n }\n _initializeFocusTrap() {\n return new FocusTrap({\n trapElement: this._element\n });\n }\n _addEventListeners() {\n EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {\n if (event.key !== ESCAPE_KEY) {\n return;\n }\n if (this._config.keyboard) {\n this.hide();\n return;\n }\n EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);\n });\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Offcanvas.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config](this);\n });\n }\n}\n\n/**\n * Data API implementation\n */\n\nEventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {\n const target = SelectorEngine.getElementFromSelector(this);\n if (['A', 'AREA'].includes(this.tagName)) {\n event.preventDefault();\n }\n if (isDisabled(this)) {\n return;\n }\n EventHandler.one(target, EVENT_HIDDEN$3, () => {\n // focus on trigger when it is closed\n if (isVisible(this)) {\n this.focus();\n }\n });\n\n // avoid conflict when clicking a toggler of an offcanvas, while another is open\n const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);\n if (alreadyOpen && alreadyOpen !== target) {\n Offcanvas.getInstance(alreadyOpen).hide();\n }\n const data = Offcanvas.getOrCreateInstance(target);\n data.toggle(this);\n});\nEventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {\n for (const selector of SelectorEngine.find(OPEN_SELECTOR)) {\n Offcanvas.getOrCreateInstance(selector).show();\n }\n});\nEventHandler.on(window, EVENT_RESIZE, () => {\n for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) {\n if (getComputedStyle(element).position !== 'fixed') {\n Offcanvas.getOrCreateInstance(element).hide();\n }\n }\n});\nenableDismissTrigger(Offcanvas);\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Offcanvas);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/sanitizer.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n// js-docs-start allow-list\nconst ARIA_ATTRIBUTE_PATTERN = /^aria-[\\w-]*$/i;\nconst DefaultAllowlist = {\n // Global attributes allowed on any supplied element below.\n '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],\n a: ['target', 'href', 'title', 'rel'],\n area: [],\n b: [],\n br: [],\n col: [],\n code: [],\n div: [],\n em: [],\n hr: [],\n h1: [],\n h2: [],\n h3: [],\n h4: [],\n h5: [],\n h6: [],\n i: [],\n img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],\n li: [],\n ol: [],\n p: [],\n pre: [],\n s: [],\n small: [],\n span: [],\n sub: [],\n sup: [],\n strong: [],\n u: [],\n ul: []\n};\n// js-docs-end allow-list\n\nconst uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);\n\n/**\n * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation\n * contexts.\n *\n * Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38\n */\n// eslint-disable-next-line unicorn/better-regex\nconst SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i;\nconst allowedAttribute = (attribute, allowedAttributeList) => {\n const attributeName = attribute.nodeName.toLowerCase();\n if (allowedAttributeList.includes(attributeName)) {\n if (uriAttributes.has(attributeName)) {\n return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue));\n }\n return true;\n }\n\n // Check if a regular expression validates the attribute.\n return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName));\n};\nfunction sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {\n if (!unsafeHtml.length) {\n return unsafeHtml;\n }\n if (sanitizeFunction && typeof sanitizeFunction === 'function') {\n return sanitizeFunction(unsafeHtml);\n }\n const domParser = new window.DOMParser();\n const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');\n const elements = [].concat(...createdDocument.body.querySelectorAll('*'));\n for (const element of elements) {\n const elementName = element.nodeName.toLowerCase();\n if (!Object.keys(allowList).includes(elementName)) {\n element.remove();\n continue;\n }\n const attributeList = [].concat(...element.attributes);\n const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);\n for (const attribute of attributeList) {\n if (!allowedAttribute(attribute, allowedAttributes)) {\n element.removeAttribute(attribute.nodeName);\n }\n }\n }\n return createdDocument.body.innerHTML;\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap util/template-factory.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$5 = 'TemplateFactory';\nconst Default$4 = {\n allowList: DefaultAllowlist,\n content: {},\n // { selector : text , selector2 : text2 , }\n extraClass: '',\n html: false,\n sanitize: true,\n sanitizeFn: null,\n template: '
'\n};\nconst DefaultType$4 = {\n allowList: 'object',\n content: 'object',\n extraClass: '(string|function)',\n html: 'boolean',\n sanitize: 'boolean',\n sanitizeFn: '(null|function)',\n template: 'string'\n};\nconst DefaultContentType = {\n entry: '(string|element|function|null)',\n selector: '(string|element)'\n};\n\n/**\n * Class definition\n */\n\nclass TemplateFactory extends Config {\n constructor(config) {\n super();\n this._config = this._getConfig(config);\n }\n\n // Getters\n static get Default() {\n return Default$4;\n }\n static get DefaultType() {\n return DefaultType$4;\n }\n static get NAME() {\n return NAME$5;\n }\n\n // Public\n getContent() {\n return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean);\n }\n hasContent() {\n return this.getContent().length > 0;\n }\n changeContent(content) {\n this._checkContent(content);\n this._config.content = {\n ...this._config.content,\n ...content\n };\n return this;\n }\n toHtml() {\n const templateWrapper = document.createElement('div');\n templateWrapper.innerHTML = this._maybeSanitize(this._config.template);\n for (const [selector, text] of Object.entries(this._config.content)) {\n this._setContent(templateWrapper, text, selector);\n }\n const template = templateWrapper.children[0];\n const extraClass = this._resolvePossibleFunction(this._config.extraClass);\n if (extraClass) {\n template.classList.add(...extraClass.split(' '));\n }\n return template;\n }\n\n // Private\n _typeCheckConfig(config) {\n super._typeCheckConfig(config);\n this._checkContent(config.content);\n }\n _checkContent(arg) {\n for (const [selector, content] of Object.entries(arg)) {\n super._typeCheckConfig({\n selector,\n entry: content\n }, DefaultContentType);\n }\n }\n _setContent(template, content, selector) {\n const templateElement = SelectorEngine.findOne(selector, template);\n if (!templateElement) {\n return;\n }\n content = this._resolvePossibleFunction(content);\n if (!content) {\n templateElement.remove();\n return;\n }\n if (isElement(content)) {\n this._putElementInTemplate(getElement(content), templateElement);\n return;\n }\n if (this._config.html) {\n templateElement.innerHTML = this._maybeSanitize(content);\n return;\n }\n templateElement.textContent = content;\n }\n _maybeSanitize(arg) {\n return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg;\n }\n _resolvePossibleFunction(arg) {\n return execute(arg, [this]);\n }\n _putElementInTemplate(element, templateElement) {\n if (this._config.html) {\n templateElement.innerHTML = '';\n templateElement.append(element);\n return;\n }\n templateElement.textContent = element.textContent;\n }\n}\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap tooltip.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$4 = 'tooltip';\nconst DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);\nconst CLASS_NAME_FADE$2 = 'fade';\nconst CLASS_NAME_MODAL = 'modal';\nconst CLASS_NAME_SHOW$2 = 'show';\nconst SELECTOR_TOOLTIP_INNER = '.tooltip-inner';\nconst SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;\nconst EVENT_MODAL_HIDE = 'hide.bs.modal';\nconst TRIGGER_HOVER = 'hover';\nconst TRIGGER_FOCUS = 'focus';\nconst TRIGGER_CLICK = 'click';\nconst TRIGGER_MANUAL = 'manual';\nconst EVENT_HIDE$2 = 'hide';\nconst EVENT_HIDDEN$2 = 'hidden';\nconst EVENT_SHOW$2 = 'show';\nconst EVENT_SHOWN$2 = 'shown';\nconst EVENT_INSERTED = 'inserted';\nconst EVENT_CLICK$1 = 'click';\nconst EVENT_FOCUSIN$1 = 'focusin';\nconst EVENT_FOCUSOUT$1 = 'focusout';\nconst EVENT_MOUSEENTER = 'mouseenter';\nconst EVENT_MOUSELEAVE = 'mouseleave';\nconst AttachmentMap = {\n AUTO: 'auto',\n TOP: 'top',\n RIGHT: isRTL() ? 'left' : 'right',\n BOTTOM: 'bottom',\n LEFT: isRTL() ? 'right' : 'left'\n};\nconst Default$3 = {\n allowList: DefaultAllowlist,\n animation: true,\n boundary: 'clippingParents',\n container: false,\n customClass: '',\n delay: 0,\n fallbackPlacements: ['top', 'right', 'bottom', 'left'],\n html: false,\n offset: [0, 6],\n placement: 'top',\n popperConfig: null,\n sanitize: true,\n sanitizeFn: null,\n selector: false,\n template: '
' + '
' + '
' + '
',\n title: '',\n trigger: 'hover focus'\n};\nconst DefaultType$3 = {\n allowList: 'object',\n animation: 'boolean',\n boundary: '(string|element)',\n container: '(string|element|boolean)',\n customClass: '(string|function)',\n delay: '(number|object)',\n fallbackPlacements: 'array',\n html: 'boolean',\n offset: '(array|string|function)',\n placement: '(string|function)',\n popperConfig: '(null|object|function)',\n sanitize: 'boolean',\n sanitizeFn: '(null|function)',\n selector: '(string|boolean)',\n template: 'string',\n title: '(string|element|function)',\n trigger: 'string'\n};\n\n/**\n * Class definition\n */\n\nclass Tooltip extends BaseComponent {\n constructor(element, config) {\n if (typeof Popper === 'undefined') {\n throw new TypeError('Bootstrap\\'s tooltips require Popper (https://popper.js.org)');\n }\n super(element, config);\n\n // Private\n this._isEnabled = true;\n this._timeout = 0;\n this._isHovered = null;\n this._activeTrigger = {};\n this._popper = null;\n this._templateFactory = null;\n this._newContent = null;\n\n // Protected\n this.tip = null;\n this._setListeners();\n if (!this._config.selector) {\n this._fixTitle();\n }\n }\n\n // Getters\n static get Default() {\n return Default$3;\n }\n static get DefaultType() {\n return DefaultType$3;\n }\n static get NAME() {\n return NAME$4;\n }\n\n // Public\n enable() {\n this._isEnabled = true;\n }\n disable() {\n this._isEnabled = false;\n }\n toggleEnabled() {\n this._isEnabled = !this._isEnabled;\n }\n toggle() {\n if (!this._isEnabled) {\n return;\n }\n this._activeTrigger.click = !this._activeTrigger.click;\n if (this._isShown()) {\n this._leave();\n return;\n }\n this._enter();\n }\n dispose() {\n clearTimeout(this._timeout);\n EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);\n if (this._element.getAttribute('data-bs-original-title')) {\n this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'));\n }\n this._disposePopper();\n super.dispose();\n }\n show() {\n if (this._element.style.display === 'none') {\n throw new Error('Please use show on visible elements');\n }\n if (!(this._isWithContent() && this._isEnabled)) {\n return;\n }\n const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2));\n const shadowRoot = findShadowRoot(this._element);\n const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element);\n if (showEvent.defaultPrevented || !isInTheDom) {\n return;\n }\n\n // TODO: v6 remove this or make it optional\n this._disposePopper();\n const tip = this._getTipElement();\n this._element.setAttribute('aria-describedby', tip.getAttribute('id'));\n const {\n container\n } = this._config;\n if (!this._element.ownerDocument.documentElement.contains(this.tip)) {\n container.append(tip);\n EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED));\n }\n this._popper = this._createPopper(tip);\n tip.classList.add(CLASS_NAME_SHOW$2);\n\n // If this is a touch-enabled device we add extra\n // empty mouseover listeners to the body's immediate children;\n // only needed because of broken event delegation on iOS\n // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html\n if ('ontouchstart' in document.documentElement) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.on(element, 'mouseover', noop);\n }\n }\n const complete = () => {\n EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2));\n if (this._isHovered === false) {\n this._leave();\n }\n this._isHovered = false;\n };\n this._queueCallback(complete, this.tip, this._isAnimated());\n }\n hide() {\n if (!this._isShown()) {\n return;\n }\n const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));\n if (hideEvent.defaultPrevented) {\n return;\n }\n const tip = this._getTipElement();\n tip.classList.remove(CLASS_NAME_SHOW$2);\n\n // If this is a touch-enabled device we remove the extra\n // empty mouseover listeners we added for iOS support\n if ('ontouchstart' in document.documentElement) {\n for (const element of [].concat(...document.body.children)) {\n EventHandler.off(element, 'mouseover', noop);\n }\n }\n this._activeTrigger[TRIGGER_CLICK] = false;\n this._activeTrigger[TRIGGER_FOCUS] = false;\n this._activeTrigger[TRIGGER_HOVER] = false;\n this._isHovered = null; // it is a trick to support manual triggering\n\n const complete = () => {\n if (this._isWithActiveTrigger()) {\n return;\n }\n if (!this._isHovered) {\n this._disposePopper();\n }\n this._element.removeAttribute('aria-describedby');\n EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2));\n };\n this._queueCallback(complete, this.tip, this._isAnimated());\n }\n update() {\n if (this._popper) {\n this._popper.update();\n }\n }\n\n // Protected\n _isWithContent() {\n return Boolean(this._getTitle());\n }\n _getTipElement() {\n if (!this.tip) {\n this.tip = this._createTipElement(this._newContent || this._getContentForTemplate());\n }\n return this.tip;\n }\n _createTipElement(content) {\n const tip = this._getTemplateFactory(content).toHtml();\n\n // TODO: remove this check in v6\n if (!tip) {\n return null;\n }\n tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);\n // TODO: v6 the following can be achieved with CSS only\n tip.classList.add(`bs-${this.constructor.NAME}-auto`);\n const tipId = getUID(this.constructor.NAME).toString();\n tip.setAttribute('id', tipId);\n if (this._isAnimated()) {\n tip.classList.add(CLASS_NAME_FADE$2);\n }\n return tip;\n }\n setContent(content) {\n this._newContent = content;\n if (this._isShown()) {\n this._disposePopper();\n this.show();\n }\n }\n _getTemplateFactory(content) {\n if (this._templateFactory) {\n this._templateFactory.changeContent(content);\n } else {\n this._templateFactory = new TemplateFactory({\n ...this._config,\n // the `content` var has to be after `this._config`\n // to override config.content in case of popover\n content,\n extraClass: this._resolvePossibleFunction(this._config.customClass)\n });\n }\n return this._templateFactory;\n }\n _getContentForTemplate() {\n return {\n [SELECTOR_TOOLTIP_INNER]: this._getTitle()\n };\n }\n _getTitle() {\n return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title');\n }\n\n // Private\n _initializeOnDelegatedTarget(event) {\n return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());\n }\n _isAnimated() {\n return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2);\n }\n _isShown() {\n return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2);\n }\n _createPopper(tip) {\n const placement = execute(this._config.placement, [this, tip, this._element]);\n const attachment = AttachmentMap[placement.toUpperCase()];\n return Popper.createPopper(this._element, tip, this._getPopperConfig(attachment));\n }\n _getOffset() {\n const {\n offset\n } = this._config;\n if (typeof offset === 'string') {\n return offset.split(',').map(value => Number.parseInt(value, 10));\n }\n if (typeof offset === 'function') {\n return popperData => offset(popperData, this._element);\n }\n return offset;\n }\n _resolvePossibleFunction(arg) {\n return execute(arg, [this._element]);\n }\n _getPopperConfig(attachment) {\n const defaultBsPopperConfig = {\n placement: attachment,\n modifiers: [{\n name: 'flip',\n options: {\n fallbackPlacements: this._config.fallbackPlacements\n }\n }, {\n name: 'offset',\n options: {\n offset: this._getOffset()\n }\n }, {\n name: 'preventOverflow',\n options: {\n boundary: this._config.boundary\n }\n }, {\n name: 'arrow',\n options: {\n element: `.${this.constructor.NAME}-arrow`\n }\n }, {\n name: 'preSetPlacement',\n enabled: true,\n phase: 'beforeMain',\n fn: data => {\n // Pre-set Popper's placement attribute in order to read the arrow sizes properly.\n // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement\n this._getTipElement().setAttribute('data-popper-placement', data.state.placement);\n }\n }]\n };\n return {\n ...defaultBsPopperConfig,\n ...execute(this._config.popperConfig, [defaultBsPopperConfig])\n };\n }\n _setListeners() {\n const triggers = this._config.trigger.split(' ');\n for (const trigger of triggers) {\n if (trigger === 'click') {\n EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => {\n const context = this._initializeOnDelegatedTarget(event);\n context.toggle();\n });\n } else if (trigger !== TRIGGER_MANUAL) {\n const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1);\n const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1);\n EventHandler.on(this._element, eventIn, this._config.selector, event => {\n const context = this._initializeOnDelegatedTarget(event);\n context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;\n context._enter();\n });\n EventHandler.on(this._element, eventOut, this._config.selector, event => {\n const context = this._initializeOnDelegatedTarget(event);\n context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);\n context._leave();\n });\n }\n }\n this._hideModalHandler = () => {\n if (this._element) {\n this.hide();\n }\n };\n EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);\n }\n _fixTitle() {\n const title = this._element.getAttribute('title');\n if (!title) {\n return;\n }\n if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) {\n this._element.setAttribute('aria-label', title);\n }\n this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility\n this._element.removeAttribute('title');\n }\n _enter() {\n if (this._isShown() || this._isHovered) {\n this._isHovered = true;\n return;\n }\n this._isHovered = true;\n this._setTimeout(() => {\n if (this._isHovered) {\n this.show();\n }\n }, this._config.delay.show);\n }\n _leave() {\n if (this._isWithActiveTrigger()) {\n return;\n }\n this._isHovered = false;\n this._setTimeout(() => {\n if (!this._isHovered) {\n this.hide();\n }\n }, this._config.delay.hide);\n }\n _setTimeout(handler, timeout) {\n clearTimeout(this._timeout);\n this._timeout = setTimeout(handler, timeout);\n }\n _isWithActiveTrigger() {\n return Object.values(this._activeTrigger).includes(true);\n }\n _getConfig(config) {\n const dataAttributes = Manipulator.getDataAttributes(this._element);\n for (const dataAttribute of Object.keys(dataAttributes)) {\n if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {\n delete dataAttributes[dataAttribute];\n }\n }\n config = {\n ...dataAttributes,\n ...(typeof config === 'object' && config ? config : {})\n };\n config = this._mergeConfigObj(config);\n config = this._configAfterMerge(config);\n this._typeCheckConfig(config);\n return config;\n }\n _configAfterMerge(config) {\n config.container = config.container === false ? document.body : getElement(config.container);\n if (typeof config.delay === 'number') {\n config.delay = {\n show: config.delay,\n hide: config.delay\n };\n }\n if (typeof config.title === 'number') {\n config.title = config.title.toString();\n }\n if (typeof config.content === 'number') {\n config.content = config.content.toString();\n }\n return config;\n }\n _getDelegateConfig() {\n const config = {};\n for (const [key, value] of Object.entries(this._config)) {\n if (this.constructor.Default[key] !== value) {\n config[key] = value;\n }\n }\n config.selector = false;\n config.trigger = 'manual';\n\n // In the future can be replaced with:\n // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])\n // `Object.fromEntries(keysWithDifferentValues)`\n return config;\n }\n _disposePopper() {\n if (this._popper) {\n this._popper.destroy();\n this._popper = null;\n }\n if (this.tip) {\n this.tip.remove();\n this.tip = null;\n }\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Tooltip.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n });\n }\n}\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Tooltip);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap popover.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$3 = 'popover';\nconst SELECTOR_TITLE = '.popover-header';\nconst SELECTOR_CONTENT = '.popover-body';\nconst Default$2 = {\n ...Tooltip.Default,\n content: '',\n offset: [0, 8],\n placement: 'right',\n template: '
' + '
' + '

' + '
' + '
',\n trigger: 'click'\n};\nconst DefaultType$2 = {\n ...Tooltip.DefaultType,\n content: '(null|string|element|function)'\n};\n\n/**\n * Class definition\n */\n\nclass Popover extends Tooltip {\n // Getters\n static get Default() {\n return Default$2;\n }\n static get DefaultType() {\n return DefaultType$2;\n }\n static get NAME() {\n return NAME$3;\n }\n\n // Overrides\n _isWithContent() {\n return this._getTitle() || this._getContent();\n }\n\n // Private\n _getContentForTemplate() {\n return {\n [SELECTOR_TITLE]: this._getTitle(),\n [SELECTOR_CONTENT]: this._getContent()\n };\n }\n _getContent() {\n return this._resolvePossibleFunction(this._config.content);\n }\n\n // Static\n static jQueryInterface(config) {\n return this.each(function () {\n const data = Popover.getOrCreateInstance(this, config);\n if (typeof config !== 'string') {\n return;\n }\n if (typeof data[config] === 'undefined') {\n throw new TypeError(`No method named \"${config}\"`);\n }\n data[config]();\n });\n }\n}\n\n/**\n * jQuery\n */\n\ndefineJQueryPlugin(Popover);\n\n/**\n * --------------------------------------------------------------------------\n * Bootstrap scrollspy.js\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n * --------------------------------------------------------------------------\n */\n\n\n/**\n * Constants\n */\n\nconst NAME$2 = 'scrollspy';\nconst DATA_KEY$2 = 'bs.scrollspy';\nconst EVENT_KEY$2 = `.${DATA_KEY$2}`;\nconst DATA_API_KEY = '.data-api';\nconst EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;\nconst EVENT_CLICK = `click${EVENT_KEY$2}`;\nconst EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`;\nconst CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';\nconst CLASS_NAME_ACTIVE$1 = 'active';\nconst SELECTOR_DATA_SPY = '[data-bs-spy=\"scroll\"]';\nconst SELECTOR_TARGET_LINKS = '[href]';\nconst SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';\nconst SELECTOR_NAV_LINKS = '.nav-link';\nconst SELECTOR_NAV_ITEMS = '.nav-item';\nconst SELECTOR_LIST_ITEMS = '.list-group-item';\nconst SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;\nconst SELECTOR_DROPDOWN = '.dropdown';\nconst SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';\nconst Default$1 = {\n offset: null,\n // TODO: v6 @deprecated, keep it for backwards compatibility reasons\n rootMargin: '0px 0px -25%',\n smoothScroll: false,\n target: null,\n threshold: [0.1, 0.5, 1]\n};\nconst DefaultType$1 = {\n offset: '(number|null)',\n // TODO v6 @deprecated, keep it for backwards compatibility reasons\n rootMargin: 'string',\n smoothScroll: 'boolean',\n target: 'element',\n threshold: 'array'\n};\n\n/**\n * Class definition\n */\n\nclass ScrollSpy extends BaseComponent {\n constructor(element, config) {\n super(element, config);\n\n // this._element is the observablesContainer and config.target the menu links wrapper\n this._targetLinks = new Map();\n this._observableSections = new Map();\n this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element;\n this._activeTarget = null;\n this._observer = null;\n this._previousScrollData = {\n visibleEntryTop: 0,\n parentScrollTop: 0\n };\n this.refresh(); // initialize\n }\n\n // Getters\n static get Default() {\n return Default$1;\n }\n static get DefaultType() {\n return DefaultType$1;\n }\n static get NAME() {\n return NAME$2;\n }\n\n // Public\n refresh() {\n this._initializeTargetsAndObservables();\n this._maybeEnableSmoothScroll();\n if (this._observer) {\n this._observer.disconnect();\n } else {\n this._observer = this._getNewObserver();\n }\n for (const section of this._observableSections.values()) {\n this._observer.observe(section);\n }\n }\n dispose() {\n this._observer.disconnect();\n super.dispose();\n }\n\n // Private\n _configAfterMerge(config) {\n // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case\n config.target = getElement(config.target) || document.body;\n\n // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only\n config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin;\n if (typeof config.threshold === 'string') {\n config.threshold = config.threshold.split(',').map(value => Number.parseFloat(value));\n }\n return config;\n }\n _maybeEnableSmoothScroll() {\n if (!this._config.smoothScroll) {\n return;\n }\n\n // unregister any previous listeners\n EventHandler.off(this._config.target, EVENT_CLICK);\n EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => {\n const observableSection = this._observableSections.get(event.target.hash);\n if (observableSection) {\n event.preventDefault();\n const root = this._rootElement || window;\n const height = observableSection.offsetTop - this._element.offsetTop;\n if (root.scrollTo) {\n root.scrollTo({\n top: height,\n behavior: 'smooth'\n });\n return;\n }\n\n // Chrome 60 doesn't support `scrollTo`\n root.scrollTop = height;\n }\n });\n }\n _getNewObserver() {\n const options = {\n root: this._rootElement,\n threshold: this._config.threshold,\n rootMargin: this._config.rootMargin\n };\n return new IntersectionObserver(entries => this._observerCallback(entries), options);\n }\n\n // The logic of selection\n _observerCallback(entries) {\n const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`);\n const activate = entry => {\n this._previousScrollData.visibleEntryTop = entry.target.offsetTop;\n this._process(targetElement(entry));\n };\n const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;\n const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;\n this._previousScrollData.parentScrollTop = parentScrollTop;\n for (const entry of entries) {\n if (!entry.isIntersecting) {\n this._activeTarget = null;\n this._clearActiveClass(targetElement(entry));\n continue;\n }\n const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop;\n // if we are scrolling down, pick the bigger offsetTop\n if (userScrollsDown && entryIsLowerThanPrevious) {\n activate(entry);\n // if parent isn't scrolled, let's keep the first visible item, breaking the iteration\n if (!parentScrollTop) {\n return;\n }\n continue;\n }\n\n // if we are scrolling up, pick the smallest offsetTop\n if (!userScrollsDown && !entryIsLowerThanPrevious) {\n activate(entry);\n }\n }\n }\n _initializeTargetsAndObservables() {\n this._targetLinks = new Map();\n this._observableSections = new Map();\n const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target);\n for (const anchor of targetLinks) {\n // ensure that the anchor has an id and is not disabled\n if (!anchor.hash || isDisabled(anchor)) {\n continue;\n }\n const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element);\n\n // ensure that the observableSection exists & is visible\n if (isVisible(observableSection)) {\n this._targetLinks.set(decodeURI(anchor.hash), anchor);\n this._observableSections.set(anchor.hash, observableSection);\n }\n }\n }\n _process(target) {\n if (this._activeTarget === target) {\n return;\n }\n this._clearActiveClass(this._config.target);\n this._activeTarget = target;\n target.classList.add(CLASS_NAME_ACTIVE$1);\n this._activateParents(target);\n EventHandler.trigger(this._element, EVENT_ACTIVATE, {\n relatedTarget: target\n });\n }\n _activateParents(target) {\n // Activate dropdown parents\n if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {\n SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1);\n return;\n }\n for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {\n // Set triggered links parents as active\n // With both